Java 类com.google.android.exoplayer2.mediacodec.MediaCodecUtil.DecoderQueryException 实例源码

@TargetApi(18)
@SuppressWarnings("ResourceType")
private static boolean isL1WidevineAvailable(String videoMimeType) {
  try {
    // Force L3 if secure decoder is not available.
    if (MediaCodecUtil.getDecoderInfo(videoMimeType, true) == null) {
      return false;
    }

    MediaDrm mediaDrm = new MediaDrm(WIDEVINE_UUID);
    String securityProperty = mediaDrm.getPropertyString(SECURITY_LEVEL_PROPERTY);
    mediaDrm.release();
    return WIDEVINE_SECURITY_LEVEL_1.equals(securityProperty);
  } catch (DecoderQueryException | UnsupportedSchemeException e) {
    throw new IllegalStateException(e);
  }
}

@Override
protected int supportsFormat(MediaCodecSelector mediaCodecSelector, Format format)
    throws DecoderQueryException {
  String mimeType = format.sampleMimeType;
  if (!MimeTypes.isAudio(mimeType)) {
    return FORMAT_UNSUPPORTED_TYPE;
  }
  int tunnelingSupport = Util.SDK_INT >= 21 ? TUNNELING_SUPPORTED : TUNNELING_NOT_SUPPORTED;
  if (allowPassthrough(mimeType) && mediaCodecSelector.getPassthroughDecoderInfo() != null) {
    return ADAPTIVE_NOT_SEAMLESS | tunnelingSupport | FORMAT_HANDLED;
  }
  MediaCodecInfo decoderInfo = mediaCodecSelector.getDecoderInfo(mimeType, false);
  if (decoderInfo == null) {
    return FORMAT_UNSUPPORTED_SUBTYPE;
  }
  // Note: We assume support for unknown sampleRate and channelCount.
  boolean decoderCapable = Util.SDK_INT < 21
      || ((format.sampleRate == Format.NO_VALUE
      || decoderInfo.isAudioSampleRateSupportedV21(format.sampleRate))
      && (format.channelCount == Format.NO_VALUE
      ||  decoderInfo.isAudioChannelCountSupportedV21(format.channelCount)));
  int formatSupport = decoderCapable ? FORMAT_HANDLED : FORMAT_EXCEEDS_CAPABILITIES;
  return ADAPTIVE_NOT_SEAMLESS | tunnelingSupport | formatSupport;
}

@Override
protected int supportsFormat(MediaCodecSelector mediaCodecSelector, Format format)
    throws DecoderQueryException {
  String mimeType = format.sampleMimeType;
  if (!MimeTypes.isAudio(mimeType)) {
    return FORMAT_UNSUPPORTED_TYPE;
  }
  int tunnelingSupport = Util.SDK_INT >= 21 ? TUNNELING_SUPPORTED : TUNNELING_NOT_SUPPORTED;
  if (allowPassthrough(mimeType) && mediaCodecSelector.getPassthroughDecoderInfo() != null) {
    return ADAPTIVE_NOT_SEAMLESS | tunnelingSupport | FORMAT_HANDLED;
  }
  MediaCodecInfo decoderInfo = mediaCodecSelector.getDecoderInfo(mimeType, false);
  if (decoderInfo == null) {
    return FORMAT_UNSUPPORTED_SUBTYPE;
  }
  // Note: We assume support for unknown sampleRate and channelCount.
  boolean decoderCapable = Util.SDK_INT < 21
      || ((format.sampleRate == Format.NO_VALUE
      || decoderInfo.isAudioSampleRateSupportedV21(format.sampleRate))
      && (format.channelCount == Format.NO_VALUE
      ||  decoderInfo.isAudioChannelCountSupportedV21(format.channelCount)));
  int formatSupport = decoderCapable ? FORMAT_HANDLED : FORMAT_EXCEEDS_CAPABILITIES;
  return ADAPTIVE_NOT_SEAMLESS | tunnelingSupport | formatSupport;
}

