sjs/media
1
0
Fork 0
mirror of https://github.com/samsonjs/media.git synced 2026-04-04 11:05:47 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Rename TrackRenderer -> Renderer

Browse source 
-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=127065122
This commit is contained in:
olly 2016-07-11 02:08:17 -07:00 committed by Oliver Woodman
parent 8e0354c0a6
commit 9558a4cb99
41 changed files with 579 additions and 609 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
demo/src/main/java/com/google/android/exoplayer2/demo/EventLogger.java
View file

@ -22,10 +22,10 @@ import com.google.android.exoplayer2.DefaultTrackSelector.TrackInfo;
import com.google.android.exoplayer2.ExoPlaybackException;
import com.google.android.exoplayer2.ExoPlayer;
import com.google.android.exoplayer2.Format;
import com.google.android.exoplayer2.Renderer;
import com.google.android.exoplayer2.SimpleExoPlayer;
import com.google.android.exoplayer2.TrackGroup;
import com.google.android.exoplayer2.TrackGroupArray;
import com.google.android.exoplayer2.TrackRenderer;
import com.google.android.exoplayer2.TrackSelection;
import com.google.android.exoplayer2.drm.StreamingDrmSessionManager;
import com.google.android.exoplayer2.extractor.ExtractorMediaSource;
@ -130,7 +130,7 @@ public class EventLogger implements ExoPlayer.EventListener, SimpleExoPlayer.Deb
TrackGroup trackGroup = trackGroups.get(groupIndex);
for (int trackIndex = 0; trackIndex < trackGroup.length; trackIndex++) {
String status = getTrackStatusString(false);
String formatSupport = getFormatSupportString(TrackRenderer.FORMAT_UNSUPPORTED_TYPE);
String formatSupport = getFormatSupportString(Renderer.FORMAT_UNSUPPORTED_TYPE);
Log.d(TAG, " " + status + " Track:" + trackIndex + ", "
+ getFormatString(trackGroup.getFormat(trackIndex))
+ ", supported=" + formatSupport);
@ -291,13 +291,13 @@ public class EventLogger implements ExoPlayer.EventListener, SimpleExoPlayer.Deb
private static String getFormatSupportString(int formatSupport) {
switch (formatSupport) {
case TrackRenderer.FORMAT_HANDLED:
case Renderer.FORMAT_HANDLED:
return "YES";
case TrackRenderer.FORMAT_EXCEEDS_CAPABILITIES:
case Renderer.FORMAT_EXCEEDS_CAPABILITIES:
return "NO_EXCEEDS_CAPABILITIES";
case TrackRenderer.FORMAT_UNSUPPORTED_SUBTYPE:
case Renderer.FORMAT_UNSUPPORTED_SUBTYPE:
return "NO_UNSUPPORTED_TYPE";
case TrackRenderer.FORMAT_UNSUPPORTED_TYPE:
case Renderer.FORMAT_UNSUPPORTED_TYPE:
return "NO";
default:
return "?";
@ -309,11 +309,11 @@ public class EventLogger implements ExoPlayer.EventListener, SimpleExoPlayer.Deb
return "N/A";
}
switch (adaptiveSupport) {
case TrackRenderer.ADAPTIVE_SEAMLESS:
case Renderer.ADAPTIVE_SEAMLESS:
return "YES";
case TrackRenderer.ADAPTIVE_NOT_SEAMLESS:
case Renderer.ADAPTIVE_NOT_SEAMLESS:
return "YES_NOT_SEAMLESS";
case TrackRenderer.ADAPTIVE_NOT_SUPPORTED:
case Renderer.ADAPTIVE_NOT_SUPPORTED:
return "NO";
default:
return "?";

2
demo/src/main/java/com/google/android/exoplayer2/demo/PlayerActivity.java
View file

@ -25,7 +25,7 @@ import com.google.android.exoplayer2.DefaultTrackSelector.TrackInfo;
import com.google.android.exoplayer2.ExoPlaybackException;
import com.google.android.exoplayer2.ExoPlayer;
import com.google.android.exoplayer2.ExoPlayerFactory;
import com.google.android.exoplayer2.MediaCodecTrackRenderer.DecoderInitializationException;
import com.google.android.exoplayer2.MediaCodecRenderer.DecoderInitializationException;
import com.google.android.exoplayer2.MediaCodecUtil.DecoderQueryException;
import com.google.android.exoplayer2.MediaSource;
import com.google.android.exoplayer2.SimpleExoPlayer;

8
demo/src/main/java/com/google/android/exoplayer2/demo/TrackSelectionHelper.java
View file

@ -18,9 +18,9 @@ package com.google.android.exoplayer2.demo;
import com.google.android.exoplayer2.DefaultTrackSelector;
import com.google.android.exoplayer2.DefaultTrackSelector.TrackInfo;
import com.google.android.exoplayer2.Format;
import com.google.android.exoplayer2.Renderer;
import com.google.android.exoplayer2.TrackGroup;
import com.google.android.exoplayer2.TrackGroupArray;
import com.google.android.exoplayer2.TrackRenderer;
import com.google.android.exoplayer2.TrackSelection;
import com.google.android.exoplayer2.util.MimeTypes;
@ -45,7 +45,7 @@ import java.util.Locale;
DialogInterface.OnClickListener {
private final DefaultTrackSelector selector;
private TrackInfo trackInfo;
private int rendererIndex;
private TrackGroupArray trackGroups;
@ -81,7 +81,7 @@ import java.util.Locale;
trackGroupsAdaptive = new boolean[trackGroups.length];
for (int i = 0; i < trackGroups.length; i++) {
trackGroupsAdaptive[i] = trackInfo.getAdaptiveSupport(rendererIndex, i, false)
!= TrackRenderer.ADAPTIVE_NOT_SUPPORTED;
!= Renderer.ADAPTIVE_NOT_SUPPORTED;
}
isDisabled = selector.getRendererDisabled(rendererIndex);
override = selector.hasSelectionOverride(rendererIndex, trackGroups)
@ -133,7 +133,7 @@ import java.util.Locale;
trackViewLayoutId, root, false);
trackView.setText(buildTrackName(group.getFormat(trackIndex)));
if (trackInfo.getTrackFormatSupport(rendererIndex, groupIndex, trackIndex)
== TrackRenderer.FORMAT_HANDLED) {
== Renderer.FORMAT_HANDLED) {
haveSupportedTracks = true;
trackView.setTag(Pair.create(groupIndex, trackIndex));
trackView.setOnClickListener(this);

8
extensions/ffmpeg/README.md
View file

@ -1,11 +1,11 @@
# FfmpegAudioTrackRenderer #
# FfmpegAudioRenderer #
## Description ##
The FFmpeg extension is a [TrackRenderer][] implementation that uses FFmpeg to
decode audio.
The FFmpeg extension is a [Renderer][] implementation that uses FFmpeg to decode
audio.
[TrackRenderer]: https://google.github.io/ExoPlayer/doc/reference/com/google/android/exoplayer2/TrackRenderer.html
[Renderer]: https://google.github.io/ExoPlayer/doc/reference/com/google/android/exoplayer2/Renderer.html
## Build instructions ##

16
extensions/ffmpeg/src/main/java/com/google/android/exoplayer2/ext/ffmpeg/FfmpegAudioTrackRenderer.java → extensions/ffmpeg/src/main/java/com/google/android/exoplayer2/ext/ffmpeg/FfmpegAudioRenderer.java
View file

@ -15,12 +15,12 @@
*/
package com.google.android.exoplayer2.ext.ffmpeg;
import com.google.android.exoplayer2.AudioTrackRendererEventListener;
import com.google.android.exoplayer2.AudioRendererEventListener;
import com.google.android.exoplayer2.C;
import com.google.android.exoplayer2.Format;
import com.google.android.exoplayer2.audio.AudioCapabilities;
import com.google.android.exoplayer2.audio.AudioTrack;
import com.google.android.exoplayer2.extensions.AudioDecoderTrackRenderer;
import com.google.android.exoplayer2.extensions.AudioDecoderRenderer;
import com.google.android.exoplayer2.util.MimeTypes;
import android.os.Handler;
@ -28,14 +28,14 @@ import android.os.Handler;
/**
* Decodes and renders audio using FFmpeg.
*/
public final class FfmpegAudioTrackRenderer extends AudioDecoderTrackRenderer {
public final class FfmpegAudioRenderer extends AudioDecoderRenderer {
private static final int NUM_BUFFERS = 16;
private static final int INITIAL_INPUT_BUFFER_SIZE = 960 * 6;
private FfmpegDecoder decoder;
public FfmpegAudioTrackRenderer() {
public FfmpegAudioRenderer() {
this(null, null);
}
@ -44,8 +44,7 @@ public final class FfmpegAudioTrackRenderer extends AudioDecoderTrackRenderer {
* null if delivery of events is not required.
* @param eventListener A listener of events. May be null if delivery of events is not required.
*/
public FfmpegAudioTrackRenderer(Handler eventHandler,
AudioTrackRendererEventListener eventListener) {
public FfmpegAudioRenderer(Handler eventHandler, AudioRendererEventListener eventListener) {
super(eventHandler, eventListener);
}
@ -57,9 +56,8 @@ public final class FfmpegAudioTrackRenderer extends AudioDecoderTrackRenderer {
* default capabilities (no encoded audio passthrough support) should be assumed.
* @param streamType The type of audio stream for the {@link AudioTrack}.
*/
public FfmpegAudioTrackRenderer(Handler eventHandler,
AudioTrackRendererEventListener eventListener, AudioCapabilities audioCapabilities,
int streamType) {
public FfmpegAudioRenderer(Handler eventHandler, AudioRendererEventListener eventListener,
AudioCapabilities audioCapabilities, int streamType) {
super(eventHandler, eventListener, audioCapabilities, streamType);
}

4
extensions/flac/README.md
View file

@ -2,11 +2,11 @@
## Description ##
The Flac Extension is a [TrackRenderer][] implementation that helps you bundle
The Flac Extension is a [Renderer][] implementation that helps you bundle
libFLAC (the Flac decoding library) into your app and use it along with
ExoPlayer to play Flac audio on Android devices.
[TrackRenderer]: https://google.github.io/ExoPlayer/doc/reference/com/google/android/exoplayer2/TrackRenderer.html
[Renderer]: https://google.github.io/ExoPlayer/doc/reference/com/google/android/exoplayer2/Renderer.html
## Build Instructions ##

8
extensions/flac/src/androidTest/java/com/google/android/exoplayer2/ext/flac/FlacPlaybackTest.java
View file

@ -20,7 +20,7 @@ import com.google.android.exoplayer2.DefaultTrackSelector;
import com.google.android.exoplayer2.ExoPlaybackException;
import com.google.android.exoplayer2.ExoPlayer;
import com.google.android.exoplayer2.ExoPlayerFactory;
import com.google.android.exoplayer2.TrackRenderer;
import com.google.android.exoplayer2.Renderer;
import com.google.android.exoplayer2.extractor.ExtractorMediaSource;
import com.google.android.exoplayer2.extractor.mkv.MatroskaExtractor;
import com.google.android.exoplayer2.upstream.DefaultDataSourceFactory;
@ -31,7 +31,7 @@ import android.os.Looper;
import android.test.InstrumentationTestCase;
/**
* Playback tests using {@link LibflacAudioTrackRenderer}.
* Playback tests using {@link LibflacAudioRenderer}.
*/
public class FlacPlaybackTest extends InstrumentationTestCase {
@ -71,10 +71,10 @@ public class FlacPlaybackTest extends InstrumentationTestCase {
@Override
public void run() {
Looper.prepare();
LibflacAudioTrackRenderer audioRenderer = new LibflacAudioTrackRenderer();
LibflacAudioRenderer audioRenderer = new LibflacAudioRenderer();
DefaultTrackSelector trackSelector = new DefaultTrackSelector(
new DefaultTrackSelectionPolicy(), null);
player = ExoPlayerFactory.newInstance(new TrackRenderer[] {audioRenderer}, trackSelector);
player = ExoPlayerFactory.newInstance(new Renderer[] {audioRenderer}, trackSelector);
player.addListener(this);
ExtractorMediaSource mediaSource = new ExtractorMediaSource(
uri,

16
extensions/flac/src/main/java/com/google/android/exoplayer2/ext/flac/LibflacAudioTrackRenderer.java → extensions/flac/src/main/java/com/google/android/exoplayer2/ext/flac/LibflacAudioRenderer.java
View file

@ -15,11 +15,11 @@
*/
package com.google.android.exoplayer2.ext.flac;
import com.google.android.exoplayer2.AudioTrackRendererEventListener;
import com.google.android.exoplayer2.AudioRendererEventListener;
import com.google.android.exoplayer2.Format;
import com.google.android.exoplayer2.audio.AudioCapabilities;
import com.google.android.exoplayer2.audio.AudioTrack;
import com.google.android.exoplayer2.extensions.AudioDecoderTrackRenderer;
import com.google.android.exoplayer2.extensions.AudioDecoderRenderer;
import com.google.android.exoplayer2.util.MimeTypes;
import android.os.Handler;
@ -27,7 +27,7 @@ import android.os.Handler;
/**
* Decodes and renders audio using the native Flac decoder.
*/
public class LibflacAudioTrackRenderer extends AudioDecoderTrackRenderer {
public class LibflacAudioRenderer extends AudioDecoderRenderer {
private static final int NUM_BUFFERS = 16;
@ -38,7 +38,7 @@ public class LibflacAudioTrackRenderer extends AudioDecoderTrackRenderer {
return FlacJni.IS_AVAILABLE;
}
public LibflacAudioTrackRenderer() {
public LibflacAudioRenderer() {
this(null, null);
}
@ -47,8 +47,7 @@ public class LibflacAudioTrackRenderer extends AudioDecoderTrackRenderer {
* null if delivery of events is not required.
* @param eventListener A listener of events. May be null if delivery of events is not required.
*/
public LibflacAudioTrackRenderer(Handler eventHandler,
AudioTrackRendererEventListener eventListener) {
public LibflacAudioRenderer(Handler eventHandler, AudioRendererEventListener eventListener) {
super(eventHandler, eventListener);
}
@ -60,9 +59,8 @@ public class LibflacAudioTrackRenderer extends AudioDecoderTrackRenderer {
* default capabilities (no encoded audio passthrough support) should be assumed.
* @param streamType The type of audio stream for the {@link AudioTrack}.
*/
public LibflacAudioTrackRenderer(Handler eventHandler,
AudioTrackRendererEventListener eventListener, AudioCapabilities audioCapabilities,
int streamType) {
public LibflacAudioRenderer(Handler eventHandler, AudioRendererEventListener eventListener,
AudioCapabilities audioCapabilities, int streamType) {
super(eventHandler, eventListener, audioCapabilities, streamType);
}

4
extensions/opus/README.md
View file

@ -2,11 +2,11 @@
## Description ##
The Opus Extension is a [TrackRenderer][] implementation that helps you bundle
The Opus Extension is a [Renderer][] implementation that helps you bundle
libopus (the Opus decoding library) into your app and use it along with
ExoPlayer to play Opus audio on Android devices.
[TrackRenderer]: https://google.github.io/ExoPlayer/doc/reference/com/google/android/exoplayer2/TrackRenderer.html
[Renderer]: https://google.github.io/ExoPlayer/doc/reference/com/google/android/exoplayer2/Renderer.html
## Build Instructions ##

8
extensions/opus/src/androidTest/java/com/google/android/exoplayer2/ext/opus/OpusPlaybackTest.java
View file

@ -20,7 +20,7 @@ import com.google.android.exoplayer2.DefaultTrackSelector;
import com.google.android.exoplayer2.ExoPlaybackException;
import com.google.android.exoplayer2.ExoPlayer;
import com.google.android.exoplayer2.ExoPlayerFactory;
import com.google.android.exoplayer2.TrackRenderer;
import com.google.android.exoplayer2.Renderer;
import com.google.android.exoplayer2.extractor.ExtractorMediaSource;
import com.google.android.exoplayer2.extractor.mkv.MatroskaExtractor;
import com.google.android.exoplayer2.upstream.DefaultDataSourceFactory;
@ -31,7 +31,7 @@ import android.os.Looper;
import android.test.InstrumentationTestCase;
/**
* Playback tests using {@link LibopusAudioTrackRenderer}.
* Playback tests using {@link LibopusAudioRenderer}.
*/
public class OpusPlaybackTest extends InstrumentationTestCase {
@ -71,10 +71,10 @@ public class OpusPlaybackTest extends InstrumentationTestCase {
@Override
public void run() {
Looper.prepare();
LibopusAudioTrackRenderer audioRenderer = new LibopusAudioTrackRenderer();
LibopusAudioRenderer audioRenderer = new LibopusAudioRenderer();
DefaultTrackSelector trackSelector = new DefaultTrackSelector(
new DefaultTrackSelectionPolicy(), null);
player = ExoPlayerFactory.newInstance(new TrackRenderer[] {audioRenderer}, trackSelector);
player = ExoPlayerFactory.newInstance(new Renderer[] {audioRenderer}, trackSelector);
player.addListener(this);
ExtractorMediaSource mediaSource = new ExtractorMediaSource(
uri,

16
extensions/opus/src/main/java/com/google/android/exoplayer2/ext/opus/LibopusAudioTrackRenderer.java → extensions/opus/src/main/java/com/google/android/exoplayer2/ext/opus/LibopusAudioRenderer.java
View file

@ -15,11 +15,11 @@
*/
package com.google.android.exoplayer2.ext.opus;
import com.google.android.exoplayer2.AudioTrackRendererEventListener;
import com.google.android.exoplayer2.AudioRendererEventListener;
import com.google.android.exoplayer2.Format;
import com.google.android.exoplayer2.audio.AudioCapabilities;
import com.google.android.exoplayer2.audio.AudioTrack;
import com.google.android.exoplayer2.extensions.AudioDecoderTrackRenderer;
import com.google.android.exoplayer2.extensions.AudioDecoderRenderer;
import com.google.android.exoplayer2.util.MimeTypes;
import android.os.Handler;
@ -27,7 +27,7 @@ import android.os.Handler;
/**
* Decodes and renders audio using the native Opus decoder.
*/
public final class LibopusAudioTrackRenderer extends AudioDecoderTrackRenderer {
public final class LibopusAudioRenderer extends AudioDecoderRenderer {
private static final int NUM_BUFFERS = 16;
private static final int INITIAL_INPUT_BUFFER_SIZE = 960 * 6;
@ -46,7 +46,7 @@ public final class LibopusAudioTrackRenderer extends AudioDecoderTrackRenderer {
return isLibopusAvailable() ? OpusDecoder.getLibopusVersion() : null;
}
public LibopusAudioTrackRenderer() {
public LibopusAudioRenderer() {
this(null, null);
}
@ -55,8 +55,7 @@ public final class LibopusAudioTrackRenderer extends AudioDecoderTrackRenderer {
* null if delivery of events is not required.
* @param eventListener A listener of events. May be null if delivery of events is not required.
*/
public LibopusAudioTrackRenderer(Handler eventHandler,
AudioTrackRendererEventListener eventListener) {
public LibopusAudioRenderer(Handler eventHandler, AudioRendererEventListener eventListener) {
super(eventHandler, eventListener);
}
@ -68,9 +67,8 @@ public final class LibopusAudioTrackRenderer extends AudioDecoderTrackRenderer {
* default capabilities (no encoded audio passthrough support) should be assumed.
* @param streamType The type of audio stream for the {@link AudioTrack}.
*/
public LibopusAudioTrackRenderer(Handler eventHandler,
AudioTrackRendererEventListener eventListener, AudioCapabilities audioCapabilities,
int streamType) {
public LibopusAudioRenderer(Handler eventHandler, AudioRendererEventListener eventListener,
AudioCapabilities audioCapabilities, int streamType) {
super(eventHandler, eventListener, audioCapabilities, streamType);
}

8
extensions/vp9/README.md
View file

@ -2,11 +2,11 @@
## Description ##
The VP9 Extension is a [TrackRenderer][] implementation that helps you bundle
libvpx (the VP9 decoding library) into your app and use it along with ExoPlayer
to play VP9 video on Android devices.
The VP9 Extension is a [Renderer][] implementation that helps you bundle libvpx
(the VP9 decoding library) into your app and use it along with ExoPlayer to play
VP9 video on Android devices.
[TrackRenderer]: https://google.github.io/ExoPlayer/doc/reference/com/google/android/exoplayer2/TrackRenderer.html
[Renderer]: https://google.github.io/ExoPlayer/doc/reference/com/google/android/exoplayer2/Renderer.html
## Build Instructions ##

10
extensions/vp9/src/androidTest/java/com/google/android/exoplayer2/ext/vp9/VpxPlaybackTest.java
View file

@ -20,7 +20,7 @@ import com.google.android.exoplayer2.DefaultTrackSelector;
import com.google.android.exoplayer2.ExoPlaybackException;
import com.google.android.exoplayer2.ExoPlayer;
import com.google.android.exoplayer2.ExoPlayerFactory;
import com.google.android.exoplayer2.TrackRenderer;
import com.google.android.exoplayer2.Renderer;
import com.google.android.exoplayer2.extractor.ExtractorMediaSource;
import com.google.android.exoplayer2.extractor.mkv.MatroskaExtractor;
import com.google.android.exoplayer2.upstream.DefaultDataSourceFactory;
@ -31,7 +31,7 @@ import android.os.Looper;
import android.test.InstrumentationTestCase;
/**
* Playback tests using {@link LibvpxVideoTrackRenderer}.
* Playback tests using {@link LibvpxVideoRenderer}.
*/
public class VpxPlaybackTest extends InstrumentationTestCase {
@ -87,10 +87,10 @@ public class VpxPlaybackTest extends InstrumentationTestCase {
@Override
public void run() {
Looper.prepare();
LibvpxVideoTrackRenderer videoRenderer = new LibvpxVideoTrackRenderer(true, 0);
LibvpxVideoRenderer videoRenderer = new LibvpxVideoRenderer(true, 0);
DefaultTrackSelector trackSelector = new DefaultTrackSelector(
new DefaultTrackSelectionPolicy(), null);
player = ExoPlayerFactory.newInstance(new TrackRenderer[] {videoRenderer}, trackSelector);
player = ExoPlayerFactory.newInstance(new Renderer[] {videoRenderer}, trackSelector);
player.addListener(this);
ExtractorMediaSource mediaSource = new ExtractorMediaSource(
uri,
@ -100,7 +100,7 @@ public class VpxPlaybackTest extends InstrumentationTestCase {
null,
null);
player.sendMessages(new ExoPlayer.ExoPlayerMessage(videoRenderer,
LibvpxVideoTrackRenderer.MSG_SET_OUTPUT_BUFFER_RENDERER,
LibvpxVideoRenderer.MSG_SET_OUTPUT_BUFFER_RENDERER,
new VpxVideoSurfaceView(context)));
player.setMediaSource(mediaSource);
player.setPlayWhenReady(true);

20
extensions/vp9/src/main/java/com/google/android/exoplayer2/ext/vp9/LibvpxVideoTrackRenderer.java → extensions/vp9/src/main/java/com/google/android/exoplayer2/ext/vp9/LibvpxVideoRenderer.java
View file

@ -22,10 +22,10 @@ import com.google.android.exoplayer2.ExoPlaybackException;
import com.google.android.exoplayer2.ExoPlayer;
import com.google.android.exoplayer2.Format;
import com.google.android.exoplayer2.FormatHolder;
import com.google.android.exoplayer2.TrackRenderer;
import com.google.android.exoplayer2.Renderer;
import com.google.android.exoplayer2.TrackStream;
import com.google.android.exoplayer2.VideoTrackRendererEventListener;
import com.google.android.exoplayer2.VideoTrackRendererEventListener.EventDispatcher;
import com.google.android.exoplayer2.VideoRendererEventListener;
import com.google.android.exoplayer2.VideoRendererEventListener.EventDispatcher;
import com.google.android.exoplayer2.util.MimeTypes;
import com.google.android.exoplayer2.util.TraceUtil;
@ -38,7 +38,7 @@ import android.view.Surface;
/**
* Decodes and renders video using the native VP9 decoder.
*/
public final class LibvpxVideoTrackRenderer extends TrackRenderer {
public final class LibvpxVideoRenderer extends Renderer {
/**
* The type of a message that can be passed to an instance of this class via
@ -48,7 +48,7 @@ public final class LibvpxVideoTrackRenderer extends TrackRenderer {
public static final int MSG_SET_OUTPUT_BUFFER_RENDERER = C.MSG_CUSTOM_BASE;
/**
* The number of input buffers and the number of output buffers. The track renderer may limit the
* The number of input buffers and the number of output buffers. The renderer may limit the
* minimum possible value due to requiring multiple output buffers to be dequeued at a time for it
* to make progress.
*/
@ -90,7 +90,7 @@ public final class LibvpxVideoTrackRenderer extends TrackRenderer {
* @param allowedJoiningTimeMs The maximum duration in milliseconds for which this video renderer
* can attempt to seamlessly join an ongoing playback.
*/
public LibvpxVideoTrackRenderer(boolean scaleToFit, long allowedJoiningTimeMs) {
public LibvpxVideoRenderer(boolean scaleToFit, long allowedJoiningTimeMs) {
this(scaleToFit, allowedJoiningTimeMs, null, null, 0);
}
@ -102,10 +102,10 @@ public final class LibvpxVideoTrackRenderer extends TrackRenderer {
* null if delivery of events is not required.
* @param eventListener A listener of events. May be null if delivery of events is not required.
* @param maxDroppedFrameCountToNotify The maximum number of frames that can be dropped between
* invocations of {@link VideoTrackRendererEventListener#onDroppedFrames(int, long)}.
* invocations of {@link VideoRendererEventListener#onDroppedFrames(int, long)}.
*/
public LibvpxVideoTrackRenderer(boolean scaleToFit, long allowedJoiningTimeMs,
Handler eventHandler, VideoTrackRendererEventListener eventListener,
public LibvpxVideoRenderer(boolean scaleToFit, long allowedJoiningTimeMs,
Handler eventHandler, VideoRendererEventListener eventListener,
int maxDroppedFrameCountToNotify) {
this.scaleToFit = scaleToFit;
this.allowedJoiningTimeMs = allowedJoiningTimeMs;
@ -234,7 +234,7 @@ public final class LibvpxVideoTrackRenderer extends TrackRenderer {
return false;
}
if (getState() == TrackRenderer.STATE_STARTED
if (getState() == Renderer.STATE_STARTED
&& outputBuffer.timestampUs <= positionUs + 30000) {
renderBuffer();
}

10
library/src/main/java/com/google/android/exoplayer2/AudioTrackRendererEventListener.java → library/src/main/java/com/google/android/exoplayer2/AudioRendererEventListener.java
View file

@ -22,9 +22,9 @@ import android.os.Handler;
import android.os.SystemClock;
/**
* Interface definition for a callback to be notified of audio {@link TrackRenderer} events.
* Interface definition for a callback to be notified of audio {@link Renderer} events.
*/
public interface AudioTrackRendererEventListener {
public interface AudioRendererEventListener {
/**
* Invoked when the renderer is enabled.
@ -71,14 +71,14 @@ public interface AudioTrackRendererEventListener {
void onAudioDisabled(CodecCounters counters);
/**
* Dispatches events to a {@link AudioTrackRendererEventListener}.
* Dispatches events to a {@link AudioRendererEventListener}.
*/
final class EventDispatcher {
private final Handler handler;
private final AudioTrackRendererEventListener listener;
private final AudioRendererEventListener listener;
public EventDispatcher(Handler handler, AudioTrackRendererEventListener listener) {
public EventDispatcher(Handler handler, AudioRendererEventListener listener) {
this.handler = listener != null ? Assertions.checkNotNull(handler) : null;
this.listener = listener;
}

6
library/src/main/java/com/google/android/exoplayer2/C.java
View file

@ -271,21 +271,21 @@ public interface C {
UUID PLAYREADY_UUID = new UUID(0x9A04F07998404286L, 0xAB92E65BE0885F95L);
/**
* The type of a message that can be passed to a video {@link TrackRenderer} via
* The type of a message that can be passed to a video {@link Renderer} via
* {@link ExoPlayer#sendMessages} or {@link ExoPlayer#blockingSendMessages}. The message object
* should be the target {@link Surface}, or null.
*/
int MSG_SET_SURFACE = 1;
/**
* The type of a message that can be passed to an audio {@link TrackRenderer} via
* The type of a message that can be passed to an audio {@link Renderer} via
* {@link ExoPlayer#sendMessages} or {@link ExoPlayer#blockingSendMessages}. The message object
* should be a {@link Float} with 0 being silence and 1 being unity gain.
*/
int MSG_SET_VOLUME = 2;
/**
* The type of a message that can be passed to an audio {@link TrackRenderer} via
* The type of a message that can be passed to an audio {@link Renderer} via
* {@link ExoPlayer#sendMessages} or {@link ExoPlayer#blockingSendMessages}. The message object
* should be a {@link android.media.PlaybackParams}, which will be used to configure the
* underlying {@link android.media.AudioTrack}. The message object should not be modified by the

2
library/src/main/java/com/google/android/exoplayer2/DefaultLoadControl.java
View file

@ -103,7 +103,7 @@ public final class DefaultLoadControl implements LoadControl {
}
@Override
public void onTrackSelections(TrackRenderer[] renderers, TrackGroupArray trackGroups,
public void onTrackSelections(Renderer[] renderers, TrackGroupArray trackGroups,
TrackSelectionArray trackSelections) {
targetBufferSize = 0;
for (int i = 0; i < renderers.length; i++) {

10
library/src/main/java/com/google/android/exoplayer2/DefaultTrackSelectionPolicy.java
View file

@ -122,7 +122,7 @@ public class DefaultTrackSelectionPolicy extends TrackSelectionPolicy {
// TrackSelectionPolicy implementation.
@Override
public TrackSelection[] selectTracks(TrackRenderer[] renderers,
public TrackSelection[] selectTracks(Renderer[] renderers,
TrackGroupArray[] rendererTrackGroupArrays, int[][][] rendererFormatSupports)
throws ExoPlaybackException {
// Make a track selection for each renderer.
@ -157,13 +157,13 @@ public class DefaultTrackSelectionPolicy extends TrackSelectionPolicy {
// Video track selection implementation.
private static TrackSelection selectTrackForVideoRenderer(TrackRenderer renderer,
private static TrackSelection selectTrackForVideoRenderer(Renderer renderer,
TrackGroupArray trackGroups, int[][] formatSupport, int maxVideoWidth, int maxVideoHeight,
boolean allowNonSeamlessAdaptiveness, boolean allowMixedMimeAdaptiveness)
throws ExoPlaybackException {
int requiredAdaptiveSupport = allowNonSeamlessAdaptiveness
? TrackRenderer.ADAPTIVE_NOT_SEAMLESS | TrackRenderer.ADAPTIVE_SEAMLESS
: TrackRenderer.ADAPTIVE_SEAMLESS;
? (Renderer.ADAPTIVE_NOT_SEAMLESS | Renderer.ADAPTIVE_SEAMLESS)
: Renderer.ADAPTIVE_SEAMLESS;
boolean allowMixedMimeTypes = allowMixedMimeAdaptiveness
&& (renderer.supportsMixedMimeTypeAdaptation() & requiredAdaptiveSupport) != 0;
int largestAdaptiveGroup = -1;
@ -347,7 +347,7 @@ public class DefaultTrackSelectionPolicy extends TrackSelectionPolicy {
}
private static boolean isSupported(int formatSupport) {
return (formatSupport & TrackRenderer.FORMAT_SUPPORT_MASK) == TrackRenderer.FORMAT_HANDLED;
return (formatSupport & Renderer.FORMAT_SUPPORT_MASK) == Renderer.FORMAT_HANDLED;
}
private static boolean formatHasLanguage(Format format, String language) {

84
library/src/main/java/com/google/android/exoplayer2/DefaultTrackSelector.java
View file

@ -232,7 +232,7 @@ public final class DefaultTrackSelector extends TrackSelector implements
}
@Override
protected Pair<TrackSelectionArray, Object> selectTracks(TrackRenderer[] renderers,
protected Pair<TrackSelectionArray, Object> selectTracks(Renderer[] renderers,
TrackGroupArray trackGroups) throws ExoPlaybackException {
// Structures into which data will be written during the selection. The extra item at the end
// of each array is to store data associated with track groups that cannot be associated with
@ -319,13 +319,13 @@ public final class DefaultTrackSelector extends TrackSelector implements
* Finds the renderer to which the provided {@link TrackGroup} should be associated.
* <p>
* A {@link TrackGroup} is associated to a renderer that reports
* {@link TrackRenderer#FORMAT_HANDLED} support for one or more of the tracks in the group, or
* {@link TrackRenderer#FORMAT_EXCEEDS_CAPABILITIES} if no such renderer exists, or
* {@link TrackRenderer#FORMAT_UNSUPPORTED_SUBTYPE} if again no such renderer exists. In the case
* {@link Renderer#FORMAT_HANDLED} support for one or more of the tracks in the group, or
* {@link Renderer#FORMAT_EXCEEDS_CAPABILITIES} if no such renderer exists, or
* {@link Renderer#FORMAT_UNSUPPORTED_SUBTYPE} if again no such renderer exists. In the case
* that two or more renderers report the same level of support, the renderer with the lowest index
* is associated.
* <p>
* If all renderers report {@link TrackRenderer#FORMAT_UNSUPPORTED_TYPE} for all of the tracks in
* If all renderers report {@link Renderer#FORMAT_UNSUPPORTED_TYPE} for all of the tracks in
* the group, then {@code renderers.length} is returned to indicate that no association was made.
*
* @param renderers The renderers from which to select.
@ -334,18 +334,18 @@ public final class DefaultTrackSelector extends TrackSelector implements
* was made.
* @throws ExoPlaybackException If an error occurs finding a renderer.
*/
private static int findRenderer(TrackRenderer[] renderers, TrackGroup group)
private static int findRenderer(Renderer[] renderers, TrackGroup group)
throws ExoPlaybackException {
int bestRendererIndex = renderers.length;
int bestSupportLevel = TrackRenderer.FORMAT_UNSUPPORTED_TYPE;
int bestSupportLevel = Renderer.FORMAT_UNSUPPORTED_TYPE;
for (int rendererIndex = 0; rendererIndex < renderers.length; rendererIndex++) {
TrackRenderer renderer = renderers[rendererIndex];
Renderer renderer = renderers[rendererIndex];
for (int trackIndex = 0; trackIndex < group.length; trackIndex++) {
int trackSupportLevel = renderer.supportsFormat(group.getFormat(trackIndex));
if (trackSupportLevel > bestSupportLevel) {
bestRendererIndex = rendererIndex;
bestSupportLevel = trackSupportLevel;
if (bestSupportLevel == TrackRenderer.FORMAT_HANDLED) {
if (bestSupportLevel == Renderer.FORMAT_HANDLED) {
// We can't do better.
return bestRendererIndex;
}
@ -356,16 +356,16 @@ public final class DefaultTrackSelector extends TrackSelector implements
}
/**
* Calls {@link TrackRenderer#supportsFormat(Format)} for each track in the specified
* Calls {@link Renderer#supportsFormat(Format)} for each track in the specified
* {@link TrackGroup}, returning the results in an array.
*
* @param renderer The renderer to evaluate.
* @param group The {@link TrackGroup} to evaluate.
* @return An array containing the result of calling {@link TrackRenderer#supportsFormat(Format)}
* @return An array containing the result of calling {@link Renderer#supportsFormat(Format)}
* on the renderer for each track in the group.
* @throws ExoPlaybackException If an error occurs determining the format support.
*/
private static int[] getFormatSupport(TrackRenderer renderer, TrackGroup group)
private static int[] getFormatSupport(Renderer renderer, TrackGroup group)
throws ExoPlaybackException {
int[] formatSupport = new int[group.length];
for (int i = 0; i < group.length; i++) {
@ -375,15 +375,15 @@ public final class DefaultTrackSelector extends TrackSelector implements
}
/**
* Calls {@link TrackRenderer#supportsMixedMimeTypeAdaptation()} for each renderer, returning
* Calls {@link Renderer#supportsMixedMimeTypeAdaptation()} for each renderer, returning
* the results in an array.
*
* @param renderers The renderers to evaluate.
* @return An array containing the result of calling
* {@link TrackRenderer#supportsMixedMimeTypeAdaptation()} on each renderer.
* {@link Renderer#supportsMixedMimeTypeAdaptation()} on each renderer.
* @throws ExoPlaybackException If an error occurs determining the adaptation support.
*/
private static int[] getMixedMimeTypeAdaptationSupport(TrackRenderer[] renderers)
private static int[] getMixedMimeTypeAdaptationSupport(Renderer[] renderers)
throws ExoPlaybackException {
int[] mixedMimeTypeAdaptationSupport = new int[renderers.length];
for (int i = 0; i < mixedMimeTypeAdaptationSupport.length; i++) {
@ -423,7 +423,7 @@ public final class DefaultTrackSelector extends TrackSelector implements
}
/**
* Provides track information for each {@link TrackRenderer}.
* Provides track information for each {@link Renderer}.
*/
public static final class TrackInfo {
@ -455,8 +455,8 @@ public final class DefaultTrackSelector extends TrackSelector implements
* @param trackGroups The {@link TrackGroupArray}s for each renderer.
* @param trackSelections The current {@link TrackSelection}s for each renderer.
* @param mixedMimeTypeAdaptiveSupport The result of
* {@link TrackRenderer#supportsMixedMimeTypeAdaptation()} for each renderer.
* @param formatSupport The result of {@link TrackRenderer#supportsFormat(Format)} for each
* {@link Renderer#supportsMixedMimeTypeAdaptation()} for each renderer.
* @param formatSupport The result of {@link Renderer#supportsFormat(Format)} for each
* track, indexed by renderer index, group index and track index (in that order).
* @param unassociatedTrackGroups Contains {@link TrackGroup}s not associated with any renderer.
*/
@ -504,8 +504,8 @@ public final class DefaultTrackSelector extends TrackSelector implements
for (int i = 0; i < rendererFormatSupport.length; i++) {
for (int j = 0; j < rendererFormatSupport[i].length; j++) {
hasTracks = true;
if ((rendererFormatSupport[i][j] & TrackRenderer.FORMAT_SUPPORT_MASK)
== TrackRenderer.FORMAT_HANDLED) {
if ((rendererFormatSupport[i][j] & Renderer.FORMAT_SUPPORT_MASK)
== Renderer.FORMAT_HANDLED) {
return RENDERER_SUPPORT_PLAYABLE_TRACKS;
}
}
@ -519,14 +519,14 @@ public final class DefaultTrackSelector extends TrackSelector implements
* @param rendererIndex The renderer index.
* @param groupIndex The index of the group to which the track belongs.
* @param trackIndex The index of the track within the group.
* @return One of {@link TrackRenderer#FORMAT_HANDLED},
* {@link TrackRenderer#FORMAT_EXCEEDS_CAPABILITIES},
* {@link TrackRenderer#FORMAT_UNSUPPORTED_SUBTYPE} and
* {@link TrackRenderer#FORMAT_UNSUPPORTED_TYPE}.
* @return One of {@link Renderer#FORMAT_HANDLED},
* {@link Renderer#FORMAT_EXCEEDS_CAPABILITIES},
* {@link Renderer#FORMAT_UNSUPPORTED_SUBTYPE} and
* {@link Renderer#FORMAT_UNSUPPORTED_TYPE}.
*/
public int getTrackFormatSupport(int rendererIndex, int groupIndex, int trackIndex) {
return formatSupport[rendererIndex][groupIndex][trackIndex]
& TrackRenderer.FORMAT_SUPPORT_MASK;
& Renderer.FORMAT_SUPPORT_MASK;
}
/**
@ -534,21 +534,21 @@ public final class DefaultTrackSelector extends TrackSelector implements
* specified {@link TrackGroup}.
* <p>
* Tracks for which {@link #getTrackFormatSupport(int, int, int)} returns
* {@link TrackRenderer#FORMAT_HANDLED} are always considered.
* {@link Renderer#FORMAT_HANDLED} are always considered.
* Tracks for which {@link #getTrackFormatSupport(int, int, int)} returns
* {@link TrackRenderer#FORMAT_UNSUPPORTED_TYPE} or
* {@link TrackRenderer#FORMAT_UNSUPPORTED_SUBTYPE} are never considered.
* {@link Renderer#FORMAT_UNSUPPORTED_TYPE} or
* {@link Renderer#FORMAT_UNSUPPORTED_SUBTYPE} are never considered.
* Tracks for which {@link #getTrackFormatSupport(int, int, int)} returns
* {@link TrackRenderer#FORMAT_EXCEEDS_CAPABILITIES} are considered only if
* {@link Renderer#FORMAT_EXCEEDS_CAPABILITIES} are considered only if
* {@code includeCapabilitiesExceededTracks} is set to {@code true}.
*
* @param rendererIndex The renderer index.
* @param groupIndex The index of the group.
* @param includeCapabilitiesExceededTracks True if formats that exceed the capabilities of the
* renderer should be included when determining support. False otherwise.
* @return One of {@link TrackRenderer#ADAPTIVE_SEAMLESS},
* {@link TrackRenderer#ADAPTIVE_NOT_SEAMLESS} and
* {@link TrackRenderer#ADAPTIVE_NOT_SUPPORTED}.
* @return One of {@link Renderer#ADAPTIVE_SEAMLESS},
* {@link Renderer#ADAPTIVE_NOT_SEAMLESS} and
* {@link Renderer#ADAPTIVE_NOT_SUPPORTED}.
*/
public int getAdaptiveSupport(int rendererIndex, int groupIndex,
boolean includeCapabilitiesExceededTracks) {
@ -558,8 +558,8 @@ public final class DefaultTrackSelector extends TrackSelector implements
int trackIndexCount = 0;
for (int i = 0; i < trackCount; i++) {
int fixedSupport = getTrackFormatSupport(rendererIndex, groupIndex, i);
if (fixedSupport == TrackRenderer.FORMAT_HANDLED || (includeCapabilitiesExceededTracks
&& fixedSupport == TrackRenderer.FORMAT_EXCEEDS_CAPABILITIES)) {
if (fixedSupport == Renderer.FORMAT_HANDLED || (includeCapabilitiesExceededTracks
&& fixedSupport == Renderer.FORMAT_EXCEEDS_CAPABILITIES)) {
trackIndices[trackIndexCount++] = i;
}
}
@ -573,17 +573,17 @@ public final class DefaultTrackSelector extends TrackSelector implements
*
* @param rendererIndex The renderer index.
* @param groupIndex The index of the group.
* @return One of {@link TrackRenderer#ADAPTIVE_SEAMLESS},
* {@link TrackRenderer#ADAPTIVE_NOT_SEAMLESS} and
* {@link TrackRenderer#ADAPTIVE_NOT_SUPPORTED}.
* @return One of {@link Renderer#ADAPTIVE_SEAMLESS},
* {@link Renderer#ADAPTIVE_NOT_SEAMLESS} and
* {@link Renderer#ADAPTIVE_NOT_SUPPORTED}.
*/
public int getAdaptiveSupport(int rendererIndex, int groupIndex, int[] trackIndices) {
TrackGroup trackGroup = trackGroups[rendererIndex].get(groupIndex);
if (!trackGroup.adaptive) {
return TrackRenderer.ADAPTIVE_NOT_SUPPORTED;
return Renderer.ADAPTIVE_NOT_SUPPORTED;
}
int handledTrackCount = 0;
int adaptiveSupport = TrackRenderer.ADAPTIVE_SEAMLESS;
int adaptiveSupport = Renderer.ADAPTIVE_SEAMLESS;
boolean multipleMimeTypes = false;
String firstSampleMimeType = null;
for (int i = 0; i < trackIndices.length; i++) {
@ -596,7 +596,7 @@ public final class DefaultTrackSelector extends TrackSelector implements
multipleMimeTypes |= !Util.areEqual(firstSampleMimeType, sampleMimeType);
}
adaptiveSupport = Math.min(adaptiveSupport,
formatSupport[rendererIndex][groupIndex][i] & TrackRenderer.ADAPTIVE_SUPPORT_MASK);
formatSupport[rendererIndex][groupIndex][i] & Renderer.ADAPTIVE_SUPPORT_MASK);
}
return multipleMimeTypes
? Math.min(adaptiveSupport, mixedMimeTypeAdaptiveSupport[rendererIndex])
@ -604,9 +604,9 @@ public final class DefaultTrackSelector extends TrackSelector implements
}
/**
* Gets the {@link TrackGroup}s not associated with any {@link TrackRenderer}.
* Gets the {@link TrackGroup}s not associated with any {@link Renderer}.
*
* @return The {@link TrackGroup}s not associated with any {@link TrackRenderer}.
* @return The {@link TrackGroup}s not associated with any {@link Renderer}.
*/
public TrackGroupArray getUnassociatedTrackGroups() {
return unassociatedTrackGroups;

2
library/src/main/java/com/google/android/exoplayer2/ExoPlaybackException.java
View file

@ -31,7 +31,7 @@ public final class ExoPlaybackException extends Exception {
*/
public static final int TYPE_SOURCE = 0;
/**
* The error occurred in a {@link TrackRenderer}.
* The error occurred in a {@link Renderer}.
* <p>
* Call {@link #getRendererException()} to retrieve the underlying cause.
*/

14
library/src/main/java/com/google/android/exoplayer2/ExoPlayer.java
View file

@ -32,11 +32,11 @@ package com.google.android.exoplayer2;
* <p>The implementation is designed to make no assumptions about (and hence impose no restrictions
* on) the type of the media being played, how and where it is stored, or how it is rendered.
* Rather than implementing the loading and rendering of media directly, {@link ExoPlayer} instead
* delegates this work to one or more {@link TrackRenderer}s, which are injected when the player
* delegates this work to one or more {@link Renderer}s, which are injected when the player
* is created. Hence {@link ExoPlayer} is capable of loading and playing any media for which a
* {@link TrackRenderer} implementation can be provided.
* {@link Renderer} implementation can be provided.
*
* <p>{@link MediaCodecAudioTrackRenderer} and {@link MediaCodecVideoTrackRenderer} can be used for
* <p>{@link MediaCodecAudioRenderer} and {@link MediaCodecVideoRenderer} can be used for
* the common cases of rendering audio and video. These components in turn require an
* <i>upstream</i> {@link MediaPeriod} to be injected through their constructors, where upstream
* is defined to denote a component that is closer to the source of the media. This pattern of
@ -63,8 +63,8 @@ package com.google.android.exoplayer2;
* <li>Registered {@link EventListener}s are invoked on the thread that created the
* {@link ExoPlayer} instance.</li>
* <li>An internal playback thread is responsible for managing playback and invoking the
* {@link TrackRenderer}s in order to load and play the media.</li>
* <li>{@link TrackRenderer} implementations (or any upstream components that they depend on) may
* {@link Renderer}s in order to load and play the media.</li>
* <li>{@link Renderer} implementations (or any upstream components that they depend on) may
* use additional background threads (e.g. to load data). These are implementation specific.</li>
* </ul>
*
@ -83,7 +83,7 @@ package com.google.android.exoplayer2;
* border="0"/></p>
*
* <p>The possible playback state transitions are shown below. Transitions can be triggered either
* by changes in the state of the {@link TrackRenderer}s being used, or as a result of
* by changes in the state of the {@link Renderer}s being used, or as a result of
* {@link #setMediaSource(MediaSource)}, {@link #stop()} or {@link #release()} being invoked.</p>
* <p align="center"><img src="../../../../../images/exoplayer_playbackstate.png"
* alt="ExoPlayer playback state transitions"
@ -193,7 +193,7 @@ public interface ExoPlayer {
int STATE_IDLE = 1;
/**
* The player not able to immediately play from the current position. The cause is
* {@link TrackRenderer} specific, but this state typically occurs when more data needs to be
* {@link Renderer} specific, but this state typically occurs when more data needs to be
* loaded to be ready to play, or more data needs to be buffered for playback to resume.
*/
int STATE_BUFFERING = 2;

12
library/src/main/java/com/google/android/exoplayer2/ExoPlayerFactory.java
View file

@ -71,7 +71,7 @@ public final class ExoPlayerFactory {
* @param loadControl The {@link LoadControl} that will be used by the instance.
* @param drmSessionManager An optional {@link DrmSessionManager}. May be null if the instance
* will not be used for DRM protected playbacks.
* @param preferExtensionDecoders True to prefer {@link TrackRenderer} instances defined in
* @param preferExtensionDecoders True to prefer {@link Renderer} instances defined in
* available extensions over those defined in the core library. Note that extensions must be
* included in the application build for setting this flag to have any effect.
*/
@ -92,7 +92,7 @@ public final class ExoPlayerFactory {
* @param loadControl The {@link LoadControl} that will be used by the instance.
* @param drmSessionManager An optional {@link DrmSessionManager}. May be null if the instance
* will not be used for DRM protected playbacks.
* @param preferExtensionDecoders True to prefer {@link TrackRenderer} instances defined in
* @param preferExtensionDecoders True to prefer {@link Renderer} instances defined in
* available extensions over those defined in the core library. Note that extensions must be
* included in the application build for setting this flag to have any effect.
* @param allowedVideoJoiningTimeMs The maximum duration for which a video renderer can attempt to
@ -110,10 +110,10 @@ public final class ExoPlayerFactory {
* <p>
* Must be called from a thread that has an associated {@link Looper}.
*
* @param renderers The {@link TrackRenderer}s that will be used by the instance.
* @param renderers The {@link Renderer}s that will be used by the instance.
* @param trackSelector The {@link TrackSelector} that will be used by the instance.
*/
public static ExoPlayer newInstance(TrackRenderer[] renderers, TrackSelector trackSelector) {
public static ExoPlayer newInstance(Renderer[] renderers, TrackSelector trackSelector) {
return newInstance(renderers, trackSelector, new DefaultLoadControl());
}
@ -122,11 +122,11 @@ public final class ExoPlayerFactory {
* <p>
* Must be called from a thread that has an associated {@link Looper}.
*
* @param renderers The {@link TrackRenderer}s that will be used by the instance.
* @param renderers The {@link Renderer}s that will be used by the instance.
* @param trackSelector The {@link TrackSelector} that will be used by the instance.
* @param loadControl The {@link LoadControl} that will be used by the instance.
*/
public static ExoPlayer newInstance(TrackRenderer[] renderers, TrackSelector trackSelector,
public static ExoPlayer newInstance(Renderer[] renderers, TrackSelector trackSelector,
LoadControl loadControl) {
return new ExoPlayerImpl(renderers, trackSelector, loadControl);
}

4
library/src/main/java/com/google/android/exoplayer2/ExoPlayerImpl.java
View file

@ -54,12 +54,12 @@ import java.util.concurrent.CopyOnWriteArraySet;
/**
* Constructs an instance. Must be invoked from a thread that has an associated {@link Looper}.
*
* @param renderers The {@link TrackRenderer}s that will be used by the instance.
* @param renderers The {@link Renderer}s that will be used by the instance.
* @param trackSelector The {@link TrackSelector} that will be used by the instance.
* @param loadControl The {@link LoadControl} that will be used by the instance.
*/
@SuppressLint("HandlerLeak")
public ExoPlayerImpl(TrackRenderer[] renderers, TrackSelector trackSelector,
public ExoPlayerImpl(Renderer[] renderers, TrackSelector trackSelector,
LoadControl loadControl) {
Log.i(TAG, "Init " + ExoPlayerLibraryInfo.VERSION);
Assertions.checkNotNull(renderers);

58
library/src/main/java/com/google/android/exoplayer2/ExoPlayerImplInternal.java
View file

@ -100,10 +100,10 @@ import java.util.ArrayList;
private final Timeline timeline;
private PlaybackInfo playbackInfo;
private TrackRenderer rendererMediaClockSource;
private Renderer rendererMediaClockSource;
private MediaClock rendererMediaClock;
private MediaSource mediaSource;
private TrackRenderer[] enabledRenderers;
private Renderer[] enabledRenderers;
private boolean released;
private boolean playWhenReady;
private boolean rebuffering;
@ -115,7 +115,7 @@ import java.util.ArrayList;
private long internalPositionUs;
public ExoPlayerImplInternal(TrackRenderer[] renderers, TrackSelector trackSelector,
public ExoPlayerImplInternal(Renderer[] renderers, TrackSelector trackSelector,
LoadControl loadControl, boolean playWhenReady, Handler eventHandler) {
this.trackSelector = trackSelector;
this.loadControl = loadControl;
@ -128,7 +128,7 @@ import java.util.ArrayList;
}
standaloneMediaClock = new StandaloneMediaClock();
enabledRenderers = new TrackRenderer[0];
enabledRenderers = new Renderer[0];
timeline = new Timeline(renderers);
playbackInfo = new PlaybackInfo(0);
@ -335,14 +335,14 @@ import java.util.ArrayList;
private void startRenderers() throws ExoPlaybackException {
rebuffering = false;
standaloneMediaClock.start();
for (TrackRenderer renderer : enabledRenderers) {
for (Renderer renderer : enabledRenderers) {
renderer.start();
}
}
private void stopRenderers() throws ExoPlaybackException {
standaloneMediaClock.stop();
for (TrackRenderer renderer : enabledRenderers) {
for (Renderer renderer : enabledRenderers) {
ensureStopped(renderer);
}
}
@ -400,7 +400,7 @@ import java.util.ArrayList;
updatePlaybackPositions();
boolean allRenderersEnded = true;
boolean allRenderersReadyOrEnded = true;
for (TrackRenderer renderer : enabledRenderers) {
for (Renderer renderer : enabledRenderers) {
// TODO: Each renderer should return the maximum delay before which it wishes to be invoked
// again. The minimum of these values should then be used as the delay before the next
// invocation of this method.
@ -494,7 +494,7 @@ import java.util.ArrayList;
long sourceOffsetUs = timeline.playingPeriod == null ? 0 : timeline.playingPeriod.offsetUs;
internalPositionUs = sourceOffsetUs + periodPositionUs;
standaloneMediaClock.setPositionUs(internalPositionUs);
for (TrackRenderer renderer : enabledRenderers) {
for (Renderer renderer : enabledRenderers) {
renderer.reset(internalPositionUs);
}
}
@ -519,7 +519,7 @@ import java.util.ArrayList;
standaloneMediaClock.stop();
rendererMediaClock = null;
rendererMediaClockSource = null;
for (TrackRenderer renderer : enabledRenderers) {
for (Renderer renderer : enabledRenderers) {
try {
ensureStopped(renderer);
renderer.disable();
@ -528,7 +528,7 @@ import java.util.ArrayList;
Log.e(TAG, "Stop failed.", e);
}
}
enabledRenderers = new TrackRenderer[0];
enabledRenderers = new Renderer[0];
mediaSource = null;
timeline.reset();
loadControl.reset();
@ -552,8 +552,8 @@ import java.util.ArrayList;
}
}
private void ensureStopped(TrackRenderer renderer) throws ExoPlaybackException {
if (renderer.getState() == TrackRenderer.STATE_STARTED) {
private void ensureStopped(Renderer renderer) throws ExoPlaybackException {
if (renderer.getState() == Renderer.STATE_STARTED) {
renderer.stop();
}
}
@ -573,7 +573,7 @@ import java.util.ArrayList;
*/
private final class Timeline {
private final TrackRenderer[] renderers;
private final Renderer[] renderers;
public boolean isReady;
public boolean isEnded;
@ -585,7 +585,7 @@ import java.util.ArrayList;
private int pendingPeriodIndex;
private long playingPeriodEndPositionUs;
public Timeline(TrackRenderer[] renderers) {
public Timeline(Renderer[] renderers) {
this.renderers = renderers;
playingPeriodEndPositionUs = C.UNSET_TIME_US;
}
@ -615,7 +615,7 @@ import java.util.ArrayList;
public void maybeThrowPeriodPrepareError() throws IOException {
if (loadingPeriod != null && !loadingPeriod.prepared
&& (readingPeriod == null || readingPeriod.nextPeriod == loadingPeriod)) {
for (TrackRenderer renderer : enabledRenderers) {
for (Renderer renderer : enabledRenderers) {
if (!renderer.hasReadStreamToEnd()) {
return;
}
@ -682,7 +682,7 @@ import java.util.ArrayList;
// The renderers have their final TrackStreams.
return;
}
for (TrackRenderer renderer : enabledRenderers) {
for (Renderer renderer : enabledRenderers) {
if (!renderer.hasReadStreamToEnd()) {
return;
}
@ -693,7 +693,7 @@ import java.util.ArrayList;
TrackSelectionArray newTrackSelections = readingPeriod.trackSelections;
TrackGroupArray groups = readingPeriod.mediaPeriod.getTrackGroups();
for (int i = 0; i < renderers.length; i++) {
TrackRenderer renderer = renderers[i];
Renderer renderer = renderers[i];
TrackSelection oldSelection = oldTrackSelections.get(i);
TrackSelection newSelection = newTrackSelections.get(i);
if (oldSelection != null) {
@ -717,7 +717,7 @@ import java.util.ArrayList;
&& readingPeriod.index == periodCount - 1) {
readingPeriod = null;
// This is the last period, so signal the renderers to read the end of the stream.
for (TrackRenderer renderer : enabledRenderers) {
for (Renderer renderer : enabledRenderers) {
renderer.setCurrentTrackStreamIsFinal();
}
}
@ -789,11 +789,11 @@ import java.util.ArrayList;
resetInternalPosition(seekPositionUs);
maybeContinueLoading();
} else {
for (TrackRenderer renderer : enabledRenderers) {
for (Renderer renderer : enabledRenderers) {
ensureStopped(renderer);
renderer.disable();
}
enabledRenderers = new TrackRenderer[0];
enabledRenderers = new Renderer[0];
playingPeriod = null;
readingPeriod = null;
loadingPeriod = null;
@ -844,8 +844,8 @@ import java.util.ArrayList;
int enabledRendererCount = 0;
boolean[] rendererWasEnabledFlags = new boolean[renderers.length];
for (int i = 0; i < renderers.length; i++) {
TrackRenderer renderer = renderers[i];
rendererWasEnabledFlags[i] = renderer.getState() != TrackRenderer.STATE_DISABLED;
Renderer renderer = renderers[i];
rendererWasEnabledFlags[i] = renderer.getState() != Renderer.STATE_DISABLED;
TrackSelection oldSelection = playingPeriodOldTrackSelections.get(i);
TrackSelection newSelection = playingPeriod.trackSelections.get(i);
if (newSelection != null) {
@ -906,8 +906,8 @@ import java.util.ArrayList;
int enabledRendererCount = 0;
boolean[] rendererWasEnabledFlags = new boolean[renderers.length];
for (int i = 0; i < renderers.length; i++) {
TrackRenderer renderer = renderers[i];
rendererWasEnabledFlags[i] = renderer.getState() != TrackRenderer.STATE_DISABLED;
Renderer renderer = renderers[i];
rendererWasEnabledFlags[i] = renderer.getState() != Renderer.STATE_DISABLED;
TrackSelection newSelection = period.trackSelections.get(i);
if (newSelection != null) {
// The renderer should be enabled when playing the new period.
@ -942,15 +942,15 @@ import java.util.ArrayList;
private void enableRenderers(boolean[] rendererWasEnabledFlags, int enabledRendererCount)
throws ExoPlaybackException {
enabledRenderers = new TrackRenderer[enabledRendererCount];
enabledRenderers = new Renderer[enabledRendererCount];
enabledRendererCount = 0;
TrackGroupArray trackGroups = playingPeriod.mediaPeriod.getTrackGroups();
for (int i = 0; i < renderers.length; i++) {
TrackRenderer renderer = renderers[i];
Renderer renderer = renderers[i];
TrackSelection newSelection = playingPeriod.trackSelections.get(i);
if (newSelection != null) {
enabledRenderers[enabledRendererCount++] = renderer;
if (renderer.getState() == TrackRenderer.STATE_DISABLED) {
if (renderer.getState() == Renderer.STATE_DISABLED) {
// The renderer needs enabling with its new track selection.
boolean playing = playWhenReady && state == ExoPlayer.STATE_READY;
// Consider as joining only if the renderer was previously disabled.
@ -988,7 +988,7 @@ import java.util.ArrayList;
*/
private static final class Period {
private final TrackRenderer[] renderers;
private final Renderer[] renderers;
private final TrackSelector trackSelector;
public final MediaPeriod mediaPeriod;
@ -1005,7 +1005,7 @@ import java.util.ArrayList;
private TrackSelectionArray trackSelections;
private TrackSelectionArray periodTrackSelections;
public Period(TrackRenderer[] renderers, TrackSelector trackSelector, MediaPeriod mediaPeriod,
public Period(Renderer[] renderers, TrackSelector trackSelector, MediaPeriod mediaPeriod,
int index) {
this.renderers = renderers;
this.trackSelector = trackSelector;

2
library/src/main/java/com/google/android/exoplayer2/LoadControl.java
View file

@ -29,7 +29,7 @@ public interface LoadControl {
* @param trackGroups The available {@link TrackGroup}s.
* @param trackSelections The {@link TrackSelection}s that were made.
*/
void onTrackSelections(TrackRenderer[] renderers, TrackGroupArray trackGroups,
void onTrackSelections(Renderer[] renderers, TrackGroupArray trackGroups,
TrackSelectionArray trackSelections);
/**

24
library/src/main/java/com/google/android/exoplayer2/MediaCodecAudioTrackRenderer.java → library/src/main/java/com/google/android/exoplayer2/MediaCodecAudioRenderer.java
View file

@ -15,7 +15,7 @@
*/
package com.google.android.exoplayer2;
import com.google.android.exoplayer2.AudioTrackRendererEventListener.EventDispatcher;
import com.google.android.exoplayer2.AudioRendererEventListener.EventDispatcher;
import com.google.android.exoplayer2.MediaCodecUtil.DecoderQueryException;
import com.google.android.exoplayer2.audio.AudioCapabilities;
import com.google.android.exoplayer2.audio.AudioTrack;
@ -39,7 +39,7 @@ import java.nio.ByteBuffer;
* Decodes and renders audio using {@link MediaCodec} and {@link android.media.AudioTrack}.
*/
@TargetApi(16)
public class MediaCodecAudioTrackRenderer extends MediaCodecTrackRenderer implements MediaClock {
public class MediaCodecAudioRenderer extends MediaCodecRenderer implements MediaClock {
private final EventDispatcher eventDispatcher;
private final AudioTrack audioTrack;
@ -57,7 +57,7 @@ public class MediaCodecAudioTrackRenderer extends MediaCodecTrackRenderer implem
/**
* @param mediaCodecSelector A decoder selector.
*/
public MediaCodecAudioTrackRenderer(MediaCodecSelector mediaCodecSelector) {
public MediaCodecAudioRenderer(MediaCodecSelector mediaCodecSelector) {
this(mediaCodecSelector, null, true);
}
@ -71,7 +71,7 @@ public class MediaCodecAudioTrackRenderer extends MediaCodecTrackRenderer implem
* permitted to play clear regions of encrypted media files before {@code drmSessionManager}
* has obtained the keys necessary to decrypt encrypted regions of the media.
*/
public MediaCodecAudioTrackRenderer(MediaCodecSelector mediaCodecSelector,
public MediaCodecAudioRenderer(MediaCodecSelector mediaCodecSelector,
DrmSessionManager drmSessionManager, boolean playClearSamplesWithoutKeys) {
this(mediaCodecSelector, drmSessionManager, playClearSamplesWithoutKeys, null, null);
}
@ -82,8 +82,8 @@ public class MediaCodecAudioTrackRenderer extends MediaCodecTrackRenderer implem
* null if delivery of events is not required.
* @param eventListener A listener of events. May be null if delivery of events is not required.
*/
public MediaCodecAudioTrackRenderer(MediaCodecSelector mediaCodecSelector, Handler eventHandler,
AudioTrackRendererEventListener eventListener) {
public MediaCodecAudioRenderer(MediaCodecSelector mediaCodecSelector, Handler eventHandler,
AudioRendererEventListener eventListener) {
this(mediaCodecSelector, null, true, eventHandler, eventListener);
}
@ -100,9 +100,9 @@ public class MediaCodecAudioTrackRenderer extends MediaCodecTrackRenderer implem
* null if delivery of events is not required.
* @param eventListener A listener of events. May be null if delivery of events is not required.
*/
public MediaCodecAudioTrackRenderer(MediaCodecSelector mediaCodecSelector,
public MediaCodecAudioRenderer(MediaCodecSelector mediaCodecSelector,
DrmSessionManager drmSessionManager, boolean playClearSamplesWithoutKeys,
Handler eventHandler, AudioTrackRendererEventListener eventListener) {
Handler eventHandler, AudioRendererEventListener eventListener) {
this(mediaCodecSelector, drmSessionManager, playClearSamplesWithoutKeys, eventHandler,
eventListener, null, AudioManager.STREAM_MUSIC);
}
@ -123,9 +123,9 @@ public class MediaCodecAudioTrackRenderer extends MediaCodecTrackRenderer implem
* default capabilities (no encoded audio passthrough support) should be assumed.
* @param streamType The type of audio stream for the {@link AudioTrack}.
*/
public MediaCodecAudioTrackRenderer(MediaCodecSelector mediaCodecSelector,
public MediaCodecAudioRenderer(MediaCodecSelector mediaCodecSelector,
DrmSessionManager drmSessionManager, boolean playClearSamplesWithoutKeys,
Handler eventHandler, AudioTrackRendererEventListener eventListener,
Handler eventHandler, AudioRendererEventListener eventListener,
AudioCapabilities audioCapabilities, int streamType) {
super(mediaCodecSelector, drmSessionManager, playClearSamplesWithoutKeys);
audioSessionId = AudioTrack.SESSION_ID_NOT_SET;
@ -344,14 +344,14 @@ public class MediaCodecAudioTrackRenderer extends MediaCodecTrackRenderer implem
} catch (AudioTrack.InitializationException e) {
throw ExoPlaybackException.createForRenderer(e, getIndex());
}
if (getState() == TrackRenderer.STATE_STARTED) {
if (getState() == Renderer.STATE_STARTED) {
audioTrack.play();
}
} else {
// Check for AudioTrack underrun.
boolean audioTrackHadData = audioTrackHasData;
audioTrackHasData = audioTrack.hasPendingData();
if (audioTrackHadData && !audioTrackHasData && getState() == TrackRenderer.STATE_STARTED) {
if (audioTrackHadData && !audioTrackHasData && getState() == Renderer.STATE_STARTED) {
long elapsedSinceLastFeedMs = SystemClock.elapsedRealtime() - lastFeedElapsedRealtimeMs;
long bufferSizeUs = audioTrack.getBufferSizeUs();
long bufferSizeMs = bufferSizeUs == C.UNSET_TIME_US ? -1 : bufferSizeUs / 1000;

8
library/src/main/java/com/google/android/exoplayer2/MediaCodecTrackRenderer.java → library/src/main/java/com/google/android/exoplayer2/MediaCodecRenderer.java
View file

@ -37,10 +37,10 @@ import java.util.ArrayList;
import java.util.List;
/**
* An abstract {@link TrackRenderer} that uses {@link MediaCodec} to decode samples for rendering.
* An abstract {@link Renderer} that uses {@link MediaCodec} to decode samples for rendering.
*/
@TargetApi(16)
public abstract class MediaCodecTrackRenderer extends TrackRenderer {
public abstract class MediaCodecRenderer extends Renderer {
/**
* Thrown when a failure occurs instantiating a decoder.
@ -192,7 +192,7 @@ public abstract class MediaCodecTrackRenderer extends TrackRenderer {
* permitted to play clear regions of encrypted media files before {@code drmSessionManager}
* has obtained the keys necessary to decrypt encrypted regions of the media.
*/
public MediaCodecTrackRenderer(MediaCodecSelector mediaCodecSelector,
public MediaCodecRenderer(MediaCodecSelector mediaCodecSelector,
DrmSessionManager drmSessionManager, boolean playClearSamplesWithoutKeys) {
Assertions.checkState(Util.SDK_INT >= 16);
this.mediaCodecSelector = Assertions.checkNotNull(mediaCodecSelector);
@ -338,7 +338,7 @@ public abstract class MediaCodecTrackRenderer extends TrackRenderer {
throwDecoderInitError(new DecoderInitializationException(format, e,
drmSessionRequiresSecureDecoder, codecName));
}
codecHotswapDeadlineMs = getState() == TrackRenderer.STATE_STARTED
codecHotswapDeadlineMs = getState() == Renderer.STATE_STARTED
? (SystemClock.elapsedRealtime() + MAX_CODEC_HOTSWAP_TIME_MS) : -1;
inputIndex = -1;
outputIndex = -1;

24
library/src/main/java/com/google/android/exoplayer2/MediaCodecVideoTrackRenderer.java → library/src/main/java/com/google/android/exoplayer2/MediaCodecVideoRenderer.java
View file

@ -16,7 +16,7 @@
package com.google.android.exoplayer2;
import com.google.android.exoplayer2.MediaCodecUtil.DecoderQueryException;
import com.google.android.exoplayer2.VideoTrackRendererEventListener.EventDispatcher;
import com.google.android.exoplayer2.VideoRendererEventListener.EventDispatcher;
import com.google.android.exoplayer2.drm.DrmSessionManager;
import com.google.android.exoplayer2.util.MimeTypes;
import com.google.android.exoplayer2.util.TraceUtil;
@ -39,7 +39,7 @@ import java.nio.ByteBuffer;
* Decodes and renders video using {@link MediaCodec}.
*/
@TargetApi(16)
public class MediaCodecVideoTrackRenderer extends MediaCodecTrackRenderer {
public class MediaCodecVideoRenderer extends MediaCodecRenderer {
private static final String TAG = "MediaCodecVideoRenderer";
private static final String KEY_CROP_LEFT = "crop-left";
@ -82,7 +82,7 @@ public class MediaCodecVideoTrackRenderer extends MediaCodecTrackRenderer {
* @param videoScalingMode The scaling mode to pass to
* {@link MediaCodec#setVideoScalingMode(int)}.
*/
public MediaCodecVideoTrackRenderer(Context context, MediaCodecSelector mediaCodecSelector,
public MediaCodecVideoRenderer(Context context, MediaCodecSelector mediaCodecSelector,
int videoScalingMode) {
this(context, mediaCodecSelector, videoScalingMode, 0);
}
@ -95,7 +95,7 @@ public class MediaCodecVideoTrackRenderer extends MediaCodecTrackRenderer {
* @param allowedJoiningTimeMs The maximum duration in milliseconds for which this video renderer
* can attempt to seamlessly join an ongoing playback.
*/
public MediaCodecVideoTrackRenderer(Context context, MediaCodecSelector mediaCodecSelector,
public MediaCodecVideoRenderer(Context context, MediaCodecSelector mediaCodecSelector,
int videoScalingMode, long allowedJoiningTimeMs) {
this(context, mediaCodecSelector, videoScalingMode, allowedJoiningTimeMs, null, null, -1);
}
@ -111,11 +111,11 @@ public class MediaCodecVideoTrackRenderer extends MediaCodecTrackRenderer {
* null if delivery of events is not required.
* @param eventListener A listener of events. May be null if delivery of events is not required.
* @param maxDroppedFrameCountToNotify The maximum number of frames that can be dropped between
* invocations of {@link VideoTrackRendererEventListener#onDroppedFrames(int, long)}.
* invocations of {@link VideoRendererEventListener#onDroppedFrames(int, long)}.
*/
public MediaCodecVideoTrackRenderer(Context context, MediaCodecSelector mediaCodecSelector,
public MediaCodecVideoRenderer(Context context, MediaCodecSelector mediaCodecSelector,
int videoScalingMode, long allowedJoiningTimeMs, Handler eventHandler,
VideoTrackRendererEventListener eventListener, int maxDroppedFrameCountToNotify) {
VideoRendererEventListener eventListener, int maxDroppedFrameCountToNotify) {
this(context, mediaCodecSelector, videoScalingMode, allowedJoiningTimeMs, null, false,
eventHandler, eventListener, maxDroppedFrameCountToNotify);
}
@ -138,12 +138,12 @@ public class MediaCodecVideoTrackRenderer extends MediaCodecTrackRenderer {
* null if delivery of events is not required.
* @param eventListener A listener of events. May be null if delivery of events is not required.
* @param maxDroppedFrameCountToNotify The maximum number of frames that can be dropped between
* invocations of {@link VideoTrackRendererEventListener#onDroppedFrames(int, long)}.
* invocations of {@link VideoRendererEventListener#onDroppedFrames(int, long)}.
*/
public MediaCodecVideoTrackRenderer(Context context, MediaCodecSelector mediaCodecSelector,
public MediaCodecVideoRenderer(Context context, MediaCodecSelector mediaCodecSelector,
int videoScalingMode, long allowedJoiningTimeMs, DrmSessionManager drmSessionManager,
boolean playClearSamplesWithoutKeys, Handler eventHandler,
VideoTrackRendererEventListener eventListener, int maxDroppedFrameCountToNotify) {
VideoRendererEventListener eventListener, int maxDroppedFrameCountToNotify) {
super(mediaCodecSelector, drmSessionManager, playClearSamplesWithoutKeys);
this.videoScalingMode = videoScalingMode;
this.allowedJoiningTimeMs = allowedJoiningTimeMs;
@ -307,7 +307,7 @@ public class MediaCodecVideoTrackRenderer extends MediaCodecTrackRenderer {
this.surface = surface;
this.reportedDrawnToSurface = false;
int state = getState();
if (state == TrackRenderer.STATE_ENABLED || state == TrackRenderer.STATE_STARTED) {
if (state == Renderer.STATE_ENABLED || state == Renderer.STATE_STARTED) {
releaseCodec();
maybeInitCodec();
}
@ -403,7 +403,7 @@ public class MediaCodecVideoTrackRenderer extends MediaCodecTrackRenderer {
return true;
}
if (getState() != TrackRenderer.STATE_STARTED) {
if (getState() != Renderer.STATE_STARTED) {
return false;
}

36
library/src/main/java/com/google/android/exoplayer2/TrackRenderer.java → library/src/main/java/com/google/android/exoplayer2/Renderer.java
View file

@ -23,16 +23,16 @@ import java.io.IOException;
/**
* Renders a single component of media.
*
* <p>Internally, a renderer's lifecycle is managed by the owning {@link ExoPlayer}. The player
* will transition its renderers through various states as the overall playback state changes. The
* valid state transitions are shown below, annotated with the methods that are invoked during each
* <p>
* Internally, a renderer's lifecycle is managed by the owning {@link ExoPlayer}. The player will
* transition its renderers through various states as the overall playback state changes. The valid
* state transitions are shown below, annotated with the methods that are invoked during each
* transition.
* <p align="center"><img src="../../../../../images/trackrenderer_state.png"
* alt="TrackRenderer state transitions"
* alt="Renderer state transitions"
* border="0"/></p>
*/
public abstract class TrackRenderer implements ExoPlayerComponent {
public abstract class Renderer implements ExoPlayerComponent {
/**
* A mask to apply to the result of {@link #supportsFormat(Format)} to obtain one of
@ -41,33 +41,33 @@ public abstract class TrackRenderer implements ExoPlayerComponent {
*/
public static final int FORMAT_SUPPORT_MASK = 0b11;
/**
* The {@link TrackRenderer} is capable of rendering the format.
* The {@link Renderer} is capable of rendering the format.
*/
public static final int FORMAT_HANDLED = 0b11;
/**
* The {@link TrackRenderer} is capable of rendering formats with the same mimeType, but the
* The {@link Renderer} is capable of rendering formats with the same mimeType, but the
* properties of the format exceed the renderer's capability.
* <p>
* Example: The {@link TrackRenderer} is capable of rendering H264 and the format's mimeType is
* Example: The {@link Renderer} is capable of rendering H264 and the format's mimeType is
* {@link MimeTypes#VIDEO_H264}, but the format's resolution exceeds the maximum limit supported
* by the underlying H264 decoder.
*/
public static final int FORMAT_EXCEEDS_CAPABILITIES = 0b10;
/**
* The {@link TrackRenderer} is a general purpose renderer for formats of the same top-level type,
* The {@link Renderer} is a general purpose renderer for formats of the same top-level type,
* but is not capable of rendering the format or any other format with the same mimeType because
* the sub-type is not supported.
* <p>
* Example: The {@link TrackRenderer} is a general purpose audio renderer and the format's
* Example: The {@link Renderer} is a general purpose audio renderer and the format's
* mimeType matches audio/[subtype], but there does not exist a suitable decoder for [subtype].
*/
public static final int FORMAT_UNSUPPORTED_SUBTYPE = 0b01;
/**
* The {@link TrackRenderer} is not capable of rendering the format, either because it does not
* The {@link Renderer} is not capable of rendering the format, either because it does not
* support the format's top-level type, or because it's a specialized renderer for a different
* mimeType.
* <p>
* Example: The {@link TrackRenderer} is a general purpose video renderer, but the format has an
* Example: The {@link Renderer} is a general purpose video renderer, but the format has an
* audio mimeType.
*/
public static final int FORMAT_UNSUPPORTED_TYPE = 0b00;
@ -78,16 +78,16 @@ public abstract class TrackRenderer implements ExoPlayerComponent {
*/
public static final int ADAPTIVE_SUPPORT_MASK = 0b1100;
/**
* The {@link TrackRenderer} can seamlessly adapt between formats.
* The {@link Renderer} can seamlessly adapt between formats.
*/
public static final int ADAPTIVE_SEAMLESS = 0b1000;
/**
* The {@link TrackRenderer} can adapt between formats, but may suffer a brief discontinuity
* The {@link Renderer} can adapt between formats, but may suffer a brief discontinuity
* (~50-100ms) when adaptation occurs.
*/
public static final int ADAPTIVE_NOT_SEAMLESS = 0b0100;
/**
* The {@link TrackRenderer} does not support adaptation between formats.
* The {@link Renderer} does not support adaptation between formats.
*/
public static final int ADAPTIVE_NOT_SUPPORTED = 0b0000;
@ -112,7 +112,7 @@ public abstract class TrackRenderer implements ExoPlayerComponent {
private boolean readEndOfStream;
private boolean streamIsFinal;
public TrackRenderer() {
public Renderer() {
readEndOfStream = true;
}
@ -447,7 +447,7 @@ public abstract class TrackRenderer implements ExoPlayerComponent {
/**
* Whether the renderer is ready for the {@link ExoPlayer} instance to transition to
* {@link ExoPlayer#STATE_ENDED}. The player will make this transition as soon as {@code true} is
* returned by all of its {@link TrackRenderer}s.
* returned by all of its {@link Renderer}s.
* <p>
* This method may be called when the renderer is in the following states:
* {@link #STATE_ENABLED}, {@link #STATE_STARTED}.

78
library/src/main/java/com/google/android/exoplayer2/SimpleExoPlayer.java
View file

@ -17,13 +17,11 @@ package com.google.android.exoplayer2;
import com.google.android.exoplayer2.audio.AudioCapabilities;
import com.google.android.exoplayer2.drm.DrmSessionManager;
import com.google.android.exoplayer2.metadata.MetadataTrackRenderer;
import com.google.android.exoplayer2.metadata.MetadataTrackRenderer.MetadataRenderer;
import com.google.android.exoplayer2.metadata.MetadataRenderer;
import com.google.android.exoplayer2.metadata.id3.Id3Frame;
import com.google.android.exoplayer2.metadata.id3.Id3Parser;
import com.google.android.exoplayer2.text.Cue;
import com.google.android.exoplayer2.text.TextRenderer;
import com.google.android.exoplayer2.text.TextTrackRenderer;
import com.google.android.exoplayer2.upstream.BandwidthMeter;
import com.google.android.exoplayer2.upstream.DefaultBandwidthMeter;
@ -41,7 +39,7 @@ import java.util.ArrayList;
import java.util.List;
/**
* An {@link ExoPlayer} that uses default {@link TrackRenderer} components.
* An {@link ExoPlayer} that uses default {@link Renderer} components.
* <p>
* Instances of this class can be obtained from {@link ExoPlayerFactory}.
*/
@ -94,7 +92,7 @@ public final class SimpleExoPlayer implements ExoPlayer {
private final ExoPlayer player;
private final BandwidthMeter bandwidthMeter;
private final TrackRenderer[] renderers;
private final Renderer[] renderers;
private final ComponentListener componentListener;
private final Handler mainHandler;
private final int videoRendererCount;
@ -118,7 +116,7 @@ public final class SimpleExoPlayer implements ExoPlayer {
componentListener = new ComponentListener();
// Build the renderers.
ArrayList<TrackRenderer> renderersList = new ArrayList<>();
ArrayList<Renderer> renderersList = new ArrayList<>();
if (preferExtensionDecoders) {
buildExtensionRenderers(renderersList, allowedVideoJoiningTimeMs);
buildRenderers(context, drmSessionManager, renderersList, allowedVideoJoiningTimeMs);
@ -126,12 +124,12 @@ public final class SimpleExoPlayer implements ExoPlayer {
buildRenderers(context, drmSessionManager, renderersList, allowedVideoJoiningTimeMs);
buildExtensionRenderers(renderersList, allowedVideoJoiningTimeMs);
}
renderers = renderersList.toArray(new TrackRenderer[renderersList.size()]);
renderers = renderersList.toArray(new Renderer[renderersList.size()]);
// Obtain counts of video and audio renderers.
int videoRendererCount = 0;
int audioRendererCount = 0;
for (TrackRenderer renderer : renderers) {
for (Renderer renderer : renderers) {
switch (renderer.getTrackType()) {
case C.TRACK_TYPE_VIDEO:
videoRendererCount++;
@ -160,7 +158,7 @@ public final class SimpleExoPlayer implements ExoPlayer {
/**
* Returns the track type that the renderer at a given index handles.
*
* @see TrackRenderer#getTrackType()
* @see Renderer#getTrackType()
* @param index The index of the renderer.
* @return One of the {@code TRACK_TYPE_*} constants defined in {@link C}.
*/
@ -176,7 +174,7 @@ public final class SimpleExoPlayer implements ExoPlayer {
public void setSurface(Surface surface) {
ExoPlayerMessage[] messages = new ExoPlayerMessage[videoRendererCount];
int count = 0;
for (TrackRenderer renderer : renderers) {
for (Renderer renderer : renderers) {
if (renderer.getTrackType() == C.TRACK_TYPE_VIDEO) {
messages[count++] = new ExoPlayerMessage(renderer, C.MSG_SET_SURFACE, surface);
}
@ -197,7 +195,7 @@ public final class SimpleExoPlayer implements ExoPlayer {
public void setVolume(float volume) {
ExoPlayerMessage[] messages = new ExoPlayerMessage[audioRendererCount];
int count = 0;
for (TrackRenderer renderer : renderers) {
for (Renderer renderer : renderers) {
if (renderer.getTrackType() == C.TRACK_TYPE_AUDIO) {
messages[count++] = new ExoPlayerMessage(renderer, C.MSG_SET_VOLUME, volume);
}
@ -213,7 +211,7 @@ public final class SimpleExoPlayer implements ExoPlayer {
public void setPlaybackParams(PlaybackParams params) {
ExoPlayerMessage[] messages = new ExoPlayerMessage[audioRendererCount];
int count = 0;
for (TrackRenderer renderer : renderers) {
for (Renderer renderer : renderers) {
if (renderer.getTrackType() == C.TRACK_TYPE_AUDIO) {
messages[count++] = new ExoPlayerMessage(renderer, C.MSG_SET_PLAYBACK_PARAMS, params);
}
@ -396,39 +394,39 @@ public final class SimpleExoPlayer implements ExoPlayer {
// Internal methods.
private void buildRenderers(Context context, DrmSessionManager drmSessionManager,
ArrayList<TrackRenderer> renderersList, long allowedVideoJoiningTimeMs) {
MediaCodecVideoTrackRenderer videoRenderer = new MediaCodecVideoTrackRenderer(context,
ArrayList<Renderer> renderersList, long allowedVideoJoiningTimeMs) {
MediaCodecVideoRenderer videoRenderer = new MediaCodecVideoRenderer(context,
MediaCodecSelector.DEFAULT, MediaCodec.VIDEO_SCALING_MODE_SCALE_TO_FIT,
allowedVideoJoiningTimeMs, drmSessionManager, false, mainHandler, componentListener,
MAX_DROPPED_VIDEO_FRAME_COUNT_TO_NOTIFY);
renderersList.add(videoRenderer);
TrackRenderer audioRenderer = new MediaCodecAudioTrackRenderer(MediaCodecSelector.DEFAULT,
Renderer audioRenderer = new MediaCodecAudioRenderer(MediaCodecSelector.DEFAULT,
drmSessionManager, true, mainHandler, componentListener,
AudioCapabilities.getCapabilities(context), AudioManager.STREAM_MUSIC);
renderersList.add(audioRenderer);
TrackRenderer textRenderer = new TextTrackRenderer(componentListener, mainHandler.getLooper());
Renderer textRenderer = new TextRenderer(componentListener, mainHandler.getLooper());
renderersList.add(textRenderer);
MetadataTrackRenderer<List<Id3Frame>> id3Renderer = new MetadataTrackRenderer<>(new Id3Parser(),
componentListener, mainHandler.getLooper());
MetadataRenderer<List<Id3Frame>> id3Renderer = new MetadataRenderer<>(componentListener,
mainHandler.getLooper(), new Id3Parser());
renderersList.add(id3Renderer);
}
private void buildExtensionRenderers(ArrayList<TrackRenderer> renderersList,
private void buildExtensionRenderers(ArrayList<Renderer> renderersList,
long allowedVideoJoiningTimeMs) {
// Load extension renderers using reflection so that demo app doesn't depend on them.
// Class.forName(<class name>) appears for each renderer so that automated tools like proguard
// can detect the use of reflection (see http://proguard.sourceforge.net/FAQ.html#forname).
try {
Class<?> clazz =
Class.forName("com.google.android.exoplayer2.ext.vp9.LibvpxVideoTrackRenderer");
Class.forName("com.google.android.exoplayer2.ext.vp9.LibvpxVideoRenderer");
Constructor<?> constructor = clazz.getConstructor(boolean.class, long.class, Handler.class,
VideoTrackRendererEventListener.class, int.class);
renderersList.add((TrackRenderer) constructor.newInstance(true, allowedVideoJoiningTimeMs,
VideoRendererEventListener.class, int.class);
renderersList.add((Renderer) constructor.newInstance(true, allowedVideoJoiningTimeMs,
mainHandler, componentListener, MAX_DROPPED_VIDEO_FRAME_COUNT_TO_NOTIFY));
Log.i(TAG, "Loaded LibvpxVideoTrackRenderer.");
Log.i(TAG, "Loaded LibvpxVideoRenderer.");
} catch (ClassNotFoundException e) {
// Expected if the app was built without the extension.
} catch (Exception e) {
@ -437,11 +435,11 @@ public final class SimpleExoPlayer implements ExoPlayer {
try {
Class<?> clazz =
Class.forName("com.google.android.exoplayer2.ext.opus.LibopusAudioTrackRenderer");
Class.forName("com.google.android.exoplayer2.ext.opus.LibopusAudioRenderer");
Constructor<?> constructor = clazz.getConstructor(Handler.class,
AudioTrackRendererEventListener.class);
renderersList.add((TrackRenderer) constructor.newInstance(mainHandler, componentListener));
Log.i(TAG, "Loaded LibopusAudioTrackRenderer.");
AudioRendererEventListener.class);
renderersList.add((Renderer) constructor.newInstance(mainHandler, componentListener));
Log.i(TAG, "Loaded LibopusAudioRenderer.");
} catch (ClassNotFoundException e) {
// Expected if the app was built without the extension.
} catch (Exception e) {
@ -450,11 +448,11 @@ public final class SimpleExoPlayer implements ExoPlayer {
try {
Class<?> clazz =
Class.forName("com.google.android.exoplayer2.ext.flac.LibflacAudioTrackRenderer");
Class.forName("com.google.android.exoplayer2.ext.flac.LibflacAudioRenderer");
Constructor<?> constructor = clazz.getConstructor(Handler.class,
AudioTrackRendererEventListener.class);
renderersList.add((TrackRenderer) constructor.newInstance(mainHandler, componentListener));
Log.i(TAG, "Loaded LibflacAudioTrackRenderer.");
AudioRendererEventListener.class);
renderersList.add((Renderer) constructor.newInstance(mainHandler, componentListener));
Log.i(TAG, "Loaded LibflacAudioRenderer.");
} catch (ClassNotFoundException e) {
// Expected if the app was built without the extension.
} catch (Exception e) {
@ -463,11 +461,11 @@ public final class SimpleExoPlayer implements ExoPlayer {
try {
Class<?> clazz =
Class.forName("com.google.android.exoplayer2.ext.ffmpeg.FfmpegAudioTrackRenderer");
Class.forName("com.google.android.exoplayer2.ext.ffmpeg.FfmpegAudioRenderer");
Constructor<?> constructor = clazz.getConstructor(Handler.class,
AudioTrackRendererEventListener.class);
renderersList.add((TrackRenderer) constructor.newInstance(mainHandler, componentListener));
Log.i(TAG, "Loaded FfmpegAudioTrackRenderer.");
AudioRendererEventListener.class);
renderersList.add((Renderer) constructor.newInstance(mainHandler, componentListener));
Log.i(TAG, "Loaded FfmpegAudioRenderer.");
} catch (ClassNotFoundException e) {
// Expected if the app was built without the extension.
} catch (Exception e) {
@ -475,10 +473,10 @@ public final class SimpleExoPlayer implements ExoPlayer {
}
}
private final class ComponentListener implements VideoTrackRendererEventListener,
AudioTrackRendererEventListener, TextRenderer, MetadataRenderer<List<Id3Frame>> {
private final class ComponentListener implements VideoRendererEventListener,
AudioRendererEventListener, TextRenderer.Output, MetadataRenderer.Output<List<Id3Frame>> {
// VideoTrackRendererEventListener implementation
// VideoRendererEventListener implementation
@Override
public void onVideoEnabled(CodecCounters counters) {
@ -537,7 +535,7 @@ public final class SimpleExoPlayer implements ExoPlayer {
videoCodecCounters = null;
}
// AudioTrackRendererEventListener implementation
// AudioRendererEventListener implementation
@Override
public void onAudioEnabled(CodecCounters counters) {
@ -581,7 +579,7 @@ public final class SimpleExoPlayer implements ExoPlayer {
audioCodecCounters = null;
}
// TextRenderer implementation
// TextRendererOutput implementation
@Override
public void onCues(List<Cue> cues) {

12
library/src/main/java/com/google/android/exoplayer2/TrackSelectionPolicy.java
View file

@ -16,7 +16,7 @@
package com.google.android.exoplayer2;
/**
* Defines a policy for selecting the track rendered by each {@link TrackRenderer}.
* Defines a policy for selecting the track rendered by each {@link Renderer}.
*/
public abstract class TrackSelectionPolicy {
@ -49,17 +49,17 @@ public abstract class TrackSelectionPolicy {
}
/**
* Given an array of {@link TrackRenderer}s and a set of {@link TrackGroup}s assigned to each of
* Given an array of {@link Renderer}s and a set of {@link TrackGroup}s assigned to each of
* them, provides a {@link TrackSelection} per renderer.
*
* @param renderers The available {@link TrackRenderer}s.
* @param renderers The available {@link Renderer}s.
* @param rendererTrackGroupArrays An array of {@link TrackGroupArray}s where each entry
* corresponds to the {@link TrackRenderer} of equal index in {@code renderers}.
* corresponds to the {@link Renderer} of equal index in {@code renderers}.
* @param rendererFormatSupports Maps every available track to a specific level of support as
* defined by the {@link TrackRenderer} {@code FORMAT_*} constants.
* defined by the {@link Renderer} {@code FORMAT_*} constants.
* @throws ExoPlaybackException If an error occurs while selecting the tracks.
*/
protected abstract TrackSelection[] selectTracks(TrackRenderer[] renderers,
protected abstract TrackSelection[] selectTracks(Renderer[] renderers,
TrackGroupArray[] rendererTrackGroupArrays, int[][][] rendererFormatSupports)
throws ExoPlaybackException;

6
library/src/main/java/com/google/android/exoplayer2/TrackSelector.java
View file

@ -18,7 +18,7 @@ package com.google.android.exoplayer2;
import android.util.Pair;
/**
* Selects tracks to be consumed by available {@link TrackRenderer}s.
* Selects tracks to be consumed by available {@link Renderer}s.
*/
public abstract class TrackSelector {
@ -63,12 +63,12 @@ public abstract class TrackSelector {
* if the selection is activated.
* @throws ExoPlaybackException If an error occurs selecting tracks.
*/
protected abstract Pair<TrackSelectionArray, Object> selectTracks(TrackRenderer[] renderers,
protected abstract Pair<TrackSelectionArray, Object> selectTracks(Renderer[] renderers,
TrackGroupArray trackGroups) throws ExoPlaybackException;
/**
* Invoked when a selection previously generated by
* {@link #selectTracks(TrackRenderer[], TrackGroupArray)} is activated.
* {@link #selectTracks(Renderer[], TrackGroupArray)} is activated.
*
* @param selectionInfo The opaque object associated with the selection.
*/

10
library/src/main/java/com/google/android/exoplayer2/VideoTrackRendererEventListener.java → library/src/main/java/com/google/android/exoplayer2/VideoRendererEventListener.java
View file

@ -23,9 +23,9 @@ import android.view.Surface;
import android.view.TextureView;
/**
* Interface definition for a callback to be notified of video {@link TrackRenderer} events.
* Interface definition for a callback to be notified of video {@link Renderer} events.
*/
public interface VideoTrackRendererEventListener {
public interface VideoRendererEventListener {
/**
* Invoked when the renderer is enabled.
@ -101,14 +101,14 @@ public interface VideoTrackRendererEventListener {
void onVideoDisabled(CodecCounters counters);
/**
* Dispatches events to a {@link VideoTrackRendererEventListener}.
* Dispatches events to a {@link VideoRendererEventListener}.
*/
final class EventDispatcher {
private final Handler handler;
private final VideoTrackRendererEventListener listener;
private final VideoRendererEventListener listener;
public EventDispatcher(Handler handler, VideoTrackRendererEventListener listener) {
public EventDispatcher(Handler handler, VideoRendererEventListener listener) {
this.handler = listener != null ? Assertions.checkNotNull(handler) : null;
this.listener = listener;
}

22
library/src/main/java/com/google/android/exoplayer2/extensions/AudioDecoderTrackRenderer.java → library/src/main/java/com/google/android/exoplayer2/extensions/AudioDecoderRenderer.java
View file

@ -15,8 +15,8 @@
*/
package com.google.android.exoplayer2.extensions;
import com.google.android.exoplayer2.AudioTrackRendererEventListener;
import com.google.android.exoplayer2.AudioTrackRendererEventListener.EventDispatcher;
import com.google.android.exoplayer2.AudioRendererEventListener;
import com.google.android.exoplayer2.AudioRendererEventListener.EventDispatcher;
import com.google.android.exoplayer2.C;
import com.google.android.exoplayer2.CodecCounters;
import com.google.android.exoplayer2.DecoderInputBuffer;
@ -24,7 +24,7 @@ import com.google.android.exoplayer2.ExoPlaybackException;
import com.google.android.exoplayer2.Format;
import com.google.android.exoplayer2.FormatHolder;
import com.google.android.exoplayer2.MediaClock;
import com.google.android.exoplayer2.TrackRenderer;
import com.google.android.exoplayer2.Renderer;
import com.google.android.exoplayer2.TrackStream;
import com.google.android.exoplayer2.audio.AudioCapabilities;
import com.google.android.exoplayer2.audio.AudioTrack;
@ -39,7 +39,7 @@ import android.os.SystemClock;
/**
* Decodes and renders audio using a {@link SimpleDecoder}.
*/
public abstract class AudioDecoderTrackRenderer extends TrackRenderer implements MediaClock {
public abstract class AudioDecoderRenderer extends Renderer implements MediaClock {
private final EventDispatcher eventDispatcher;
private final FormatHolder formatHolder;
@ -62,7 +62,7 @@ public abstract class AudioDecoderTrackRenderer extends TrackRenderer implements
private boolean audioTrackHasData;
private long lastFeedElapsedRealtimeMs;
public AudioDecoderTrackRenderer() {
public AudioDecoderRenderer() {
this(null, null);
}
@ -71,8 +71,8 @@ public abstract class AudioDecoderTrackRenderer extends TrackRenderer implements
* null if delivery of events is not required.
* @param eventListener A listener of events. May be null if delivery of events is not required.
*/
public AudioDecoderTrackRenderer(Handler eventHandler,
AudioTrackRendererEventListener eventListener) {
public AudioDecoderRenderer(Handler eventHandler,
AudioRendererEventListener eventListener) {
this (eventHandler, eventListener, null, AudioManager.STREAM_MUSIC);
}
@ -84,8 +84,8 @@ public abstract class AudioDecoderTrackRenderer extends TrackRenderer implements
* default capabilities (no encoded audio passthrough support) should be assumed.
* @param streamType The type of audio stream for the {@link AudioTrack}.
*/
public AudioDecoderTrackRenderer(Handler eventHandler,
AudioTrackRendererEventListener eventListener, AudioCapabilities audioCapabilities,
public AudioDecoderRenderer(Handler eventHandler,
AudioRendererEventListener eventListener, AudioCapabilities audioCapabilities,
int streamType) {
eventDispatcher = new EventDispatcher(eventHandler, eventListener);
audioSessionId = AudioTrack.SESSION_ID_NOT_SET;
@ -193,14 +193,14 @@ public abstract class AudioDecoderTrackRenderer extends TrackRenderer implements
onAudioSessionId(audioSessionId);
}
audioTrackHasData = false;
if (getState() == TrackRenderer.STATE_STARTED) {
if (getState() == Renderer.STATE_STARTED) {
audioTrack.play();
}
} else {
// Check for AudioTrack underrun.
boolean audioTrackHadData = audioTrackHasData;
audioTrackHasData = audioTrack.hasPendingData();
if (audioTrackHadData && !audioTrackHasData && getState() == TrackRenderer.STATE_STARTED) {
if (audioTrackHadData && !audioTrackHasData && getState() == Renderer.STATE_STARTED) {
long elapsedSinceLastFeedMs = SystemClock.elapsedRealtime() - lastFeedElapsedRealtimeMs;
long bufferSizeUs = audioTrack.getBufferSizeUs();
long bufferSizeMs = bufferSizeUs == C.UNSET_TIME_US ? -1 : bufferSizeUs / 1000;

44
library/src/main/java/com/google/android/exoplayer2/metadata/MetadataTrackRenderer.java → library/src/main/java/com/google/android/exoplayer2/metadata/MetadataRenderer.java
View file

@ -20,7 +20,7 @@ import com.google.android.exoplayer2.DecoderInputBuffer;
import com.google.android.exoplayer2.ExoPlaybackException;
import com.google.android.exoplayer2.Format;
import com.google.android.exoplayer2.FormatHolder;
import com.google.android.exoplayer2.TrackRenderer;
import com.google.android.exoplayer2.Renderer;
import com.google.android.exoplayer2.TrackStream;
import com.google.android.exoplayer2.util.Assertions;
@ -33,18 +33,18 @@ import java.io.IOException;
import java.nio.ByteBuffer;
/**
* A {@link TrackRenderer} for metadata embedded in a media stream.
* A {@link Renderer} for metadata embedded in a media stream.
*
* @param <T> The type of the metadata.
*/
public final class MetadataTrackRenderer<T> extends TrackRenderer implements Callback {
public final class MetadataRenderer<T> extends Renderer implements Callback {
/**
* An interface for components that process metadata.
* An output for the renderer.
*
* @param <T> The type of the metadata.
*/
public interface MetadataRenderer<T> {
public interface Output<T> {
/**
* Invoked each time there is a metadata associated with current playback time.
@ -58,8 +58,8 @@ public final class MetadataTrackRenderer<T> extends TrackRenderer implements Cal
private static final int MSG_INVOKE_RENDERER = 0;
private final MetadataParser<T> metadataParser;
private final MetadataRenderer<T> metadataRenderer;
private final Handler metadataHandler;
private final Output<T> output;
private final Handler outputHandler;
private final FormatHolder formatHolder;
private final DecoderInputBuffer buffer;
@ -68,20 +68,18 @@ public final class MetadataTrackRenderer<T> extends TrackRenderer implements Cal
private T pendingMetadata;
/**
* @param output The output.
* @param outputLooper The looper associated with the thread on which the output should be
* invoked. If the output makes use of standard Android UI components, then this should
* normally be the looper associated with the application's main thread, which can be obtained
* using {@link android.app.Activity#getMainLooper()}. Null may be passed if the output
* should be invoked directly on the player's internal rendering thread.
* @param metadataParser A parser for parsing the metadata.
* @param metadataRenderer The metadata renderer to receive the parsed metadata.
* @param metadataRendererLooper The looper associated with the thread on which metadataRenderer
* should be invoked. If the renderer makes use of standard Android UI components, then this
* should normally be the looper associated with the applications' main thread, which can be
* obtained using {@link android.app.Activity#getMainLooper()}. Null may be passed if the
* renderer should be invoked directly on the player's internal rendering thread.
*/
public MetadataTrackRenderer(MetadataParser<T> metadataParser,
MetadataRenderer<T> metadataRenderer, Looper metadataRendererLooper) {
public MetadataRenderer(Output<T> output, Looper outputLooper, MetadataParser<T> metadataParser) {
this.output = Assertions.checkNotNull(output);
this.outputHandler = outputLooper == null ? null : new Handler(outputLooper, this);
this.metadataParser = Assertions.checkNotNull(metadataParser);
this.metadataRenderer = Assertions.checkNotNull(metadataRenderer);
this.metadataHandler = metadataRendererLooper == null ? null
: new Handler(metadataRendererLooper, this);
formatHolder = new FormatHolder();
buffer = new DecoderInputBuffer(DecoderInputBuffer.BUFFER_REPLACEMENT_MODE_NORMAL);
}
@ -93,8 +91,8 @@ public final class MetadataTrackRenderer<T> extends TrackRenderer implements Cal
@Override
protected int supportsFormat(Format format) {
return metadataParser.canParse(format.sampleMimeType) ? TrackRenderer.FORMAT_HANDLED
: TrackRenderer.FORMAT_UNSUPPORTED_TYPE;
return metadataParser.canParse(format.sampleMimeType) ? Renderer.FORMAT_HANDLED
: Renderer.FORMAT_UNSUPPORTED_TYPE;
}
@Override
@ -147,8 +145,8 @@ public final class MetadataTrackRenderer<T> extends TrackRenderer implements Cal
}
private void invokeRenderer(T metadata) {
if (metadataHandler != null) {
metadataHandler.obtainMessage(MSG_INVOKE_RENDERER, metadata).sendToTarget();
if (outputHandler != null) {
outputHandler.obtainMessage(MSG_INVOKE_RENDERER, metadata).sendToTarget();
} else {
invokeRendererInternal(metadata);
}
@ -166,7 +164,7 @@ public final class MetadataTrackRenderer<T> extends TrackRenderer implements Cal
}
private void invokeRendererInternal(T metadata) {
metadataRenderer.onMetadata(metadata);
output.onMetadata(metadata);
}
}

268
library/src/main/java/com/google/android/exoplayer2/text/TextRenderer.java
View file

@ -15,18 +15,274 @@
*/
package com.google.android.exoplayer2.text;
import com.google.android.exoplayer2.C;
import com.google.android.exoplayer2.ExoPlaybackException;
import com.google.android.exoplayer2.Format;
import com.google.android.exoplayer2.FormatHolder;
import com.google.android.exoplayer2.ParserException;
import com.google.android.exoplayer2.Renderer;
import com.google.android.exoplayer2.TrackStream;
import com.google.android.exoplayer2.extensions.Decoder;
import com.google.android.exoplayer2.util.Assertions;
import com.google.android.exoplayer2.util.MimeTypes;
import android.annotation.TargetApi;
import android.os.Handler;
import android.os.Handler.Callback;
import android.os.Looper;
import android.os.Message;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
/**
* An interface for components that render text.
* A {@link Renderer} for subtitles.
* <p>
* Text is parsed from sample data using {@link Decoder} instances obtained from a
* {@link SubtitleParserFactory}. The actual rendering of each line of text is delegated to a
* {@link Output}.
*/
public interface TextRenderer {
@TargetApi(16)
public final class TextRenderer extends Renderer implements Callback {
/**
* Invoked each time there is a change in the {@link Cue}s to be rendered.
*
* @param cues The {@link Cue}s to be rendered, or an empty list if no cues are to be rendered.
* An output for the renderer.
*/
void onCues(List<Cue> cues);
public interface Output {
/**
* Invoked each time there is a change in the {@link Cue}s.
*
* @param cues The {@link Cue}s.
*/
void onCues(List<Cue> cues);
}
private static final int MSG_UPDATE_OUTPUT = 0;
private final Handler outputHandler;
private final Output output;
private final SubtitleParserFactory parserFactory;
private final FormatHolder formatHolder;
private boolean inputStreamEnded;
private boolean outputStreamEnded;
private SubtitleParser parser;
private SubtitleInputBuffer nextInputBuffer;
private SubtitleOutputBuffer subtitle;
private SubtitleOutputBuffer nextSubtitle;
private int nextSubtitleEventIndex;
/**
* @param output The output.
* @param outputLooper The looper associated with the thread on which the output should be
* invoked. If the output makes use of standard Android UI components, then this should
* normally be the looper associated with the application's main thread, which can be obtained
* using {@link android.app.Activity#getMainLooper()}. Null may be passed if the output
* should be invoked directly on the player's internal rendering thread.
*/
public TextRenderer(Output output, Looper outputLooper) {
this(output, outputLooper, SubtitleParserFactory.DEFAULT);
}
/**
* @param output The output.
* @param outputLooper The looper associated with the thread on which the output should be
* invoked. If the output makes use of standard Android UI components, then this should
* normally be the looper associated with the application's main thread, which can be obtained
* using {@link android.app.Activity#getMainLooper()}. Null may be passed if the output
* should be invoked directly on the player's internal rendering thread.
* @param parserFactory A factory from which to obtain {@link Decoder} instances.
*/
public TextRenderer(Output output, Looper outputLooper, SubtitleParserFactory parserFactory) {
this.output = Assertions.checkNotNull(output);
this.outputHandler = outputLooper == null ? null : new Handler(outputLooper, this);
this.parserFactory = parserFactory;
formatHolder = new FormatHolder();
}
@Override
public int getTrackType() {
return C.TRACK_TYPE_TEXT;
}
@Override
protected int supportsFormat(Format format) {
return parserFactory.supportsFormat(format) ? Renderer.FORMAT_HANDLED
: (MimeTypes.isText(format.sampleMimeType) ? FORMAT_UNSUPPORTED_SUBTYPE
: FORMAT_UNSUPPORTED_TYPE);
}
@Override
protected void onStreamChanged(Format[] formats) throws ExoPlaybackException {
if (parser != null) {
parser.release();
}
parser = parserFactory.createParser(formats[0]);
}
@Override
protected void onReset(long positionUs, boolean joining) {
inputStreamEnded = false;
outputStreamEnded = false;
if (subtitle != null) {
subtitle.release();
subtitle = null;
}
if (nextSubtitle != null) {
nextSubtitle.release();
nextSubtitle = null;
}
nextInputBuffer = null;
clearOutput();
parser.flush();
}
@Override
protected void render(long positionUs, long elapsedRealtimeUs) throws ExoPlaybackException {
if (outputStreamEnded) {
return;
}
if (nextSubtitle == null) {
parser.setPositionUs(positionUs);
try {
nextSubtitle = parser.dequeueOutputBuffer();
} catch (IOException e) {
throw ExoPlaybackException.createForRenderer(e, getIndex());
}
}
if (getState() != Renderer.STATE_STARTED) {
return;
}
boolean textRendererNeedsUpdate = false;
if (subtitle != null) {
// We're iterating through the events in a subtitle. Set textRendererNeedsUpdate if we
// advance to the next event.
long subtitleNextEventTimeUs = getNextEventTime();
while (subtitleNextEventTimeUs <= positionUs) {
nextSubtitleEventIndex++;
subtitleNextEventTimeUs = getNextEventTime();
textRendererNeedsUpdate = true;
}
}
if (nextSubtitle != null && nextSubtitle.timestampUs <= positionUs) {
// Advance to the next subtitle. Sync the next event index and trigger an update.
if (subtitle != null) {
subtitle.release();
}
subtitle = nextSubtitle;
nextSubtitle = null;
if (subtitle.isEndOfStream()) {
outputStreamEnded = true;
subtitle.release();
subtitle = null;
return;
}
nextSubtitleEventIndex = subtitle.getNextEventTimeIndex(positionUs);
textRendererNeedsUpdate = true;
}
if (textRendererNeedsUpdate) {
// textRendererNeedsUpdate is set and we're playing. Update the renderer.
updateOutput(subtitle.getCues(positionUs));
}
try {
while (!inputStreamEnded) {
if (nextInputBuffer == null) {
nextInputBuffer = parser.dequeueInputBuffer();
if (nextInputBuffer == null) {
return;
}
}
// Try and read the next subtitle from the source.
int result = readSource(formatHolder, nextInputBuffer);
if (result == TrackStream.BUFFER_READ) {
// Clear BUFFER_FLAG_DECODE_ONLY (see [Internal: b/27893809]) and queue the buffer.
nextInputBuffer.clearFlag(C.BUFFER_FLAG_DECODE_ONLY);
if (nextInputBuffer.isEndOfStream()) {
inputStreamEnded = true;
} else {
nextInputBuffer.subsampleOffsetUs = formatHolder.format.subsampleOffsetUs;
nextInputBuffer.flip();
}
parser.queueInputBuffer(nextInputBuffer);
nextInputBuffer = null;
} else if (result == TrackStream.NOTHING_READ) {
break;
}
}
} catch (ParserException e) {
throw ExoPlaybackException.createForRenderer(e, getIndex());
}
}
@Override
protected void onDisabled() {
if (subtitle != null) {
subtitle.release();
subtitle = null;
}
if (nextSubtitle != null) {
nextSubtitle.release();
nextSubtitle = null;
}
parser.release();
parser = null;
nextInputBuffer = null;
clearOutput();
super.onDisabled();
}
@Override
protected boolean isEnded() {
return outputStreamEnded;
}
@Override
protected boolean isReady() {
// Don't block playback whilst subtitles are loading.
// Note: To change this behavior, it will be necessary to consider [Internal: b/12949941].
return true;
}
private long getNextEventTime() {
return ((nextSubtitleEventIndex == -1)
|| (nextSubtitleEventIndex >= subtitle.getEventTimeCount())) ? Long.MAX_VALUE
: (subtitle.getEventTime(nextSubtitleEventIndex));
}
private void updateOutput(List<Cue> cues) {
if (outputHandler != null) {
outputHandler.obtainMessage(MSG_UPDATE_OUTPUT, cues).sendToTarget();
} else {
invokeUpdateOutputInternal(cues);
}
}
private void clearOutput() {
updateOutput(Collections.<Cue>emptyList());
}
@SuppressWarnings("unchecked")
@Override
public boolean handleMessage(Message msg) {
switch (msg.what) {
case MSG_UPDATE_OUTPUT:
invokeUpdateOutputInternal((List<Cue>) msg.obj);
return true;
}
return false;
}
private void invokeUpdateOutputInternal(List<Cue> cues) {
output.onCues(cues);
}
}

276
library/src/main/java/com/google/android/exoplayer2/text/TextTrackRenderer.java
View file

@ -1,276 +0,0 @@
/*
* Copyright (C) 2016 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 com.google.android.exoplayer2.text;
import com.google.android.exoplayer2.C;
import com.google.android.exoplayer2.ExoPlaybackException;
import com.google.android.exoplayer2.Format;
import com.google.android.exoplayer2.FormatHolder;
import com.google.android.exoplayer2.ParserException;
import com.google.android.exoplayer2.TrackRenderer;
import com.google.android.exoplayer2.TrackStream;
import com.google.android.exoplayer2.extensions.Decoder;
import com.google.android.exoplayer2.util.Assertions;
import com.google.android.exoplayer2.util.MimeTypes;
import android.annotation.TargetApi;
import android.os.Handler;
import android.os.Handler.Callback;
import android.os.Looper;
import android.os.Message;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
/**
* A {@link TrackRenderer} for subtitles.
* <p>
* Text is parsed from sample data using {@link Decoder} instances obtained from a
* {@link SubtitleParserFactory}. The actual rendering of each line of text is delegated to a
* {@link TextRenderer}.
*/
@TargetApi(16)
public final class TextTrackRenderer extends TrackRenderer implements Callback {
private static final int MSG_UPDATE_OVERLAY = 0;
private final Handler textRendererHandler;
private final TextRenderer textRenderer;
private final SubtitleParserFactory parserFactory;
private final FormatHolder formatHolder;
private boolean inputStreamEnded;
private boolean outputStreamEnded;
private SubtitleParser parser;
private SubtitleInputBuffer nextInputBuffer;
private SubtitleOutputBuffer subtitle;
private SubtitleOutputBuffer nextSubtitle;
private int nextSubtitleEventIndex;
/**
* @param textRenderer The text renderer.
* @param textRendererLooper The looper associated with the thread on which textRenderer should be
* invoked. If the renderer makes use of standard Android UI components, then this should
* normally be the looper associated with the application's main thread, which can be obtained
* using {@link android.app.Activity#getMainLooper()}. Null may be passed if the renderer
* should be invoked directly on the player's internal rendering thread.
*/
public TextTrackRenderer(TextRenderer textRenderer, Looper textRendererLooper) {
this(textRenderer, textRendererLooper, SubtitleParserFactory.DEFAULT);
}
/**
* @param textRenderer The text renderer.
* @param textRendererLooper The looper associated with the thread on which textRenderer should be
* invoked. If the renderer makes use of standard Android UI components, then this should
* normally be the looper associated with the application's main thread, which can be obtained
* using {@link android.app.Activity#getMainLooper()}. Null may be passed if the renderer
* should be invoked directly on the player's internal rendering thread.
* @param parserFactory A factory from which to obtain {@link Decoder} instances.
*/
public TextTrackRenderer(TextRenderer textRenderer, Looper textRendererLooper,
SubtitleParserFactory parserFactory) {
this.textRenderer = Assertions.checkNotNull(textRenderer);
this.textRendererHandler = textRendererLooper == null ? null
: new Handler(textRendererLooper, this);
this.parserFactory = parserFactory;
formatHolder = new FormatHolder();
}
@Override
public int getTrackType() {
return C.TRACK_TYPE_TEXT;
}
@Override
protected int supportsFormat(Format format) {
return parserFactory.supportsFormat(format) ? TrackRenderer.FORMAT_HANDLED
: (MimeTypes.isText(format.sampleMimeType) ? FORMAT_UNSUPPORTED_SUBTYPE
: FORMAT_UNSUPPORTED_TYPE);
}
@Override
protected void onStreamChanged(Format[] formats) throws ExoPlaybackException {
if (parser != null) {
parser.release();
}
parser = parserFactory.createParser(formats[0]);
}
@Override
protected void onReset(long positionUs, boolean joining) {
inputStreamEnded = false;
outputStreamEnded = false;
if (subtitle != null) {
subtitle.release();
subtitle = null;
}
if (nextSubtitle != null) {
nextSubtitle.release();
nextSubtitle = null;
}
nextInputBuffer = null;
clearTextRenderer();
parser.flush();
}
@Override
protected void render(long positionUs, long elapsedRealtimeUs) throws ExoPlaybackException {
if (outputStreamEnded) {
return;
}
if (nextSubtitle == null) {
parser.setPositionUs(positionUs);
try {
nextSubtitle = parser.dequeueOutputBuffer();
} catch (IOException e) {
throw ExoPlaybackException.createForRenderer(e, getIndex());
}
}
if (getState() != TrackRenderer.STATE_STARTED) {
return;
}
boolean textRendererNeedsUpdate = false;
if (subtitle != null) {
// We're iterating through the events in a subtitle. Set textRendererNeedsUpdate if we
// advance to the next event.
long subtitleNextEventTimeUs = getNextEventTime();
while (subtitleNextEventTimeUs <= positionUs) {
nextSubtitleEventIndex++;
subtitleNextEventTimeUs = getNextEventTime();
textRendererNeedsUpdate = true;
}
}
if (nextSubtitle != null && nextSubtitle.timestampUs <= positionUs) {
// Advance to the next subtitle. Sync the next event index and trigger an update.
if (subtitle != null) {
subtitle.release();
}
subtitle = nextSubtitle;
nextSubtitle = null;
if (subtitle.isEndOfStream()) {
outputStreamEnded = true;
subtitle.release();
subtitle = null;
return;
}
nextSubtitleEventIndex = subtitle.getNextEventTimeIndex(positionUs);
textRendererNeedsUpdate = true;
}
if (textRendererNeedsUpdate) {
// textRendererNeedsUpdate is set and we're playing. Update the renderer.
updateTextRenderer(subtitle.getCues(positionUs));
}
try {
while (!inputStreamEnded) {
if (nextInputBuffer == null) {
nextInputBuffer = parser.dequeueInputBuffer();
if (nextInputBuffer == null) {
return;
}
}
// Try and read the next subtitle from the source.
int result = readSource(formatHolder, nextInputBuffer);
if (result == TrackStream.BUFFER_READ) {
// Clear BUFFER_FLAG_DECODE_ONLY (see [Internal: b/27893809]) and queue the buffer.
nextInputBuffer.clearFlag(C.BUFFER_FLAG_DECODE_ONLY);
if (nextInputBuffer.isEndOfStream()) {
inputStreamEnded = true;
} else {
nextInputBuffer.subsampleOffsetUs = formatHolder.format.subsampleOffsetUs;
nextInputBuffer.flip();
}
parser.queueInputBuffer(nextInputBuffer);
nextInputBuffer = null;
} else if (result == TrackStream.NOTHING_READ) {
break;
}
}
} catch (ParserException e) {
throw ExoPlaybackException.createForRenderer(e, getIndex());
}
}
@Override
protected void onDisabled() {
if (subtitle != null) {
subtitle.release();
subtitle = null;
}
if (nextSubtitle != null) {
nextSubtitle.release();
nextSubtitle = null;
}
parser.release();
parser = null;
nextInputBuffer = null;
clearTextRenderer();
super.onDisabled();
}
@Override
protected boolean isEnded() {
return outputStreamEnded;
}
@Override
protected boolean isReady() {
// Don't block playback whilst subtitles are loading.
// Note: To change this behavior, it will be necessary to consider [Internal: b/12949941].
return true;
}
private long getNextEventTime() {
return ((nextSubtitleEventIndex == -1)
|| (nextSubtitleEventIndex >= subtitle.getEventTimeCount())) ? Long.MAX_VALUE
: (subtitle.getEventTime(nextSubtitleEventIndex));
}
private void updateTextRenderer(List<Cue> cues) {
if (textRendererHandler != null) {
textRendererHandler.obtainMessage(MSG_UPDATE_OVERLAY, cues).sendToTarget();
} else {
invokeRendererInternalCues(cues);
}
}
private void clearTextRenderer() {
updateTextRenderer(Collections.<Cue>emptyList());
}
@SuppressWarnings("unchecked")
@Override
public boolean handleMessage(Message msg) {
switch (msg.what) {
case MSG_UPDATE_OVERLAY:
invokeRendererInternalCues((List<Cue>) msg.obj);
return true;
}
return false;
}
private void invokeRendererInternalCues(List<Cue> cues) {
textRenderer.onCues(cues);
}
}

2
library/src/main/java/com/google/android/exoplayer2/text/webvtt/WebvttCueParser.java
View file

@ -147,7 +147,7 @@ import java.util.regex.Pattern;
* @param id Id of the cue, {@code null} if it is not present.
* @param markup The markup text to be parsed.
* @param styles List of styles defined by the CSS style blocks preceeding the cues.
* @param builder Target builder.
* @param builder Output builder.
*/
/* package */ static void parseCueText(String id, String markup, WebvttCue.Builder builder,
List<WebvttCssStyle> styles) {

6
library/src/main/java/com/google/android/exoplayer2/util/PlayerControl.java
View file

@ -16,6 +16,7 @@
package com.google.android.exoplayer2.util;
import com.google.android.exoplayer2.ExoPlayer;
import com.google.android.exoplayer2.MediaCodecAudioRenderer;
import android.widget.MediaController.MediaPlayerControl;
@ -52,9 +53,8 @@ public class PlayerControl implements MediaPlayerControl {
* This is an unsupported operation.
* <p>
* Application of audio effects is dependent on the audio renderer used. When using
* {@link com.google.android.exoplayer2.MediaCodecAudioTrackRenderer}, the recommended approach is
* to extend the class and override
* {@link com.google.android.exoplayer2.MediaCodecAudioTrackRenderer#onAudioSessionId}.
* {@link MediaCodecAudioRenderer}, the recommended approach is to extend the class and override
* {@link MediaCodecAudioRenderer#onAudioSessionId}.
*
* @throws UnsupportedOperationException Always thrown.
*/

10
playbacktests/src/main/java/com/google/android/exoplayer2/playbacktests/gts/DashTest.java
View file

@ -23,9 +23,9 @@ import com.google.android.exoplayer2.ExoPlayer;
import com.google.android.exoplayer2.MediaCodecUtil;
import com.google.android.exoplayer2.MediaCodecUtil.DecoderQueryException;
import com.google.android.exoplayer2.MediaSource;
import com.google.android.exoplayer2.Renderer;
import com.google.android.exoplayer2.TrackGroup;
import com.google.android.exoplayer2.TrackGroupArray;
import com.google.android.exoplayer2.TrackRenderer;
import com.google.android.exoplayer2.TrackSelection;
import com.google.android.exoplayer2.TrackSelectionPolicy;
import com.google.android.exoplayer2.dash.DashMediaSource;
@ -444,7 +444,7 @@ public final class DashTest extends ActivityInstrumentationTestCase2<HostActivit
// We shouldn't have skipped any output buffers.
CodecCountersUtil.assertSkippedOutputBufferCount(AUDIO_TAG, audioCounters, 0);
CodecCountersUtil.assertSkippedOutputBufferCount(VIDEO_TAG, videoCounters, 0);
// We allow one fewer output buffer due to the way that MediaCodecTrackRenderer and the
// We allow one fewer output buffer due to the way that MediaCodecRenderer and the
// underlying decoders handle the end of stream. This should be tightened up in the future.
CodecCountersUtil.assertTotalOutputBufferCount(AUDIO_TAG, audioCounters,
audioCounters.inputBufferCount - 1, audioCounters.inputBufferCount);
@ -490,7 +490,7 @@ public final class DashTest extends ActivityInstrumentationTestCase2<HostActivit
}
@Override
protected TrackSelection[] selectTracks(TrackRenderer[] renderers,
protected TrackSelection[] selectTracks(Renderer[] renderers,
TrackGroupArray[] rendererTrackGroupArrays, int[][][] rendererFormatSupports)
throws ExoPlaybackException {
Assertions.checkState(renderers[VIDEO_RENDERER_INDEX].getTrackType() == C.TRACK_TYPE_VIDEO);
@ -531,8 +531,8 @@ public final class DashTest extends ActivityInstrumentationTestCase2<HostActivit
// Select additional video representations, if supported by the device.
if (canIncludeAdditionalFormats) {
for (int i = 0; i < trackGroup.length; i++) {
if (!trackIndices.contains(i) && (formatSupport[i] & TrackRenderer.FORMAT_SUPPORT_MASK)
== TrackRenderer.FORMAT_HANDLED) {
if (!trackIndices.contains(i) && (formatSupport[i] & Renderer.FORMAT_SUPPORT_MASK)
== Renderer.FORMAT_HANDLED) {
Log.d(TAG, "Adding video format: " + trackGroup.getFormat(i).id);
trackIndices.add(i);
}

12
playbacktests/src/main/java/com/google/android/exoplayer2/playbacktests/util/DebugMediaCodecVideoTrackRenderer.java → playbacktests/src/main/java/com/google/android/exoplayer2/playbacktests/util/DebugMediaCodecVideoRenderer.java
View file

@ -18,19 +18,19 @@ package com.google.android.exoplayer2.playbacktests.util;
import com.google.android.exoplayer2.DecoderInputBuffer;
import com.google.android.exoplayer2.ExoPlaybackException;
import com.google.android.exoplayer2.MediaCodecSelector;
import com.google.android.exoplayer2.MediaCodecVideoTrackRenderer;
import com.google.android.exoplayer2.VideoTrackRendererEventListener;
import com.google.android.exoplayer2.MediaCodecVideoRenderer;
import com.google.android.exoplayer2.VideoRendererEventListener;
import android.annotation.TargetApi;
import android.content.Context;
import android.os.Handler;
/**
* Decodes and renders video using {@link MediaCodecVideoTrackRenderer}. Provides buffer timestamp
* Decodes and renders video using {@link MediaCodecVideoRenderer}. Provides buffer timestamp
* assertions.
*/
@TargetApi(16)
public class DebugMediaCodecVideoTrackRenderer extends MediaCodecVideoTrackRenderer {
public class DebugMediaCodecVideoRenderer extends MediaCodecVideoRenderer {
private static final int ARRAY_SIZE = 1000;
@ -40,9 +40,9 @@ public class DebugMediaCodecVideoTrackRenderer extends MediaCodecVideoTrackRende
private int queueSize;
private int bufferCount;
public DebugMediaCodecVideoTrackRenderer(Context context, MediaCodecSelector mediaCodecSelector,
public DebugMediaCodecVideoRenderer(Context context, MediaCodecSelector mediaCodecSelector,
int videoScalingMode, long allowedJoiningTimeMs, Handler eventHandler,
VideoTrackRendererEventListener eventListener, int maxDroppedFrameCountToNotify) {
VideoRendererEventListener eventListener, int maxDroppedFrameCountToNotify) {
super(context, mediaCodecSelector, videoScalingMode, allowedJoiningTimeMs, null, false,
eventHandler, eventListener, maxDroppedFrameCountToNotify);
startIndex = 0;