Java MediaCodecTrackRenderer类代码示例

import com.google.android.exoplayer.MediaCodecTrackRenderer; //导入依赖的package包/类
/**
   * Invoked with the results from a {@link RendererBuilder}.
   *
   * @param renderers      Renderers indexed by {@link DemoPlayer} TYPE_* constants. An individual
   *                       element may be null if there do not exist tracks of the corresponding
   *                       type.
   * @param bandwidthMeter Provides an estimate of the currently available bandwidth. May be
   *                       null.
   */
/* package */ void onRenderers(TrackRenderer[] renderers, BandwidthMeter bandwidthMeter) {
      for (int i = 0; i < RENDERER_COUNT; i++) {
          if (renderers[i] == null) {
              // Convert a null renderer to a dummy renderer.
              renderers[i] = new DummyTrackRenderer();
          }
      }
      // Complete preparation.
      this.videoRenderer = renderers[TYPE_VIDEO];
      this.audioRenderer = renderers[TYPE_AUDIO];
      this.codecCounters = videoRenderer instanceof MediaCodecTrackRenderer
              ? ((MediaCodecTrackRenderer) videoRenderer).codecCounters
              : renderers[TYPE_AUDIO] instanceof MediaCodecTrackRenderer
              ? ((MediaCodecTrackRenderer) renderers[TYPE_AUDIO]).codecCounters : null;
      this.bandwidthMeter = bandwidthMeter;
      pushSurface(false);
      player.prepare(renderers);
      rendererBuildingState = RENDERER_BUILDING_STATE_BUILT;
  }
 

import com.google.android.exoplayer.MediaCodecTrackRenderer; //导入依赖的package包/类
/**
   * Invoked with the results from a {@link RendererBuilder}.
   *
   * @param renderers      Renderers indexed by {@link VideoPlayer} TYPE_* constants. An
   *                       individual element may be null if there do not exist tracks of the
   *                       corresponding type.
   * @param bandwidthMeter Provides an estimate of the currently available bandwidth. May be
   *                       null.
   */
/* package */ void onRenderers(TrackRenderer[] renderers, BandwidthMeter bandwidthMeter) {
      for (int i = 0; i < RENDERER_COUNT; i++) {
          if (renderers[i] == null) {
              // Convert a null renderer to a dummy renderer.
              renderers[i] = new DummyTrackRenderer();
          }
      }
      // Complete preparation.
      this.videoRenderer = renderers[TYPE_VIDEO];
      this.codecCounters = videoRenderer instanceof MediaCodecTrackRenderer
              ? ((MediaCodecTrackRenderer) videoRenderer).codecCounters
              : renderers[TYPE_AUDIO] instanceof MediaCodecTrackRenderer
              ? ((MediaCodecTrackRenderer) renderers[TYPE_AUDIO]).codecCounters : null;
      this.bandwidthMeter = bandwidthMeter;
      pushSurface(false);
      player.prepare(renderers);
      rendererBuildingState = RENDERER_BUILDING_STATE_BUILT;
  }
 

import com.google.android.exoplayer.MediaCodecTrackRenderer; //导入依赖的package包/类
/**
 * Invoked with the results from a {link RendererBuilder}.
 *
 * @param renderers Renderers indexed by {link DemoPlayer} TYPE_* constants. An individual
 *     element may be null if there do not exist tracks of the corresponding type.
 * @param bandwidthMeter Provides an estimate of the currently available bandwidth. May be null.
 */
/* package */ void onRenderers(TrackRenderer[] renderers, BandwidthMeter bandwidthMeter) {
  for (int i = 0; i < RENDERER_COUNT; i++) {
    if (renderers[i] == null) {
      // Convert a null renderer to a dummy renderer.
      renderers[i] = new DummyTrackRenderer();
    }
  }
  // Complete preparation.
  this.videoRenderer = renderers[TYPE_VIDEO];
  this.codecCounters = videoRenderer instanceof MediaCodecTrackRenderer
      ? ((MediaCodecTrackRenderer) videoRenderer).codecCounters
      : renderers[TYPE_AUDIO] instanceof MediaCodecTrackRenderer
      ? ((MediaCodecTrackRenderer) renderers[TYPE_AUDIO]).codecCounters : null;
  this.bandwidthMeter = bandwidthMeter;
  pushSurface(false);
  player.prepare(renderers);
  rendererBuildingState = RENDERER_BUILDING_STATE_BUILT;
}
 