@Override
protected int supportsFormat(MediaCodecSelector mediaCodecSelector, Format format)
    throws DecoderQueryException {
  String mimeType = format.sampleMimeType;
  if (!MimeTypes.isAudio(mimeType)) {
    return FORMAT_UNSUPPORTED_TYPE;
  }
  if (allowPassthrough(mimeType) && mediaCodecSelector.getPassthroughDecoderInfo() != null) {
    return ADAPTIVE_NOT_SEAMLESS | FORMAT_HANDLED;
  }
  MediaCodecInfo decoderInfo = mediaCodecSelector.getDecoderInfo(mimeType, false);
  if (decoderInfo == null) {
    return FORMAT_UNSUPPORTED_SUBTYPE;
  }
  // Note: We assume support for unknown sampleRate and channelCount.
  boolean decoderCapable = Util.SDK_INT < 21
      || ((format.sampleRate == Format.NO_VALUE
      || decoderInfo.isAudioSampleRateSupportedV21(format.sampleRate))
      && (format.channelCount == Format.NO_VALUE
      ||  decoderInfo.isAudioChannelCountSupportedV21(format.channelCount)));
  int formatSupport = decoderCapable ? FORMAT_HANDLED : FORMAT_EXCEEDS_CAPABILITIES;
  return ADAPTIVE_NOT_SEAMLESS | formatSupport;
}

public void testH264AdaptiveWithSeeking() throws DecoderQueryException {
  if (Util.SDK_INT < 16 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_H264)) {
    // Pass.
    return;
  }
  final String streamName = "test_h264_adaptive_with_seeking";
  testRunner
      .setStreamName(streamName)
      .setManifestUrl(DashTestData.H264_MANIFEST)
      .setFullPlaybackNoSeeking(false)
      .setCanIncludeAdditionalVideoFormats(true)
      .setActionSchedule(SEEKING_SCHEDULE)
      .setAudioVideoFormats(DashTestData.AAC_AUDIO_REPRESENTATION_ID,
          DashTestData.H264_CDD_ADAPTIVE)
      .run();
}

public void testH264AdaptiveWithRendererDisabling() throws DecoderQueryException {
  if (Util.SDK_INT < 16 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_H264)) {
    // Pass.
    return;
  }
  final String streamName = "test_h264_adaptive_with_renderer_disabling";
  testRunner
      .setStreamName(streamName)
      .setManifestUrl(DashTestData.H264_MANIFEST)
      .setFullPlaybackNoSeeking(false)
      .setCanIncludeAdditionalVideoFormats(true)
      .setActionSchedule(RENDERER_DISABLING_SCHEDULE)
      .setAudioVideoFormats(DashTestData.AAC_AUDIO_REPRESENTATION_ID,
          DashTestData.H264_CDD_ADAPTIVE)
      .run();
}

public void testWidevineH264AdaptiveWithSeekingV18() throws DecoderQueryException {
  if (Util.SDK_INT < 18 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_H264)) {
    // Pass.
    return;
  }
  testRunner
      .setStreamName("test_widevine_h264_adaptive_with_seeking")
      .setManifestUrl(DashTestData.WIDEVINE_H264_MANIFEST)
      .setWidevineInfo(MimeTypes.VIDEO_H264, true)
      .setFullPlaybackNoSeeking(false)
      .setCanIncludeAdditionalVideoFormats(true)
      .setActionSchedule(SEEKING_SCHEDULE)
      .setAudioVideoFormats(DashTestData.WIDEVINE_AAC_AUDIO_REPRESENTATION_ID,
          DashTestData.WIDEVINE_H264_CDD_ADAPTIVE)
      .run();
}

public void testWidevineH264AdaptiveWithRendererDisablingV18() throws DecoderQueryException {
  if (Util.SDK_INT < 18 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_H264)) {
    // Pass.
    return;
  }
  testRunner
      .setStreamName("test_widevine_h264_adaptive_with_renderer_disabling")
      .setManifestUrl(DashTestData.WIDEVINE_H264_MANIFEST)
      .setWidevineInfo(MimeTypes.VIDEO_H264, true)
      .setFullPlaybackNoSeeking(false)
      .setCanIncludeAdditionalVideoFormats(true)
      .setActionSchedule(RENDERER_DISABLING_SCHEDULE)
      .setAudioVideoFormats(DashTestData.WIDEVINE_AAC_AUDIO_REPRESENTATION_ID,
          DashTestData.WIDEVINE_H264_CDD_ADAPTIVE)
      .run();
}

