import com.google.android.exoplayer.drm.DrmSessionManager; //导入依赖的package包/类
/**
 * @param source The upstream source from which the renderer obtains samples.
 * @param drmSessionManager For use with encrypted media. May be null if support for encrypted
 *          media is not required.
 * @param playClearSamplesWithoutKeys Encrypted media may contain clear (un-encrypted) regions.
 *          For example a media file may start with a short clear region so as to allow playback
 *          to
 *          begin in parallel with key acquisision. This parameter specifies whether the renderer
 *          is
 *          permitted to play clear regions of encrypted media files before
 *          {@code drmSessionManager}
 *          has obtained the keys necessary to decrypt encrypted regions of the media.
 * @param eventHandler A handler to use when delivering events to {@code eventListener}. May be
 *          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 MediaCodecTrackRenderer(SampleSource source, DrmSessionManager drmSessionManager,
    boolean playClearSamplesWithoutKeys, Handler eventHandler, EventListener eventListener) {
  Assertions.checkState(Util.SDK_INT >= 16);
  this.source = source.register();
  this.drmSessionManager = drmSessionManager;
  this.playClearSamplesWithoutKeys = playClearSamplesWithoutKeys;
  this.eventHandler = eventHandler;
  this.eventListener = eventListener;
  codecCounters = new CodecCounters();
  sampleHolder = new SampleHolder(SampleHolder.BUFFER_REPLACEMENT_MODE_DISABLED);
  formatHolder = new MediaFormatHolder();
  decodeOnlyPresentationTimestamps = new ArrayList<>();
  outputBufferInfo = new MediaCodec.BufferInfo();
  codecReconfigurationState = RECONFIGURATION_STATE_NONE;
  codecReinitializationState = REINITIALIZATION_STATE_NONE;
}
 

import com.google.android.exoplayer.drm.DrmSessionManager; //导入依赖的package包/类
/**
 * @param sources The upstream sources from which the renderer obtains samples.
 * @param mediaCodecSelector A decoder selector.
 * @param drmSessionManager For use with encrypted media. May be null if support for encrypted
 *     media is not required.
 * @param playClearSamplesWithoutKeys Encrypted media may contain clear (un-encrypted) regions.
 *     For example a media file may start with a short clear region so as to allow playback to
 *     begin in parallel with key acquisition. This parameter specifies whether the renderer is
 *     permitted to play clear regions of encrypted media files before {@code drmSessionManager}
 *     has obtained the keys necessary to decrypt encrypted regions of the media.
 * @param eventHandler A handler to use when delivering events to {@code eventListener}. May be
 *     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 MediaCodecTrackRenderer(SampleSource[] sources, MediaCodecSelector mediaCodecSelector,
    DrmSessionManager drmSessionManager, boolean playClearSamplesWithoutKeys,
    Handler eventHandler, EventListener eventListener) {
  super(sources);
  Assertions.checkState(Util.SDK_INT >= 16);
  this.mediaCodecSelector = Assertions.checkNotNull(mediaCodecSelector);
  this.drmSessionManager = drmSessionManager;
  this.playClearSamplesWithoutKeys = playClearSamplesWithoutKeys;
  this.eventHandler = eventHandler;
  this.eventListener = eventListener;
  deviceNeedsAutoFrcWorkaround = deviceNeedsAutoFrcWorkaround();
  codecCounters = new CodecCounters();
  sampleHolder = new SampleHolder(SampleHolder.BUFFER_REPLACEMENT_MODE_DISABLED);
  formatHolder = new MediaFormatHolder();
  decodeOnlyPresentationTimestamps = new ArrayList<>();
  outputBufferInfo = new MediaCodec.BufferInfo();
  codecReconfigurationState = RECONFIGURATION_STATE_NONE;
  codecReinitializationState = REINITIALIZATION_STATE_NONE;
}
 

import com.google.android.exoplayer.drm.DrmSessionManager; //导入依赖的package包/类
protected void buildRenderers(SmoothStreamingManifest manifest) {
    if (canceled) {
        return;
    }

    // Check drm support if necessary.
    DrmSessionManager drmSessionManager = null;
    if (manifest.protectionElement != null) {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR2) {
            player.onRenderersError(new UnsupportedDrmException(UnsupportedDrmException.REASON_UNSUPPORTED_SCHEME));
            return;
        }

        try {
            drmSessionManager = StreamingDrmSessionManager.newFrameworkInstance(manifest.protectionElement.uuid, player.getPlaybackLooper(), null, null, player.getMainHandler(), player);
        } catch (UnsupportedDrmException e) {
            player.onRenderersError(e);
            return;
        }
    }

    buildTrackRenderers(drmSessionManager);
}
 

import com.google.android.exoplayer.drm.DrmSessionManager; //导入依赖的package包/类
/**
 * @param source The upstream source from which the renderer obtains samples.
 * @param drmSessionManager For use with encrypted media. May be null if support for encrypted
 *     media is not required.
 * @param playClearSamplesWithoutKeys Encrypted media may contain clear (un-encrypted) regions.
 *     For example a media file may start with a short clear region so as to allow playback to
 *     begin in parallel with key acquisision. This parameter specifies whether the renderer is
 *     permitted to play clear regions of encrypted media files before {@code drmSessionManager}
 *     has obtained the keys necessary to decrypt encrypted regions of the media.
 * @param eventHandler A handler to use when delivering events to {@code eventListener}. May be
 *     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 MediaCodecTrackRenderer(SampleSource source, DrmSessionManager drmSessionManager,
    boolean playClearSamplesWithoutKeys, Handler eventHandler, EventListener eventListener) {
  Assertions.checkState(Util.SDK_INT >= 16);
  this.source = source;
  this.drmSessionManager = drmSessionManager;
  this.playClearSamplesWithoutKeys = playClearSamplesWithoutKeys;
  this.eventHandler = eventHandler;
  this.eventListener = eventListener;
  codecCounters = new CodecCounters();
  sampleHolder = new SampleHolder(SampleHolder.BUFFER_REPLACEMENT_MODE_DISABLED);
  formatHolder = new MediaFormatHolder();
  decodeOnlyPresentationTimestamps = new ArrayList<Long>();
  outputBufferInfo = new MediaCodec.BufferInfo();

}
 

import com.google.android.exoplayer.drm.DrmSessionManager; //导入依赖的package包/类
/**
 * @param source The upstream source from which the renderer obtains samples.
 * @param drmSessionManager For use with encrypted content. May be null if support for encrypted
 *     content is not required.
 * @param playClearSamplesWithoutKeys Encrypted media may contain clear (un-encrypted) regions.
 *     For example a media file may start with a short clear region so as to allow playback to
 *     begin in parallel with key acquisision. This parameter specifies whether the renderer is
 *     permitted to play clear regions of encrypted media files before {@code drmSessionManager}
 *     has obtained the keys necessary to decrypt encrypted regions of the media.
 * @param minBufferMultiplicationFactor When instantiating an underlying {@link AudioTrack},
 *     the size of the track's is calculated as this value multiplied by the minimum buffer size
 *     obtained from {@link AudioTrack#getMinBufferSize(int, int, int)}. The multiplication
 *     factor must be greater than or equal to 1.
 * @param eventHandler A handler to use when delivering events to {@code eventListener}. May be
 *     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(SampleSource source, DrmSessionManager drmSessionManager,
    boolean playClearSamplesWithoutKeys, float minBufferMultiplicationFactor,
    Handler eventHandler, EventListener eventListener) {
  super(source, drmSessionManager, playClearSamplesWithoutKeys, eventHandler, eventListener);
  Assertions.checkState(minBufferMultiplicationFactor >= 1);
  this.minBufferMultiplicationFactor = minBufferMultiplicationFactor;
  this.eventListener = eventListener;
  audioTrackReleasingConditionVariable = new ConditionVariable(true);
  if (Util.SDK_INT >= 19) {
    audioTimestampCompat = new AudioTimestampCompatV19();
  } else {
    audioTimestampCompat = new NoopAudioTimestampCompat();
  }
  if (Util.SDK_INT >= 18) {
    try {
      audioTrackGetLatencyMethod = AudioTrack.class.getMethod("getLatency", (Class<?>[]) null);
    } catch (NoSuchMethodException e) {
      // There's no guarantee this method exists. Do nothing.
    }
  }
  playheadOffsets = new long[MAX_PLAYHEAD_OFFSET_COUNT];
  volume = 1.0f;
}
 

import com.google.android.exoplayer.drm.DrmSessionManager; //导入依赖的package包/类
/**
 * @param source The upstream source from which the renderer obtains samples.
 * @param drmSessionManager For use with encrypted media. May be null if support for encrypted
 *     media is not required.
 * @param playClearSamplesWithoutKeys Encrypted media may contain clear (un-encrypted) regions.
 *     For example a media file may start with a short clear region so as to allow playback to
 *     begin in parallel with key acquisision. This parameter specifies whether the renderer is
 *     permitted to play clear regions of encrypted media files before {@code drmSessionManager}
 *     has obtained the keys necessary to decrypt encrypted regions of the media.
 * @param eventHandler A handler to use when delivering events to {@code eventListener}. May be
 *     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 MediaCodecTrackRenderer(SampleSource source, DrmSessionManager drmSessionManager,
    boolean playClearSamplesWithoutKeys, Handler eventHandler, EventListener eventListener) {
  Assertions.checkState(Util.SDK_INT >= 16);
  this.source = source.register();
  this.drmSessionManager = drmSessionManager;
  this.playClearSamplesWithoutKeys = playClearSamplesWithoutKeys;
  this.eventHandler = eventHandler;
  this.eventListener = eventListener;
  codecCounters = new CodecCounters();
  sampleHolder = new SampleHolder(SampleHolder.BUFFER_REPLACEMENT_MODE_DISABLED);
  formatHolder = new MediaFormatHolder();
  decodeOnlyPresentationTimestamps = new ArrayList<>();
  outputBufferInfo = new MediaCodec.BufferInfo();
  codecReconfigurationState = RECONFIGURATION_STATE_NONE;
  codecReinitializationState = REINITIALIZATION_STATE_NONE;
}
 

import com.google.android.exoplayer.drm.DrmSessionManager; //导入依赖的package包/类
/**
 * @param source The upstream source from which the renderer obtains samples.
 * @param drmSessionManager For use with encrypted content. May be null if support for encrypted
 *     content is not required.
 * @param playClearSamplesWithoutKeys Encrypted media may contain clear (un-encrypted) regions.
 *     For example a media file may start with a short clear region so as to allow playback to
 *     begin in parallel with key acquisision. This parameter specifies whether the renderer is
 *     permitted to play clear regions of encrypted media files before {@code drmSessionManager}
 *     has obtained the keys necessary to decrypt encrypted regions of the media.
 * @param minBufferMultiplicationFactor When instantiating an underlying {@link android.media.AudioTrack},
 *     the size of the track's is calculated as this value multiplied by the minimum buffer size
 *     obtained from {@link android.media.AudioTrack#getMinBufferSize(int, int, int)}. The multiplication
 *     factor must be greater than or equal to 1.
 * @param eventHandler A handler to use when delivering events to {@code eventListener}. May be
 *     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(SampleSource source, DrmSessionManager drmSessionManager,
    boolean playClearSamplesWithoutKeys, float minBufferMultiplicationFactor,
    Handler eventHandler, EventListener eventListener) {
  super(source, drmSessionManager, playClearSamplesWithoutKeys, eventHandler, eventListener);
  Assertions.checkState(minBufferMultiplicationFactor >= 1);
  this.minBufferMultiplicationFactor = minBufferMultiplicationFactor;
  this.eventListener = eventListener;
  audioTrackReleasingConditionVariable = new ConditionVariable(true);
  if (Util.SDK_INT >= 19) {
    audioTimestampCompat = new AudioTimestampCompatV19();
  } else {
    audioTimestampCompat = new NoopAudioTimestampCompat();
  }
  if (Util.SDK_INT >= 18) {
    try {
      audioTrackGetLatencyMethod = AudioTrack.class.getMethod("getLatency", (Class<?>[]) null);
    } catch (NoSuchMethodException e) {
      // There's no guarantee this method exists. Do nothing.
    }
  }
  playheadOffsets = new long[MAX_PLAYHEAD_OFFSET_COUNT];
  volume = 1.0f;
}
 

import com.google.android.exoplayer.drm.DrmSessionManager; //导入依赖的package包/类
/**
 * @param source                        The upstream source from which the renderer obtains samples.
 * @param drmSessionManager             For use with encrypted content. May be null if support for encrypted
 *                                      content is not required.
 * @param playClearSamplesWithoutKeys   Encrypted media may contain clear (un-encrypted) regions.
 *                                      For example a media file may start with a short clear region so as to allow playback to
 *                                      begin in parallel with key acquisision. This parameter specifies whether the renderer is
 *                                      permitted to play clear regions of encrypted media files before {@code drmSessionManager}
 *                                      has obtained the keys necessary to decrypt encrypted regions of the media.
 * @param minBufferMultiplicationFactor When instantiating an underlying {@link AudioTrack},
 *                                      the size of the track's is calculated as this value multiplied by the minimum buffer size
 *                                      obtained from {@link AudioTrack#getMinBufferSize(int, int, int)}. The multiplication
 *                                      factor must be greater than or equal to 1.
 * @param eventHandler                  A handler to use when delivering events to {@code eventListener}. May be
 *                                      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 MediaCodecSpeedControllableAudioTrackRenderer(SampleSource source, DrmSessionManager drmSessionManager,
                                                     boolean playClearSamplesWithoutKeys, float minBufferMultiplicationFactor,
                                                     Handler eventHandler, EventListener eventListener) {
    super(source, drmSessionManager, playClearSamplesWithoutKeys, eventHandler, eventListener);
    Assertions.checkState(minBufferMultiplicationFactor >= 1);
    this.minBufferMultiplicationFactor = minBufferMultiplicationFactor;
    this.eventListener = eventListener;
    audioTrackReleasingConditionVariable = new ConditionVariable(true);
    if (Util.SDK_INT >= 19) {
        audioTimestampCompat = new AudioTimestampCompatV19();
    } else {
        audioTimestampCompat = new NoopAudioTimestampCompat();
    }
    if (Util.SDK_INT >= 18) {
        try {
            audioTrackGetLatencyMethod = AudioTrack.class.getMethod("getLatency", (Class<?>[]) null);
        } catch (NoSuchMethodException e) {
            // There's no guarantee this method exists. Do nothing.
        }
    }
    playheadOffsets = new long[MAX_PLAYHEAD_OFFSET_COUNT];
    volume = 1.0f;
}
 

import com.google.android.exoplayer.drm.DrmSessionManager; //导入依赖的package包/类
private boolean shouldWaitForKeys(boolean sampleEncrypted) throws ExoPlaybackException {
  if (!openedDrmSession) {
    return false;
  }
  int drmManagerState = drmSessionManager.getState();
  if (drmManagerState == DrmSessionManager.STATE_ERROR) {
    throw new ExoPlaybackException(drmSessionManager.getError());
  }
  if (drmManagerState != DrmSessionManager.STATE_OPENED_WITH_KEYS &&
      (sampleEncrypted || !playClearSamplesWithoutKeys)) {
    return true;
  }
  return false;
}
 

import com.google.android.exoplayer.drm.DrmSessionManager; //导入依赖的package包/类
public static Pair<DrmSessionManager, Boolean> getDrmSessionManagerData(DemoPlayer player,
    MediaDrmCallback drmCallback) throws UnsupportedSchemeException {
  StreamingDrmSessionManager streamingDrmSessionManager = new StreamingDrmSessionManager(
      DemoUtil.WIDEVINE_UUID, player.getPlaybackLooper(), drmCallback, null,
      player.getMainHandler(), player);
  return Pair.create((DrmSessionManager) streamingDrmSessionManager,
      getWidevineSecurityLevel(streamingDrmSessionManager) == SECURITY_LEVEL_1);
}
 

import com.google.android.exoplayer.drm.DrmSessionManager; //导入依赖的package包/类
/**
 * @param source The upstream source from which the renderer obtains samples.
 * @param drmSessionManager For use with encrypted media. May be null if support for encrypted
 *     media is not required.
 * @param playClearSamplesWithoutKeys Encrypted media may contain clear (un-encrypted) regions.
 *     For example a media file may start with a short clear region so as to allow playback to
 *     begin in parallel with key acquisision. This parameter specifies whether the renderer is
 *     permitted to play clear regions of encrypted media files before {@code drmSessionManager}
 *     has obtained the keys necessary to decrypt encrypted regions of the media.
 * @param eventHandler A handler to use when delivering events to {@code eventListener}. May be
 *     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 MediaCodecTrackRenderer(SampleSource source, DrmSessionManager drmSessionManager,
    boolean playClearSamplesWithoutKeys, Handler eventHandler, EventListener eventListener) {
  Assertions.checkState(Util.SDK_INT >= 16);
  this.source = source;
  this.drmSessionManager = drmSessionManager;
  this.playClearSamplesWithoutKeys = playClearSamplesWithoutKeys;
  this.eventHandler = eventHandler;
  this.eventListener = eventListener;
  codecCounters = new CodecCounters();
  sampleHolder = new SampleHolder(SampleHolder.BUFFER_REPLACEMENT_MODE_DISABLED);
  formatHolder = new MediaFormatHolder();
  decodeOnlyPresentationTimestamps = new ArrayList<Long>();
  outputBufferInfo = new MediaCodec.BufferInfo();
}
 

import com.google.android.exoplayer.drm.DrmSessionManager; //导入依赖的package包/类
/**
 * @param source The upstream source from which the renderer obtains samples.
 * @param drmSessionManager For use with encrypted media. May be null if support for encrypted
 *     media is not required.
 * @param playClearSamplesWithoutKeys Encrypted media may contain clear (un-encrypted) regions.
 *     For example a media file may start with a short clear region so as to allow playback to
 *     begin in parallel with key acquisision. This parameter specifies whether the renderer is
 *     permitted to play clear regions of encrypted media files before {@code drmSessionManager}
 *     has obtained the keys necessary to decrypt encrypted regions of the media.
 * @param eventHandler A handler to use when delivering events to {@code eventListener}. May be
 *     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 MediaCodecTrackRenderer(SampleSource source, DrmSessionManager drmSessionManager,
    boolean playClearSamplesWithoutKeys, Handler eventHandler, EventListener eventListener) {
  Assertions.checkState(Util.SDK_INT >= 16);
  this.source = source;
  this.drmSessionManager = drmSessionManager;
  this.playClearSamplesWithoutKeys = playClearSamplesWithoutKeys;
  this.eventHandler = eventHandler;
  this.eventListener = eventListener;
  codecCounters = new CodecCounters();
  sampleHolder = new SampleHolder(false);
  formatHolder = new MediaFormatHolder();
  decodeOnlyPresentationTimestamps = new HashSet<Long>();
  outputBufferInfo = new MediaCodec.BufferInfo();
}
 

import com.google.android.exoplayer.drm.DrmSessionManager; //导入依赖的package包/类
/**
 * @param source The upstream source from which the renderer obtains samples.
 * @param drmSessionManager For use with encrypted media. May be null if support for encrypted
 *     media is not required.
 * @param playClearSamplesWithoutKeys Encrypted media may contain clear (un-encrypted) regions.
 *     For example a media file may start with a short clear region so as to allow playback to
 *     begin in parallel with key acquisision. This parameter specifies whether the renderer is
 *     permitted to play clear regions of encrypted media files before {@code drmSessionManager}
 *     has obtained the keys necessary to decrypt encrypted regions of the media.
 * @param eventHandler A handler to use when delivering events to {@code eventListener}. May be
 *     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 MediaCodecTrackRenderer(SampleSource source, DrmSessionManager drmSessionManager,
                               boolean playClearSamplesWithoutKeys, Handler eventHandler, EventListener eventListener) {
  Assertions.checkState(Util.SDK_INT >= 16);
  this.source = source;
  this.drmSessionManager = drmSessionManager;
  this.playClearSamplesWithoutKeys = playClearSamplesWithoutKeys;
  this.eventHandler = eventHandler;
  this.eventListener = eventListener;
  codecCounters = new CodecCounters();
  sampleHolder = new SampleHolder(false);
  formatHolder = new FormatHolder();
  decodeOnlyPresentationTimestamps = new HashSet<Long>();
  outputBufferInfo = new MediaCodec.BufferInfo();
}
 

import com.google.android.exoplayer.drm.DrmSessionManager; //导入依赖的package包/类
public static DrmSessionManager getSessionManager(Context context) {
    try {
        return new OfflineDrmSessionManager(getStorage(context));
    } catch (UnsupportedDrmException e) {
        throw new WidevineNotSupportedException(e);
    }
}
 

import com.google.android.exoplayer.drm.DrmSessionManager; //导入依赖的package包/类
@Override
public void onSingleManifest(SmoothStreamingManifest manifest) {
  if (canceled) {
    return;
  }

  Handler mainHandler = player.getMainHandler();
  LoadControl loadControl = new DefaultLoadControl(new DefaultAllocator(BUFFER_SEGMENT_SIZE));
  DefaultBandwidthMeter bandwidthMeter = new DefaultBandwidthMeter(mainHandler, player);

  // Check drm support if necessary.
  DrmSessionManager<FrameworkMediaCrypto> drmSessionManager = null;
  if (manifest.protectionElement != null) {
    if (Util.SDK_INT < 18) {
      player.onRenderersError(
          new UnsupportedDrmException(UnsupportedDrmException.REASON_UNSUPPORTED_SCHEME));
      return;
    }
    try {
      drmSessionManager = StreamingDrmSessionManager.newFrameworkInstance(
          manifest.protectionElement.uuid, player.getPlaybackLooper(), drmCallback, null,
          player.getMainHandler(), player);
    } catch (UnsupportedDrmException e) {
      player.onRenderersError(e);
      return;
    }
  }

  // Build the video renderer.
  DataSource videoDataSource = new DefaultUriDataSource(context, bandwidthMeter, userAgent);
  ChunkSource videoChunkSource = new SmoothStreamingChunkSource(manifestFetcher,
      DefaultSmoothStreamingTrackSelector.newVideoInstance(context, true, false),
      videoDataSource, new AdaptiveEvaluator(bandwidthMeter), LIVE_EDGE_LATENCY_MS);
  ChunkSampleSource videoSampleSource = new ChunkSampleSource(videoChunkSource, loadControl,
      VIDEO_BUFFER_SEGMENTS * BUFFER_SEGMENT_SIZE, mainHandler, player,
      DemoPlayer.TYPE_VIDEO);
  TrackRenderer videoRenderer = new MediaCodecVideoTrackRenderer(context, videoSampleSource,
      MediaCodecSelector.DEFAULT, MediaCodec.VIDEO_SCALING_MODE_SCALE_TO_FIT, 5000,
      drmSessionManager, true, mainHandler, player, 50);

  // Build the audio renderer.
  DataSource audioDataSource = new DefaultUriDataSource(context, bandwidthMeter, userAgent);
  ChunkSource audioChunkSource = new SmoothStreamingChunkSource(manifestFetcher,
      DefaultSmoothStreamingTrackSelector.newAudioInstance(),
      audioDataSource, null, LIVE_EDGE_LATENCY_MS);
  ChunkSampleSource audioSampleSource = new ChunkSampleSource(audioChunkSource, loadControl,
      AUDIO_BUFFER_SEGMENTS * BUFFER_SEGMENT_SIZE, mainHandler, player,
      DemoPlayer.TYPE_AUDIO);
  TrackRenderer audioRenderer = new MediaCodecAudioTrackRenderer(audioSampleSource,
      MediaCodecSelector.DEFAULT, drmSessionManager, true, mainHandler, player,
      AudioCapabilities.getCapabilities(context), AudioManager.STREAM_MUSIC);

  // Build the text renderer.
  DataSource textDataSource = new DefaultUriDataSource(context, bandwidthMeter, userAgent);
  ChunkSource textChunkSource = new SmoothStreamingChunkSource(manifestFetcher,
      DefaultSmoothStreamingTrackSelector.newTextInstance(),
      textDataSource, null, LIVE_EDGE_LATENCY_MS);
  ChunkSampleSource textSampleSource = new ChunkSampleSource(textChunkSource, loadControl,
      TEXT_BUFFER_SEGMENTS * BUFFER_SEGMENT_SIZE, mainHandler, player,
      DemoPlayer.TYPE_TEXT);
  TrackRenderer textRenderer = new TextTrackRenderer(textSampleSource, player,
      mainHandler.getLooper());

  // Invoke the callback.
  TrackRenderer[] renderers = new TrackRenderer[DemoPlayer.RENDERER_COUNT];
  renderers[DemoPlayer.TYPE_VIDEO] = videoRenderer;
  renderers[DemoPlayer.TYPE_AUDIO] = audioRenderer;
  renderers[DemoPlayer.TYPE_TEXT] = textRenderer;
  player.onRenderers(renderers, bandwidthMeter);
}
 

import com.google.android.exoplayer.drm.DrmSessionManager; //导入依赖的package包/类
/**
 * @param context A context.
 * @param source The upstream source from which the renderer obtains samples.
 * @param videoScalingMode The scaling mode to pass to
 *     {@link MediaCodec#setVideoScalingMode(int)}.
 * @param allowedJoiningTimeMs The maximum duration in milliseconds for which this video renderer
 *     can attempt to seamlessly join an ongoing playback.
 * @param drmSessionManager For use with encrypted content. May be null if support for encrypted
 *     content is not required.
 * @param playClearSamplesWithoutKeys Encrypted media may contain clear (un-encrypted) regions.
 *     For example a media file may start with a short clear region so as to allow playback to
 *     begin in parallel with key acquisision. This parameter specifies whether the renderer is
 *     permitted to play clear regions of encrypted media files before {@code drmSessionManager}
 *     has obtained the keys necessary to decrypt encrypted regions of the media.
 * @param eventHandler A handler to use when delivering events to {@code eventListener}. May be
 *     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 EventListener#onDroppedFrames(int, long)}.
 */