import com.google.android.exoplayer.MediaCodecTrackRenderer; //导入依赖的package包/类
/**
   * Invoked with the results from a {@link RendererBuilder}.
   *
   * @param renderers      Renderers indexed by {@link ExoPlayerHelper} TYPE_* constants. An individual
   *                       element may be null if there do not exist tracks of the corresponding type.
   * @param bandwidthMeter Provides an estimate of the currently available bandwidth. May be null.
   */
/* package */ void onRenderers(TrackRenderer[] renderers, BandwidthMeter bandwidthMeter) {
      for (int i = 0; i < RENDERER_COUNT; i++) {
          if (renderers[i] == null) {
              // Convert a null renderer to a dummy renderer.
              renderers[i] = new DummyTrackRenderer();
          }
      }
      // Complete preparation.
      this.videoRenderer = renderers[TYPE_VIDEO];
      this.codecCounters = videoRenderer instanceof MediaCodecTrackRenderer
              ? ((MediaCodecTrackRenderer) videoRenderer).codecCounters
              : renderers[TYPE_AUDIO] instanceof MediaCodecTrackRenderer
              ? ((MediaCodecTrackRenderer) renderers[TYPE_AUDIO]).codecCounters : null;
      this.bandwidthMeter = bandwidthMeter;
      pushSurface(false);
      player.prepare(renderers);
      rendererBuildingState = RENDERER_BUILDING_STATE_BUILT;
  }
 

import com.google.android.exoplayer.MediaCodecTrackRenderer; //导入依赖的package包/类
/**
 * Invoked with the results from a {@link RendererBuilder}.
 *
 * @param renderers Renderers indexed by {@link DemoPlayer} TYPE_* constants. An individual
 *     element may be null if there do not exist tracks of the corresponding type.
 * @param bandwidthMeter Provides an estimate of the currently available bandwidth. May be null.
 */
/* package */ void onRenderers(TrackRenderer[] renderers, BandwidthMeter bandwidthMeter) {
  for (int i = 0; i < RENDERER_COUNT; i++) {
    if (renderers[i] == null) {
      // Convert a null renderer to a dummy renderer.
      renderers[i] = new DummyTrackRenderer();
    }
  }
  // Complete preparation.
  this.videoRenderer = renderers[TYPE_VIDEO];
  this.codecCounters = videoRenderer instanceof MediaCodecTrackRenderer
      ? ((MediaCodecTrackRenderer) videoRenderer).codecCounters
      : renderers[TYPE_AUDIO] instanceof MediaCodecTrackRenderer
      ? ((MediaCodecTrackRenderer) renderers[TYPE_AUDIO]).codecCounters : null;
  this.bandwidthMeter = bandwidthMeter;
  pushSurface(false);
  player.prepare(renderers);
  rendererBuildingState = RENDERER_BUILDING_STATE_BUILT;
}
 

import com.google.android.exoplayer.MediaCodecTrackRenderer; //导入依赖的package包/类
/**
   * Invoked with the results from a {@link RendererBuilder}.
   *
   * @param renderers Renderers indexed by {@link Player} TYPE_* constants. An individual
   *     element may be null if there do not exist tracks of the corresponding type.
   * @param bandwidthMeter Provides an estimate of the currently available bandwidth. May be null.
   */
/* package */ void onRenderers(TrackRenderer[] renderers, BandwidthMeter bandwidthMeter) {
      for (int i = 0; i < RENDERER_COUNT; i++) {
          if (renderers[i] == null) {
              // Convert a null renderer to a dummy renderer.
              renderers[i] = new DummyTrackRenderer();
          }
      }
      // Complete preparation.
      this.videoRenderer = renderers[TYPE_VIDEO];
      this.codecCounters = videoRenderer instanceof MediaCodecTrackRenderer
              ? ((MediaCodecTrackRenderer) videoRenderer).codecCounters
              : renderers[TYPE_AUDIO] instanceof MediaCodecTrackRenderer
              ? ((MediaCodecTrackRenderer) renderers[TYPE_AUDIO]).codecCounters : null;
      this.bandwidthMeter = bandwidthMeter;
      pushSurface(false);
      player.prepare(renderers);
      rendererBuildingState = RENDERER_BUILDING_STATE_BUILT;
  }
 