public void testWidevineH265AdaptiveWithSeekingV24() throws DecoderQueryException {
  if (Util.SDK_INT < 24) {
    // Pass.
    return;
  }
  testRunner
      .setStreamName("test_widevine_h265_adaptive_with_seeking")
      .setManifestUrl(DashTestData.WIDEVINE_H265_MANIFEST)
      .setWidevineInfo(MimeTypes.VIDEO_H265, true)
      .setFullPlaybackNoSeeking(false)
      .setCanIncludeAdditionalVideoFormats(true)
      .setActionSchedule(SEEKING_SCHEDULE)
      .setAudioVideoFormats(DashTestData.WIDEVINE_AAC_AUDIO_REPRESENTATION_ID,
          DashTestData.WIDEVINE_H265_CDD_ADAPTIVE)
      .run();
}

public void testWidevineH265AdaptiveWithRendererDisablingV24() throws DecoderQueryException {
  if (Util.SDK_INT < 24) {
    // Pass.
    return;
  }
  testRunner
      .setStreamName("test_widevine_h265_adaptive_with_renderer_disabling")
      .setManifestUrl(DashTestData.WIDEVINE_H265_MANIFEST)
      .setWidevineInfo(MimeTypes.VIDEO_H265, true)
      .setFullPlaybackNoSeeking(false)
      .setCanIncludeAdditionalVideoFormats(true)
      .setActionSchedule(RENDERER_DISABLING_SCHEDULE)
      .setAudioVideoFormats(DashTestData.WIDEVINE_AAC_AUDIO_REPRESENTATION_ID,
          DashTestData.WIDEVINE_H265_CDD_ADAPTIVE)
      .run();
}

public void testWidevineVp9AdaptiveWithSeekingV24() throws DecoderQueryException {
  if (Util.SDK_INT < 24) {
    // Pass.
    return;
  }
  testRunner
      .setStreamName("test_widevine_vp9_adaptive_with_seeking")
      .setManifestUrl(DashTestData.WIDEVINE_VP9_MANIFEST)
      .setWidevineInfo(MimeTypes.VIDEO_VP9, true)
      .setFullPlaybackNoSeeking(false)
      .setCanIncludeAdditionalVideoFormats(true)
      .setActionSchedule(SEEKING_SCHEDULE)
      .setAudioVideoFormats(DashTestData.WIDEVINE_VP9_AAC_AUDIO_REPRESENTATION_ID,
          DashTestData.WIDEVINE_VP9_CDD_ADAPTIVE)
      .run();
}

public void testWidevineVp9AdaptiveWithRendererDisablingV24() throws DecoderQueryException {
  if (Util.SDK_INT < 24) {
    // Pass.
    return;
  }
  testRunner
      .setStreamName("test_widevine_vp9_adaptive_with_renderer_disabling")
      .setManifestUrl(DashTestData.WIDEVINE_VP9_MANIFEST)
      .setWidevineInfo(MimeTypes.VIDEO_VP9, true)
      .setFullPlaybackNoSeeking(false)
      .setCanIncludeAdditionalVideoFormats(true)
      .setActionSchedule(RENDERER_DISABLING_SCHEDULE)
      .setAudioVideoFormats(DashTestData.WIDEVINE_VP9_AAC_AUDIO_REPRESENTATION_ID,
          DashTestData.WIDEVINE_VP9_CDD_ADAPTIVE)
      .run();
}

@Override
protected void configureCodec(MediaCodecInfo codecInfo, MediaCodec codec, Format format,
    MediaCrypto crypto) throws DecoderQueryException {
  codecMaxValues = getCodecMaxValues(codecInfo, format, streamFormats);
  MediaFormat mediaFormat = getMediaFormat(format, codecMaxValues, deviceNeedsAutoFrcWorkaround,
      tunnelingAudioSessionId);
  if (surface == null) {
    Assertions.checkState(shouldUseDummySurface(codecInfo.secure));
    if (dummySurface == null) {
      dummySurface = DummySurface.newInstanceV17(context, codecInfo.secure);
    }
    surface = dummySurface;
  }
  codec.configure(mediaFormat, surface, crypto, 0);
  if (Util.SDK_INT >= 23 && tunneling) {
    tunnelingOnFrameRenderedListener = new OnFrameRenderedListenerV23(codec);
  }
}