public TextureVideoTrackRenderer(Context context, SampleSource source, int videoScalingMode,
                                    long allowedJoiningTimeMs, DrmSessionManager drmSessionManager,
                                    boolean playClearSamplesWithoutKeys, Handler eventHandler, EventListener eventListener,
                                    int maxDroppedFrameCountToNotify) {
    super(source, drmSessionManager, playClearSamplesWithoutKeys, eventHandler, eventListener);
    this.frameReleaseTimeHelper = new VideoFrameReleaseTimeHelper(context);
    this.videoScalingMode = videoScalingMode;
    this.allowedJoiningTimeUs = allowedJoiningTimeMs * 1000;
    this.eventListener = eventListener;
    this.maxDroppedFrameCountToNotify = maxDroppedFrameCountToNotify;
    joiningDeadlineUs = -1;
    currentWidth = -1;
    currentHeight = -1;
    currentPixelWidthHeightRatio = -1;
    pendingPixelWidthHeightRatio = -1;
    lastReportedWidth = -1;
    lastReportedHeight = -1;
    lastReportedPixelWidthHeightRatio = -1;
}
 

import com.google.android.exoplayer.drm.DrmSessionManager; //导入依赖的package包/类
/**
 * @param source The upstream source from which the renderer obtains samples.
 * @param drmSessionManager For use with encrypted content. May be null if support for encrypted
 *          content is not required.
 * @param playClearSamplesWithoutKeys Encrypted media may contain clear (un-encrypted) regions.
 *          For example a media file may start with a short clear region so as to allow playback
 *          to
 *          begin in parallel with key acquisision. This parameter specifies whether the renderer
 *          is
 *          permitted to play clear regions of encrypted media files before
 *          {@code drmSessionManager}
 *          has obtained the keys necessary to decrypt encrypted regions of the media.
 * @param videoScalingMode The scaling mode to pass to
 *          {@link MediaCodec#setVideoScalingMode(int)}.
 * @param allowedJoiningTimeMs The maximum duration in milliseconds for which this video renderer
 *          can attempt to seamlessly join an ongoing playback.
 * @param frameReleaseTimeHelper An optional helper to make fine-grained adjustments to frame
 *          release times. May be null.
 * @param eventHandler A handler to use when delivering events to {@code eventListener}. May be
 *          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 EventListener#onDroppedFrames(int, long)}.
 */