import com.google.android.exoplayer.MediaCodecTrackRenderer; //导入依赖的package包/类
/**
 * Invoked with the results from a {@link RendererBuilder}.
 *
 * @param renderers      Renderers indexed by {@link DemoPlayer} TYPE_* constants. An individual
 *                       element may be null if there do not exist tracks of the corresponding
 *                       type.
 * @param bandwidthMeter Provides an estimate of the currently available bandwidth. May be null.
 */
/* package */ void onRenderers(TrackRenderer[] renderers, BandwidthMeter bandwidthMeter) {
  for (int i = 0; i < RENDERER_COUNT; i++) {
    if (renderers[i] == null) {
      // Convert a null renderer to a dummy renderer.
      renderers[i] = new DummyTrackRenderer();
    }
  }
  // Complete preparation.
  this.videoRenderer = renderers[TYPE_VIDEO];
  this.codecCounters = videoRenderer instanceof MediaCodecTrackRenderer
      ? ((MediaCodecTrackRenderer) videoRenderer).codecCounters
      : renderers[TYPE_AUDIO] instanceof MediaCodecTrackRenderer
      ? ((MediaCodecTrackRenderer) renderers[TYPE_AUDIO]).codecCounters : null;
  this.bandwidthMeter = bandwidthMeter;
  pushSurface(false);
  player.prepare(renderers);
  rendererBuildingState = RENDERER_BUILDING_STATE_BUILT;
}
 

import com.google.android.exoplayer.MediaCodecTrackRenderer; //导入依赖的package包/类
/**
 * Invoked with the results from a {@link RendererBuilder}.
 *
 * @param renderers      Renderers indexed by {@link ExoPlayerWrapper} TYPE_* constants. An individual
 *                       element may be null if there do not exist tracks of the corresponding type.
 * @param bandwidthMeter Provides an estimate of the currently available bandwidth. May be null.
 */
protected void onRenderers(TrackRenderer[] renderers, BandwidthMeter bandwidthMeter) {
    for (int i = 0; i < RENDERER_COUNT; i++) {
        if (renderers[i] == null) {
            // Convert a null renderer to a dummy renderer.
            renderers[i] = new DummyTrackRenderer();
        }
    }
    // Complete preparation.
    this.videoRenderer = renderers[TYPE_VIDEO];
    this.audioRenderer = renderers[TYPE_AUDIO];
    this.codecCounters = videoRenderer instanceof MediaCodecTrackRenderer
            ? ((MediaCodecTrackRenderer) videoRenderer).codecCounters
            : renderers[TYPE_AUDIO] instanceof MediaCodecTrackRenderer
            ? ((MediaCodecTrackRenderer) renderers[TYPE_AUDIO]).codecCounters : null;
    this.bandwidthMeter = bandwidthMeter;
    pushSurface(false);
    player.prepare(renderers);
    rendererBuildingState = RENDERER_BUILDING_STATE_BUILT;
}
 

import com.google.android.exoplayer.MediaCodecTrackRenderer; //导入依赖的package包/类
/**
 * Invoked with the results from a {@link RendererBuilder}.
 *
 * @param renderers Renderers indexed by {@link FlyingPlayer} TYPE_* constants. An individual
 *     element may be null if there do not exist tracks of the corresponding type.
 * @param bandwidthMeter Provides an estimate of the currently available bandwidth. May be null.
 */