@Override
public void onPlayerError(ExoPlaybackException e) {
    String errorString = null;
    if (e.type == ExoPlaybackException.TYPE_RENDERER) {
        Exception cause = e.getRendererException();
        if (cause instanceof DecoderInitializationException) {
            // Special case for decoder initialization failures.
            DecoderInitializationException decoderInitializationException =
                    (DecoderInitializationException) cause;
            if (decoderInitializationException.decoderName == null) {
                if (decoderInitializationException.getCause() instanceof DecoderQueryException) {
                    errorString = getString(R.string.error_querying_decoders);
                } else if (decoderInitializationException.secureDecoderRequired) {
                    errorString = getString(R.string.error_no_secure_decoder,
                            decoderInitializationException.mimeType);
                } else {
                    errorString = getString(R.string.error_no_decoder,
                            decoderInitializationException.mimeType);
                }
            } else {
                errorString = getString(R.string.error_instantiating_decoder,
                        decoderInitializationException.decoderName);
            }
        }
    }
    if (errorString != null) {
        showToast(errorString);
    }
    playerNeedsSource = true;
    if (isBehindLiveWindow(e)) {
        clearResumePosition();
        initializePlayer();
    } else {
        updateResumePosition();
        updateButtonVisibilities();
        showControls();
    }
}

public void testH264Adaptive() throws DecoderQueryException {
  if (Util.SDK_INT < 16 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_H264)) {
    // Pass.
    return;
  }
  String streamName = "test_h264_adaptive";
  testDashPlayback(getActivity(), streamName, H264_MANIFEST, AAC_AUDIO_REPRESENTATION_ID, false,
      MimeTypes.VIDEO_H264, ALLOW_ADDITIONAL_VIDEO_FORMATS, H264_CDD_ADAPTIVE);
}

public void testH264AdaptiveWithSeeking() throws DecoderQueryException {
  if (Util.SDK_INT < 16 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_H264)) {
    // Pass.
    return;
  }
  String streamName = "test_h264_adaptive_with_seeking";
  testDashPlayback(getActivity(), streamName, SEEKING_SCHEDULE, false, H264_MANIFEST,
      AAC_AUDIO_REPRESENTATION_ID, false, MimeTypes.VIDEO_H264, ALLOW_ADDITIONAL_VIDEO_FORMATS,
      H264_CDD_ADAPTIVE);
}

public void testH264AdaptiveWithRendererDisabling() throws DecoderQueryException {
  if (Util.SDK_INT < 16 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_H264)) {
    // Pass.
    return;
  }
  String streamName = "test_h264_adaptive_with_renderer_disabling";
  testDashPlayback(getActivity(), streamName, RENDERER_DISABLING_SCHEDULE, false, H264_MANIFEST,
      AAC_AUDIO_REPRESENTATION_ID, false, MimeTypes.VIDEO_H264, ALLOW_ADDITIONAL_VIDEO_FORMATS,
      H264_CDD_ADAPTIVE);
}

public void testH265Adaptive() throws DecoderQueryException {
  if (Util.SDK_INT < 24 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_H265)) {
    // Pass.
    return;
  }
  String streamName = "test_h265_adaptive";
  testDashPlayback(getActivity(), streamName, H265_MANIFEST, AAC_AUDIO_REPRESENTATION_ID, false,
      MimeTypes.VIDEO_H265, ALLOW_ADDITIONAL_VIDEO_FORMATS, H265_CDD_ADAPTIVE);
}

public void testH265AdaptiveWithSeeking() throws DecoderQueryException {
  if (Util.SDK_INT < 24 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_H265)) {
    // Pass.
    return;
  }
  String streamName = "test_h265_adaptive_with_seeking";
  testDashPlayback(getActivity(), streamName, SEEKING_SCHEDULE, false, H265_MANIFEST,
      AAC_AUDIO_REPRESENTATION_ID, false, MimeTypes.VIDEO_H265, ALLOW_ADDITIONAL_VIDEO_FORMATS,
      H265_CDD_ADAPTIVE);
}