public MediaCodecVideoTrackRenderer(SampleSource source, DrmSessionManager drmSessionManager,
    boolean playClearSamplesWithoutKeys, int videoScalingMode, long allowedJoiningTimeMs,
    FrameReleaseTimeHelper frameReleaseTimeHelper, Handler eventHandler,
    EventListener eventListener, int maxDroppedFrameCountToNotify) {
  super(source, drmSessionManager, playClearSamplesWithoutKeys, eventHandler, eventListener);
  this.videoScalingMode = videoScalingMode;
  this.allowedJoiningTimeUs = allowedJoiningTimeMs * 1000;
  this.frameReleaseTimeHelper = frameReleaseTimeHelper;
  this.eventListener = eventListener;
  this.maxDroppedFrameCountToNotify = maxDroppedFrameCountToNotify;
  joiningDeadlineUs = -1;
  currentWidth = -1;
  currentHeight = -1;
  currentPixelWidthHeightRatio = -1;
  pendingPixelWidthHeightRatio = -1;
  lastReportedWidth = -1;
  lastReportedHeight = -1;
  lastReportedPixelWidthHeightRatio = -1;
}
 

import com.google.android.exoplayer.drm.DrmSessionManager; //导入依赖的package包/类
/**
 * @param context A context.
 * @param source The upstream source from which the renderer obtains samples.
 * @param mediaCodecSelector A decoder selector.
 * @param videoScalingMode The scaling mode to pass to
 *     {@link MediaCodec#setVideoScalingMode(int)}.
 * @param allowedJoiningTimeMs The maximum duration in milliseconds for which this video renderer
 *     can attempt to seamlessly join an ongoing playback.
 * @param drmSessionManager For use with encrypted content. May be null if support for encrypted
 *     content is not required.
 * @param playClearSamplesWithoutKeys Encrypted media may contain clear (un-encrypted) regions.
 *     For example a media file may start with a short clear region so as to allow playback to
 *     begin in parallel with key acquisision. This parameter specifies whether the renderer is
 *     permitted to play clear regions of encrypted media files before {@code drmSessionManager}
 *     has obtained the keys necessary to decrypt encrypted regions of the media.
 * @param eventHandler A handler to use when delivering events to {@code eventListener}. May be
 *     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 EventListener#onDroppedFrames(int, long)}.
 */