/* package */ void onRenderers(TrackRenderer[] renderers, BandwidthMeter bandwidthMeter) {
  for (int i = 0; i < RENDERER_COUNT; i++) {
    if (renderers[i] == null) {
      // Convert a null renderer to a dummy renderer.
      renderers[i] = new DummyTrackRenderer();
    }
  }
  // Complete preparation.
  this.videoRenderer = renderers[TYPE_VIDEO];
  this.codecCounters = videoRenderer instanceof MediaCodecTrackRenderer
          ? ((MediaCodecTrackRenderer) videoRenderer).codecCounters
          : renderers[TYPE_AUDIO] instanceof MediaCodecTrackRenderer
          ? ((MediaCodecTrackRenderer) renderers[TYPE_AUDIO]).codecCounters : null;
  this.bandwidthMeter = bandwidthMeter;
  pushSurface(false);
  player.prepare(renderers);
  rendererBuildingState = RENDERER_BUILDING_STATE_BUILT;
}
 

import com.google.android.exoplayer.MediaCodecTrackRenderer; //导入依赖的package包/类
/**
   * Invoked with the results from a {@link RendererBuilder}.
   *
   * @param renderers Renderers indexed by {@link DemoPlayer} TYPE_* constants. An individual
   *     element may be null if there do not exist tracks of the corresponding type.
   * @param bandwidthMeter Provides an estimate of the currently available bandwidth. May be null.
   */
/* package */ void onRenderers(TrackRenderer[] renderers, BandwidthMeter bandwidthMeter) {
      for (int i = 0; i < RENDERER_COUNT; i++) {
          if (renderers[i] == null) {
              // Convert a null renderer to a dummy renderer.
              renderers[i] = new DummyTrackRenderer();
          }
      }
      // Complete preparation.
      this.videoRenderer = renderers[TYPE_VIDEO];
      this.audioRenderer = renderers[TYPE_AUDIO];
      this.codecCounters = videoRenderer instanceof MediaCodecTrackRenderer
              ? ((MediaCodecTrackRenderer) videoRenderer).codecCounters
              : renderers[TYPE_AUDIO] instanceof MediaCodecTrackRenderer
              ? ((MediaCodecTrackRenderer) renderers[TYPE_AUDIO]).codecCounters : null;
      this.bandwidthMeter = bandwidthMeter;
      pushSurface(false);
      player.prepare(renderers);
      rendererBuildingState = RENDERER_BUILDING_STATE_BUILT;
  }
 

import com.google.android.exoplayer.MediaCodecTrackRenderer; //导入依赖的package包/类
/**
 * Invoked with the results from a {@link RendererBuilder}.
 *
 * @param renderers Renderers indexed by {@link ExoplayerWrapper} TYPE_* constants. An
 *                  individual element may be null if there do not exist tracks of the
 *                  corresponding type.
 * @param bandwidthMeter Provides an estimate of the currently available bandwidth. May be null.
 */
public void onRenderers(TrackRenderer[] renderers,  BandwidthMeter bandwidthMeter) {
  // Normalize the results.
  if (trackNames == null) {
    trackNames = new String[RENDERER_COUNT][];
  }

  for (int i = 0; i < RENDERER_COUNT; i++) {
    if (renderers[i] == null) {
      // Convert a null renderer to a dummy renderer.
      renderers[i] = new DummyTrackRenderer();
    }
  }

  // Complete preparation.
  this.videoRenderer = renderers[TYPE_VIDEO];
  this.codecCounters = videoRenderer instanceof MediaCodecTrackRenderer
          ? ((MediaCodecTrackRenderer) videoRenderer).codecCounters
          : renderers[TYPE_AUDIO] instanceof MediaCodecTrackRenderer
          ? ((MediaCodecTrackRenderer) renderers[TYPE_AUDIO]).codecCounters : null;
  rendererBuildingState = RENDERER_BUILDING_STATE_BUILT;
  this.bandwidthMeter = bandwidthMeter;
  maybeReportPlayerState();
  pushSurfaceAndVideoTrack(false);
  player.prepare(renderers);
}
 