public void testH265AdaptiveWithRendererDisabling() throws DecoderQueryException {
  if (Util.SDK_INT < 24 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_H265)) {
    // Pass.
    return;
  }
  String streamName = "test_h265_adaptive_with_renderer_disabling";
  testDashPlayback(getActivity(), streamName, RENDERER_DISABLING_SCHEDULE, false,
      H265_MANIFEST, AAC_AUDIO_REPRESENTATION_ID, false, MimeTypes.VIDEO_H265,
      ALLOW_ADDITIONAL_VIDEO_FORMATS, H265_CDD_ADAPTIVE);
}

public void testVp9Adaptive() throws DecoderQueryException {
  if (Util.SDK_INT < 24 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_VP9)) {
    // Pass.
    return;
  }
  String streamName = "test_vp9_adaptive";
  testDashPlayback(getActivity(), streamName, VP9_MANIFEST, VORBIS_AUDIO_REPRESENTATION_ID, false,
      MimeTypes.VIDEO_VP9, ALLOW_ADDITIONAL_VIDEO_FORMATS, VP9_CDD_ADAPTIVE);
}

public void testVp9AdaptiveWithSeeking() throws DecoderQueryException {
  if (Util.SDK_INT < 24 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_VP9)) {
    // Pass.
    return;
  }
  String streamName = "test_vp9_adaptive_with_seeking";
  testDashPlayback(getActivity(), streamName, SEEKING_SCHEDULE, false, VP9_MANIFEST,
      VORBIS_AUDIO_REPRESENTATION_ID, false, MimeTypes.VIDEO_VP9, ALLOW_ADDITIONAL_VIDEO_FORMATS,
      VP9_CDD_ADAPTIVE);
}

public void testVp9AdaptiveWithRendererDisabling() throws DecoderQueryException {
  if (Util.SDK_INT < 24 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_VP9)) {
    // Pass.
    return;
  }
  String streamName = "test_vp9_adaptive_with_renderer_disabling";
  testDashPlayback(getActivity(), streamName, RENDERER_DISABLING_SCHEDULE, false,
      VP9_MANIFEST, VORBIS_AUDIO_REPRESENTATION_ID, false, MimeTypes.VIDEO_VP9,
      ALLOW_ADDITIONAL_VIDEO_FORMATS, VP9_CDD_ADAPTIVE);
}

public void testWidevineH264Fixed() throws DecoderQueryException {
  if (Util.SDK_INT < 18) {
    // Pass.
    return;
  }
  String streamName = "test_widevine_h264_fixed";
  testDashPlayback(getActivity(), streamName, WIDEVINE_H264_MANIFEST_PREFIX,
      WIDEVINE_AAC_AUDIO_REPRESENTATION_ID, true, MimeTypes.VIDEO_H264, false,
      WIDEVINE_H264_CDD_FIXED);
}

public void testWidevineH264Adaptive() throws DecoderQueryException {
  if (Util.SDK_INT < 18 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_H264)) {
    // Pass.
    return;
  }
  String streamName = "test_widevine_h264_adaptive";
  testDashPlayback(getActivity(), streamName, WIDEVINE_H264_MANIFEST_PREFIX,
      WIDEVINE_AAC_AUDIO_REPRESENTATION_ID, true, MimeTypes.VIDEO_H264,
      ALLOW_ADDITIONAL_VIDEO_FORMATS, WIDEVINE_H264_CDD_ADAPTIVE);
}

public void testWidevineH264AdaptiveWithSeeking() throws DecoderQueryException {
  if (Util.SDK_INT < 18 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_H264)) {
    // Pass.
    return;
  }
  String streamName = "test_widevine_h264_adaptive_with_seeking";
  testDashPlayback(getActivity(), streamName, SEEKING_SCHEDULE, false,
      WIDEVINE_H264_MANIFEST_PREFIX, WIDEVINE_AAC_AUDIO_REPRESENTATION_ID, true,
      MimeTypes.VIDEO_H264, ALLOW_ADDITIONAL_VIDEO_FORMATS, WIDEVINE_H264_CDD_ADAPTIVE);
}