public MediaCodecVideoTrackRenderer(Context context, SampleSource source,
    MediaCodecSelector mediaCodecSelector, int videoScalingMode, long allowedJoiningTimeMs,
    DrmSessionManager drmSessionManager, boolean playClearSamplesWithoutKeys,
    Handler eventHandler, EventListener eventListener, int maxDroppedFrameCountToNotify) {
  super(source, mediaCodecSelector, drmSessionManager, playClearSamplesWithoutKeys, eventHandler,
      eventListener);
  this.frameReleaseTimeHelper = new VideoFrameReleaseTimeHelper(context);
  this.videoScalingMode = videoScalingMode;
  this.allowedJoiningTimeUs = allowedJoiningTimeMs * 1000;
  this.eventListener = eventListener;
  this.maxDroppedFrameCountToNotify = maxDroppedFrameCountToNotify;
  joiningDeadlineUs = -1;
  currentWidth = -1;
  currentHeight = -1;
  currentPixelWidthHeightRatio = -1;
  pendingPixelWidthHeightRatio = -1;
  lastReportedWidth = -1;
  lastReportedHeight = -1;
  lastReportedPixelWidthHeightRatio = -1;
}
 

import com.google.android.exoplayer.drm.DrmSessionManager; //导入依赖的package包/类
public EMMediaCodecAudioTrackRenderer(SampleSource source, MediaCodecSelector mediaCodecSelector, DrmSessionManager drmSessionManager, boolean playClearSamplesWithoutKeys) {
    super(source, mediaCodecSelector, drmSessionManager, playClearSamplesWithoutKeys);
}
 