import com.google.android.exoplayer.MediaCodecTrackRenderer; //导入依赖的package包/类
/**
   * Invoked with the results from a {@link RendererBuilder}.
   *
   * @param trackNames        The names of the available tracks, indexed by {@link VideoPlayer} TYPE_*
   *                          constants. May be null if the track names are unknown. An individual element may be null
   *                          if the track names are unknown for the corresponding type.
   * @param multiTrackSources Sources capable of switching between multiple available tracks,
   *                          indexed by {@link VideoPlayer} TYPE_* constants. May be null if there are no types with
   *                          multiple tracks. An individual element may be null if it does not have multiple tracks.
   * @param renderers         Renderers indexed by {@link VideoPlayer} TYPE_* constants. An individual
   *                          element may be null if there do not exist tracks of the corresponding type.
   * @param bandwidthMeter    Provides an estimate of the currently available bandwidth. May be null.
   */
/* package */ void onRenderers(String[][] trackNames,
                               MultiTrackChunkSource[] multiTrackSources, TrackRenderer[] renderers,
                               BandwidthMeter bandwidthMeter) {
      // Normalize the results.
      if (trackNames == null) {
          trackNames = new String[RENDERER_COUNT][];
      }
      if (multiTrackSources == null) {
          multiTrackSources = new MultiTrackChunkSource[RENDERER_COUNT];
      }
      for (int rendererIndex = 0; rendererIndex < RENDERER_COUNT; rendererIndex++) {
          if (renderers[rendererIndex] == null) {
              // Convert a null renderer to a dummy renderer.
              renderers[rendererIndex] = new DummyTrackRenderer();
          }
          if (trackNames[rendererIndex] == null) {
              // Convert a null trackNames to an array of suitable length.
              int trackCount = multiTrackSources[rendererIndex] != null
                      ? multiTrackSources[rendererIndex].getTrackCount() : 1;
              trackNames[rendererIndex] = new String[trackCount];
          }
      }
      // Complete preparation.
      this.trackNames = trackNames;
      this.videoRenderer = renderers[TYPE_VIDEO];
      this.codecCounters = videoRenderer instanceof MediaCodecTrackRenderer
              ? ((MediaCodecTrackRenderer) videoRenderer).codecCounters
              : renderers[TYPE_AUDIO] instanceof MediaCodecTrackRenderer
              ? ((MediaCodecTrackRenderer) renderers[TYPE_AUDIO]).codecCounters : null;
      this.multiTrackSources = multiTrackSources;
      this.bandwidthMeter = bandwidthMeter;
      pushSurface(false);
      pushTrackSelection(TYPE_VIDEO, true);
      pushTrackSelection(TYPE_AUDIO, true);
      pushTrackSelection(TYPE_TEXT, true);
      player.prepare(renderers);
      rendererBuildingState = RENDERER_BUILDING_STATE_BUILT;
  }
 

import com.google.android.exoplayer.MediaCodecTrackRenderer; //导入依赖的package包/类
@Override
public void onDecoderInitializationError(
        MediaCodecTrackRenderer.DecoderInitializationException e) {
    for(Callback callback : mCallbacks) {
        callback.onPlayerError(new ExoPlaybackException(e));
    }
}
 

import com.google.android.exoplayer.MediaCodecTrackRenderer; //导入依赖的package包/类
/** RendererBuilderCallback */
@Override
public void onRenderers(TrackRenderer[] renderers, BandwidthMeter bandwidthMeter) {
    player.invokeOnRenderersBuilt(renderers, bandwidthMeter);
    this.bandwidthMeter = bandwidthMeter;
    this.codecCounters = renderers[Player.TYPE_VIDEO] instanceof MediaCodecTrackRenderer
            ? ((MediaCodecTrackRenderer) renderers[Player.TYPE_VIDEO]).codecCounters
            : renderers[Player.TYPE_AUDIO] instanceof MediaCodecTrackRenderer
                    ? ((MediaCodecTrackRenderer) renderers[Player.TYPE_AUDIO]).codecCounters
                    : null;
}
 

import com.google.android.exoplayer.MediaCodecTrackRenderer; //导入依赖的package包/类
/** MediaCodecVideoTrackRenderer.EventListener */
@Override
public void onDecoderInitializationError(
        MediaCodecTrackRenderer.DecoderInitializationException e) {
    if (internalErrorListener != null) {
        internalErrorListener.onDecoderInitializationError(e);
    }
}