public void testWidevineH264AdaptiveWithRendererDisabling() throws DecoderQueryException {
  if (Util.SDK_INT < 18 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_H264)) {
    // Pass.
    return;
  }
  String streamName = "test_widevine_h264_adaptive_with_renderer_disabling";
  testDashPlayback(getActivity(), streamName, RENDERER_DISABLING_SCHEDULE, false,
      WIDEVINE_H264_MANIFEST_PREFIX, WIDEVINE_AAC_AUDIO_REPRESENTATION_ID, true,
      MimeTypes.VIDEO_H264, ALLOW_ADDITIONAL_VIDEO_FORMATS, WIDEVINE_H264_CDD_ADAPTIVE);
}

public void testWidevineH265Fixed() throws DecoderQueryException {
  if (Util.SDK_INT < 23) {
    // Pass.
    return;
  }
  String streamName = "test_widevine_h265_fixed";
  testDashPlayback(getActivity(), streamName, WIDEVINE_H265_MANIFEST_PREFIX,
      WIDEVINE_AAC_AUDIO_REPRESENTATION_ID, true, MimeTypes.VIDEO_H265, false,
      WIDEVINE_H265_CDD_FIXED);
}

public void testWidevineH265Adaptive() throws DecoderQueryException {
  if (Util.SDK_INT < 24 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_H265)) {
    // Pass.
    return;
  }
  String streamName = "test_widevine_h265_adaptive";
  testDashPlayback(getActivity(), streamName, WIDEVINE_H265_MANIFEST_PREFIX,
      WIDEVINE_AAC_AUDIO_REPRESENTATION_ID, true, MimeTypes.VIDEO_H265,
      ALLOW_ADDITIONAL_VIDEO_FORMATS, WIDEVINE_H265_CDD_ADAPTIVE);
}

public void testWidevineH265AdaptiveWithSeeking() throws DecoderQueryException {
  if (Util.SDK_INT < 24 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_H265)) {
    // Pass.
    return;
  }
  String streamName = "test_widevine_h265_adaptive_with_seeking";
  testDashPlayback(getActivity(), streamName, SEEKING_SCHEDULE, false,
      WIDEVINE_H265_MANIFEST_PREFIX, WIDEVINE_AAC_AUDIO_REPRESENTATION_ID, true,
      MimeTypes.VIDEO_H265, ALLOW_ADDITIONAL_VIDEO_FORMATS, WIDEVINE_H265_CDD_ADAPTIVE);
}

public void testWidevineH265AdaptiveWithRendererDisabling() throws DecoderQueryException {
  if (Util.SDK_INT < 24 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_H265)) {
    // Pass.
    return;
  }
  String streamName = "test_widevine_h265_adaptive_with_renderer_disabling";
  testDashPlayback(getActivity(), streamName, RENDERER_DISABLING_SCHEDULE, false,
      WIDEVINE_H265_MANIFEST_PREFIX, WIDEVINE_AAC_AUDIO_REPRESENTATION_ID, true,
      MimeTypes.VIDEO_H265, ALLOW_ADDITIONAL_VIDEO_FORMATS, WIDEVINE_H265_CDD_ADAPTIVE);
}

public void testWidevineVp9Fixed360p() throws DecoderQueryException {
  if (Util.SDK_INT < 23) {
    // Pass.
    return;
  }
  String streamName = "test_widevine_vp9_fixed_360p";
  testDashPlayback(getActivity(), streamName, WIDEVINE_VP9_MANIFEST_PREFIX,
      WIDEVINE_VORBIS_AUDIO_REPRESENTATION_ID, true, MimeTypes.VIDEO_VP9, false,
      WIDEVINE_VP9_CDD_FIXED);
}

public void testWidevineVp9Adaptive() throws DecoderQueryException {
  if (Util.SDK_INT < 24 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_VP9)) {
    // Pass.
    return;
  }
  String streamName = "test_widevine_vp9_adaptive";
  testDashPlayback(getActivity(), streamName, WIDEVINE_VP9_MANIFEST_PREFIX,
      WIDEVINE_VORBIS_AUDIO_REPRESENTATION_ID, true, MimeTypes.VIDEO_VP9,
      ALLOW_ADDITIONAL_VIDEO_FORMATS, WIDEVINE_VP9_CDD_ADAPTIVE);
}