import com.google.android.exoplayer.drm.DrmSessionManager; //导入依赖的package包/类
protected void buildTrackRenderers(DrmSessionManager drmSessionManager, boolean filterHdContent) {
    Handler mainHandler = player.getMainHandler();
    LoadControl loadControl = new DefaultLoadControl(new DefaultAllocator(BUFFER_SEGMENT_SIZE));
    DefaultBandwidthMeter bandwidthMeter = new DefaultBandwidthMeter(mainHandler, player);


    //Create the Sample Source to be used by the Video Renderer
    DataSource dataSourceVideo = createDataSource(okHttpClient, bandwidthMeter, userAgent);
    ChunkSource chunkSourceVideo = new DashChunkSource(manifestFetcher, DefaultDashTrackSelector.newVideoInstance(context, true, filterHdContent), dataSourceVideo,
            new AdaptiveEvaluator(bandwidthMeter), LIVE_EDGE_LATENCY_MS, elapsedRealtimeOffset, mainHandler, player, EMExoPlayer.RENDER_VIDEO);
    ChunkSampleSource sampleSourceVideo = new ChunkSampleSource(chunkSourceVideo, loadControl, BUFFER_SEGMENTS_VIDEO * BUFFER_SEGMENT_SIZE,
            mainHandler, player, EMExoPlayer.RENDER_VIDEO);


    //Create the Sample Source to be used by the Audio Renderer
    DataSource dataSourceAudio = createDataSource(okHttpClient, bandwidthMeter, userAgent);
    ChunkSource chunkSourceAudio = new DashChunkSource(manifestFetcher, DefaultDashTrackSelector.newAudioInstance(), dataSourceAudio,
            null, LIVE_EDGE_LATENCY_MS, elapsedRealtimeOffset, mainHandler, player, EMExoPlayer.RENDER_AUDIO);
    ChunkSampleSource sampleSourceAudio = new ChunkSampleSource(chunkSourceAudio,