public void testWidevineVp9AdaptiveWithSeeking() throws DecoderQueryException {
  if (Util.SDK_INT < 24 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_VP9)) {
    // Pass.
    return;
  }
  String streamName = "test_widevine_vp9_adaptive_with_seeking";
  testDashPlayback(getActivity(), streamName, SEEKING_SCHEDULE, false,
      WIDEVINE_VP9_MANIFEST_PREFIX, WIDEVINE_VORBIS_AUDIO_REPRESENTATION_ID, true,
      MimeTypes.VIDEO_VP9, ALLOW_ADDITIONAL_VIDEO_FORMATS, WIDEVINE_VP9_CDD_ADAPTIVE);
}

public void testWidevineVp9AdaptiveWithRendererDisabling() throws DecoderQueryException {
  if (Util.SDK_INT < 24 || shouldSkipAdaptiveTest(MimeTypes.VIDEO_VP9)) {
    // Pass.
    return;
  }
  String streamName = "test_widevine_vp9_adaptive_with_renderer_disabling";
  testDashPlayback(getActivity(), streamName, RENDERER_DISABLING_SCHEDULE, false,
      WIDEVINE_VP9_MANIFEST_PREFIX, WIDEVINE_VORBIS_AUDIO_REPRESENTATION_ID, true,
      MimeTypes.VIDEO_VP9, ALLOW_ADDITIONAL_VIDEO_FORMATS, WIDEVINE_VP9_CDD_ADAPTIVE);
}

public void testWidevine23FpsH264Fixed() throws DecoderQueryException {
  if (Util.SDK_INT < 23) {
    // Pass.
    return;
  }
  String streamName = "test_widevine_23fps_h264_fixed";
  testDashPlayback(getActivity(), streamName, WIDEVINE_H264_23_MANIFEST_PREFIX,
      WIDEVINE_AAC_AUDIO_REPRESENTATION_ID, true, MimeTypes.VIDEO_H264, false,
      WIDEVINE_H264_BASELINE_480P_23FPS_VIDEO_REPRESENTATION_ID);
}

public void testWidevine24FpsH264Fixed() throws DecoderQueryException {
  if (Util.SDK_INT < 23) {
    // Pass.
    return;
  }
  String streamName = "test_widevine_24fps_h264_fixed";
  testDashPlayback(getActivity(), streamName, WIDEVINE_H264_24_MANIFEST_PREFIX,
      WIDEVINE_AAC_AUDIO_REPRESENTATION_ID, true, MimeTypes.VIDEO_H264, false,
      WIDEVINE_H264_BASELINE_480P_24FPS_VIDEO_REPRESENTATION_ID);
}

public void testWidevine29FpsH264Fixed() throws DecoderQueryException {
  if (Util.SDK_INT < 23) {
    // Pass.
    return;
  }
  String streamName = "test_widevine_29fps_h264_fixed";
  testDashPlayback(getActivity(), streamName, WIDEVINE_H264_29_MANIFEST_PREFIX,
      WIDEVINE_AAC_AUDIO_REPRESENTATION_ID, true, MimeTypes.VIDEO_H264, false,
      WIDEVINE_H264_BASELINE_480P_29FPS_VIDEO_REPRESENTATION_ID);
}

private static boolean shouldSkipAdaptiveTest(String mimeType) throws DecoderQueryException {
  MediaCodecInfo decoderInfo = MediaCodecUtil.getDecoderInfo(mimeType, false);
  assertNotNull(decoderInfo);
  if (decoderInfo.adaptive) {
    return false;
  }
  assertTrue(Util.SDK_INT < 21);
  return true;
}

@Override
public final int supportsFormat(Format format) throws ExoPlaybackException {
  try {
    return supportsFormat(mediaCodecSelector, format);
  } catch (DecoderQueryException e) {
    throw ExoPlaybackException.createForRenderer(e, getIndex());
  }
}