Java Code Examples for com.google.android.exoplayer2.mediacodec.MediaCodecInfo#isSeamlessAdaptationSupported()

@Override
protected @KeepCodecResult int canKeepCodec(
    MediaCodec codec, MediaCodecInfo codecInfo, Format oldFormat, Format newFormat) {
  // TODO: We currently rely on recreating the codec when encoder delay or padding is non-zero.
  // Re-creating the codec is necessary to guarantee that onOutputFormatChanged is called, which
  // is where encoder delay and padding are propagated to the sink. We should find a better way to
  // propagate these values, and then allow the codec to be re-used in cases where this would
  // otherwise be possible.
  if (getCodecMaxInputSize(codecInfo, newFormat) > codecMaxInputSize
      || oldFormat.encoderDelay != 0
      || oldFormat.encoderPadding != 0
      || newFormat.encoderDelay != 0
      || newFormat.encoderPadding != 0) {
    return KEEP_CODEC_RESULT_NO;
  } else if (codecInfo.isSeamlessAdaptationSupported(
      oldFormat, newFormat, /* isNewFormatComplete= */ true)) {
    return KEEP_CODEC_RESULT_YES_WITHOUT_RECONFIGURATION;
  } else if (canKeepCodecWithFlush(oldFormat, newFormat)) {
    return KEEP_CODEC_RESULT_YES_WITH_FLUSH;
  } else {
    return KEEP_CODEC_RESULT_NO;
  }
}
 

/**
 * Returns a maximum input size suitable for configuring a codec for {@code format} in a way that
 * will allow possible adaptation to other compatible formats in {@code streamFormats}.
 *
 * @param codecInfo A {@link MediaCodecInfo} describing the decoder.
 * @param format The {@link Format} for which the codec is being configured.
 * @param streamFormats The possible stream formats.
 * @return A suitable maximum input size.
 */
protected int getCodecMaxInputSize(
    MediaCodecInfo codecInfo, Format format, Format[] streamFormats) {
  int maxInputSize = getCodecMaxInputSize(codecInfo, format);
  if (streamFormats.length == 1) {
    // The single entry in streamFormats must correspond to the format for which the codec is
    // being configured.
    return maxInputSize;
  }
  for (Format streamFormat : streamFormats) {
    if (codecInfo.isSeamlessAdaptationSupported(
        format, streamFormat, /* isNewFormatComplete= */ false)) {
      maxInputSize = Math.max(maxInputSize, getCodecMaxInputSize(codecInfo, streamFormat));
    }
  }
  return maxInputSize;
}
 

@Override
protected @KeepCodecResult int canKeepCodec(
    MediaCodec codec, MediaCodecInfo codecInfo, Format oldFormat, Format newFormat) {
  // TODO: We currently rely on recreating the codec when encoder delay or padding is non-zero.
  // Re-creating the codec is necessary to guarantee that onOutputFormatChanged is called, which
  // is where encoder delay and padding are propagated to the sink. We should find a better way to
  // propagate these values, and then allow the codec to be re-used in cases where this would
  // otherwise be possible.
  if (getCodecMaxInputSize(codecInfo, newFormat) > codecMaxInputSize
      || oldFormat.encoderDelay != 0
      || oldFormat.encoderPadding != 0
      || newFormat.encoderDelay != 0
      || newFormat.encoderPadding != 0) {
    return KEEP_CODEC_RESULT_NO;
  } else if (codecInfo.isSeamlessAdaptationSupported(
      oldFormat, newFormat, /* isNewFormatComplete= */ true)) {
    return KEEP_CODEC_RESULT_YES_WITHOUT_RECONFIGURATION;
  } else if (areCodecConfigurationCompatible(oldFormat, newFormat)) {
    return KEEP_CODEC_RESULT_YES_WITH_FLUSH;
  } else {
    return KEEP_CODEC_RESULT_NO;
  }
}
 

/**
 * Returns a maximum input size suitable for configuring a codec for {@code format} in a way that
 * will allow possible adaptation to other compatible formats in {@code streamFormats}.
 *
 * @param codecInfo A {@link MediaCodecInfo} describing the decoder.
 * @param format The format for which the codec is being configured.
 * @param streamFormats The possible stream formats.
 * @return A suitable maximum input size.
 */
protected int getCodecMaxInputSize(
    MediaCodecInfo codecInfo, Format format, Format[] streamFormats) {
  int maxInputSize = getCodecMaxInputSize(codecInfo, format);
  if (streamFormats.length == 1) {
    // The single entry in streamFormats must correspond to the format for which the codec is
    // being configured.
    return maxInputSize;
  }
  for (Format streamFormat : streamFormats) {
    if (codecInfo.isSeamlessAdaptationSupported(
        format, streamFormat, /* isNewFormatComplete= */ false)) {
      maxInputSize = Math.max(maxInputSize, getCodecMaxInputSize(codecInfo, streamFormat));
    }
  }
  return maxInputSize;
}
 

@Override
protected @KeepCodecResult int canKeepCodec(
    MediaCodec codec, MediaCodecInfo codecInfo, Format oldFormat, Format newFormat) {
  if (codecInfo.isSeamlessAdaptationSupported(
          oldFormat, newFormat, /* isNewFormatComplete= */ true)
      && newFormat.width <= codecMaxValues.width
      && newFormat.height <= codecMaxValues.height
      && getMaxInputSize(codecInfo, newFormat) <= codecMaxValues.inputSize) {
    return oldFormat.initializationDataEquals(newFormat)
        ? KEEP_CODEC_RESULT_YES_WITHOUT_RECONFIGURATION
        : KEEP_CODEC_RESULT_YES_WITH_RECONFIGURATION;
  }
  return KEEP_CODEC_RESULT_NO;
}
 

@Override
protected @KeepCodecResult int canKeepCodec(
    MediaCodec codec, MediaCodecInfo codecInfo, Format oldFormat, Format newFormat) {
  // TODO: We currently rely on recreating the codec when encoder delay or padding is non-zero.
  // Re-creating the codec is necessary to guarantee that onOutputFormatChanged is called, which
  // is where encoder delay and padding are propagated to the sink. We should find a better way to
  // propagate these values, and then allow the codec to be re-used in cases where this would
  // otherwise be possible.
  if (getCodecMaxInputSize(codecInfo, newFormat) > codecMaxInputSize
      || oldFormat.encoderDelay != 0
      || oldFormat.encoderPadding != 0
      || newFormat.encoderDelay != 0
      || newFormat.encoderPadding != 0) {
    return KEEP_CODEC_RESULT_NO;
  } else if (codecInfo.isSeamlessAdaptationSupported(
      oldFormat, newFormat, /* isNewFormatComplete= */ true)) {
    return KEEP_CODEC_RESULT_YES_WITHOUT_RECONFIGURATION;
  } else if (areCodecConfigurationCompatible(oldFormat, newFormat)) {
    return KEEP_CODEC_RESULT_YES_WITH_FLUSH;
  } else {
    return KEEP_CODEC_RESULT_NO;
  }
}
 

/**
 * Returns a maximum input size suitable for configuring a codec for {@code format} in a way that
 * will allow possible adaptation to other compatible formats in {@code streamFormats}.
 *
 * @param codecInfo A {@link MediaCodecInfo} describing the decoder.
 * @param format The format for which the codec is being configured.
 * @param streamFormats The possible stream formats.
 * @return A suitable maximum input size.
 */
protected int getCodecMaxInputSize(
    MediaCodecInfo codecInfo, Format format, Format[] streamFormats) {
  int maxInputSize = getCodecMaxInputSize(codecInfo, format);
  if (streamFormats.length == 1) {
    // The single entry in streamFormats must correspond to the format for which the codec is
    // being configured.
    return maxInputSize;
  }
  for (Format streamFormat : streamFormats) {
    if (codecInfo.isSeamlessAdaptationSupported(
        format, streamFormat, /* isNewFormatComplete= */ false)) {
      maxInputSize = Math.max(maxInputSize, getCodecMaxInputSize(codecInfo, streamFormat));
    }
  }
  return maxInputSize;
}
 

@Override
protected @KeepCodecResult int canKeepCodec(
    MediaCodec codec, MediaCodecInfo codecInfo, Format oldFormat, Format newFormat) {
  if (codecInfo.isSeamlessAdaptationSupported(
          oldFormat, newFormat, /* isNewFormatComplete= */ true)
      && newFormat.width <= codecMaxValues.width
      && newFormat.height <= codecMaxValues.height
      && getMaxInputSize(codecInfo, newFormat) <= codecMaxValues.inputSize) {
    return oldFormat.initializationDataEquals(newFormat)
        ? KEEP_CODEC_RESULT_YES_WITHOUT_RECONFIGURATION
        : KEEP_CODEC_RESULT_YES_WITH_RECONFIGURATION;
  }
  return KEEP_CODEC_RESULT_NO;
}
 

@Override
protected @KeepCodecResult int canKeepCodec(
    MediaCodec codec, MediaCodecInfo codecInfo, Format oldFormat, Format newFormat) {
  if (codecInfo.isSeamlessAdaptationSupported(
          oldFormat, newFormat, /* isNewFormatComplete= */ true)
      && newFormat.width <= codecMaxValues.width
      && newFormat.height <= codecMaxValues.height
      && getMaxInputSize(codecInfo, newFormat) <= codecMaxValues.inputSize) {
    return oldFormat.initializationDataEquals(newFormat)
        ? KEEP_CODEC_RESULT_YES_WITHOUT_RECONFIGURATION
        : KEEP_CODEC_RESULT_YES_WITH_RECONFIGURATION;
  }
  return KEEP_CODEC_RESULT_NO;
}
 

@Override
@Capabilities
protected int supportsFormat(
    MediaCodecSelector mediaCodecSelector,
    @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager,
    Format format)
    throws DecoderQueryException {
  String mimeType = format.sampleMimeType;
  if (!MimeTypes.isAudio(mimeType)) {
    return RendererCapabilities.create(FORMAT_UNSUPPORTED_TYPE);
  }
  @TunnelingSupport
  int tunnelingSupport = Util.SDK_INT >= 21 ? TUNNELING_SUPPORTED : TUNNELING_NOT_SUPPORTED;
  boolean supportsFormatDrm =
      format.drmInitData == null
          || FrameworkMediaCrypto.class.equals(format.exoMediaCryptoType)
          || (format.exoMediaCryptoType == null
              && supportsFormatDrm(drmSessionManager, format.drmInitData));
  if (supportsFormatDrm
      && allowPassthrough(format.channelCount, mimeType)
      && mediaCodecSelector.getPassthroughDecoderInfo() != null) {
    return RendererCapabilities.create(FORMAT_HANDLED, ADAPTIVE_NOT_SEAMLESS, tunnelingSupport);
  }
  if ((MimeTypes.AUDIO_RAW.equals(mimeType)
          && !audioSink.supportsOutput(format.channelCount, format.pcmEncoding))
      || !audioSink.supportsOutput(format.channelCount, C.ENCODING_PCM_16BIT)) {
    // Assume the decoder outputs 16-bit PCM, unless the input is raw.
    return RendererCapabilities.create(FORMAT_UNSUPPORTED_SUBTYPE);
  }
  List<MediaCodecInfo> decoderInfos =
      getDecoderInfos(mediaCodecSelector, format, /* requiresSecureDecoder= */ false);
  if (decoderInfos.isEmpty()) {
    return RendererCapabilities.create(FORMAT_UNSUPPORTED_SUBTYPE);
  }
  if (!supportsFormatDrm) {
    return RendererCapabilities.create(FORMAT_UNSUPPORTED_DRM);
  }
  // Check capabilities for the first decoder in the list, which takes priority.
  MediaCodecInfo decoderInfo = decoderInfos.get(0);
  boolean isFormatSupported = decoderInfo.isFormatSupported(format);
  @AdaptiveSupport
  int adaptiveSupport =
      isFormatSupported && decoderInfo.isSeamlessAdaptationSupported(format)
          ? ADAPTIVE_SEAMLESS
          : ADAPTIVE_NOT_SEAMLESS;
  @FormatSupport
  int formatSupport = isFormatSupported ? FORMAT_HANDLED : FORMAT_EXCEEDS_CAPABILITIES;
  return RendererCapabilities.create(formatSupport, adaptiveSupport, tunnelingSupport);
}
 

@Override
@Capabilities
protected int supportsFormat(
    MediaCodecSelector mediaCodecSelector,
    @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager,
    Format format)
    throws DecoderQueryException {
  String mimeType = format.sampleMimeType;
  if (!MimeTypes.isVideo(mimeType)) {
    return RendererCapabilities.create(FORMAT_UNSUPPORTED_TYPE);
  }
  @Nullable DrmInitData drmInitData = format.drmInitData;
  // Assume encrypted content requires secure decoders.
  boolean requiresSecureDecryption = drmInitData != null;
  List<MediaCodecInfo> decoderInfos =
      getDecoderInfos(
          mediaCodecSelector,
          format,
          requiresSecureDecryption,
          /* requiresTunnelingDecoder= */ false);
  if (requiresSecureDecryption && decoderInfos.isEmpty()) {
    // No secure decoders are available. Fall back to non-secure decoders.
    decoderInfos =
        getDecoderInfos(
            mediaCodecSelector,
            format,
            /* requiresSecureDecoder= */ false,
            /* requiresTunnelingDecoder= */ false);
  }
  if (decoderInfos.isEmpty()) {
    return RendererCapabilities.create(FORMAT_UNSUPPORTED_SUBTYPE);
  }
  boolean supportsFormatDrm =
      drmInitData == null
          || FrameworkMediaCrypto.class.equals(format.exoMediaCryptoType)
          || (format.exoMediaCryptoType == null
              && supportsFormatDrm(drmSessionManager, drmInitData));
  if (!supportsFormatDrm) {
    return RendererCapabilities.create(FORMAT_UNSUPPORTED_DRM);
  }
  // Check capabilities for the first decoder in the list, which takes priority.
  MediaCodecInfo decoderInfo = decoderInfos.get(0);
  boolean isFormatSupported = decoderInfo.isFormatSupported(format);
  @AdaptiveSupport
  int adaptiveSupport =
      decoderInfo.isSeamlessAdaptationSupported(format)
          ? ADAPTIVE_SEAMLESS
          : ADAPTIVE_NOT_SEAMLESS;
  @TunnelingSupport int tunnelingSupport = TUNNELING_NOT_SUPPORTED;
  if (isFormatSupported) {
    List<MediaCodecInfo> tunnelingDecoderInfos =
        getDecoderInfos(
            mediaCodecSelector,
            format,
            requiresSecureDecryption,
            /* requiresTunnelingDecoder= */ true);
    if (!tunnelingDecoderInfos.isEmpty()) {
      MediaCodecInfo tunnelingDecoderInfo = tunnelingDecoderInfos.get(0);
      if (tunnelingDecoderInfo.isFormatSupported(format)
          && tunnelingDecoderInfo.isSeamlessAdaptationSupported(format)) {
        tunnelingSupport = TUNNELING_SUPPORTED;
      }
    }
  }
  @FormatSupport
  int formatSupport = isFormatSupported ? FORMAT_HANDLED : FORMAT_EXCEEDS_CAPABILITIES;
  return RendererCapabilities.create(formatSupport, adaptiveSupport, tunnelingSupport);
}
 

/**
 * Returns {@link CodecMaxValues} suitable for configuring a codec for {@code format} in a way
 * that will allow possible adaptation to other compatible formats in {@code streamFormats}.
 *
 * @param codecInfo Information about the {@link MediaCodec} being configured.
 * @param format The {@link Format} for which the codec is being configured.
 * @param streamFormats The possible stream formats.
 * @return Suitable {@link CodecMaxValues}.
 */
protected CodecMaxValues getCodecMaxValues(
    MediaCodecInfo codecInfo, Format format, Format[] streamFormats) {
  int maxWidth = format.width;
  int maxHeight = format.height;
  int maxInputSize = getMaxInputSize(codecInfo, format);
  if (streamFormats.length == 1) {
    // The single entry in streamFormats must correspond to the format for which the codec is
    // being configured.
    if (maxInputSize != Format.NO_VALUE) {
      int codecMaxInputSize =
          getCodecMaxInputSize(codecInfo, format.sampleMimeType, format.width, format.height);
      if (codecMaxInputSize != Format.NO_VALUE) {
        // Scale up the initial video decoder maximum input size so playlist item transitions with
        // small increases in maximum sample size don't require reinitialization. This only makes
        // a difference if the exact maximum sample sizes are known from the container.
        int scaledMaxInputSize =
            (int) (maxInputSize * INITIAL_FORMAT_MAX_INPUT_SIZE_SCALE_FACTOR);
        // Avoid exceeding the maximum expected for the codec.
        maxInputSize = Math.min(scaledMaxInputSize, codecMaxInputSize);
      }
    }
    return new CodecMaxValues(maxWidth, maxHeight, maxInputSize);
  }
  boolean haveUnknownDimensions = false;
  for (Format streamFormat : streamFormats) {
    if (codecInfo.isSeamlessAdaptationSupported(
        format, streamFormat, /* isNewFormatComplete= */ false)) {
      haveUnknownDimensions |=
          (streamFormat.width == Format.NO_VALUE || streamFormat.height == Format.NO_VALUE);
      maxWidth = Math.max(maxWidth, streamFormat.width);
      maxHeight = Math.max(maxHeight, streamFormat.height);
      maxInputSize = Math.max(maxInputSize, getMaxInputSize(codecInfo, streamFormat));
    }
  }
  if (haveUnknownDimensions) {
    Log.w(TAG, "Resolutions unknown. Codec max resolution: " + maxWidth + "x" + maxHeight);
    Point codecMaxSize = getCodecMaxSize(codecInfo, format);
    if (codecMaxSize != null) {
      maxWidth = Math.max(maxWidth, codecMaxSize.x);
      maxHeight = Math.max(maxHeight, codecMaxSize.y);
      maxInputSize =
          Math.max(
              maxInputSize,
              getCodecMaxInputSize(codecInfo, format.sampleMimeType, maxWidth, maxHeight));
      Log.w(TAG, "Codec max resolution adjusted to: " + maxWidth + "x" + maxHeight);
    }
  }
  return new CodecMaxValues(maxWidth, maxHeight, maxInputSize);
}
 

@Override
protected int supportsFormat(MediaCodecSelector mediaCodecSelector,
    DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, Format format)
    throws DecoderQueryException {
  String mimeType = format.sampleMimeType;
  if (!MimeTypes.isVideo(mimeType)) {
    return FORMAT_UNSUPPORTED_TYPE;
  }
  boolean requiresSecureDecryption = false;
  DrmInitData drmInitData = format.drmInitData;
  if (drmInitData != null) {
    for (int i = 0; i < drmInitData.schemeDataCount; i++) {
      requiresSecureDecryption |= drmInitData.get(i).requiresSecureDecryption;
    }
  }
  List<MediaCodecInfo> decoderInfos =
      getDecoderInfos(mediaCodecSelector, format, requiresSecureDecryption);
  if (decoderInfos.isEmpty()) {
    return requiresSecureDecryption
            && !mediaCodecSelector
                .getDecoderInfos(
                    format.sampleMimeType,
                    /* requiresSecureDecoder= */ false,
                    /* requiresTunnelingDecoder= */ false)
                .isEmpty()
        ? FORMAT_UNSUPPORTED_DRM
        : FORMAT_UNSUPPORTED_SUBTYPE;
  }
  if (!supportsFormatDrm(drmSessionManager, drmInitData)) {
    return FORMAT_UNSUPPORTED_DRM;
  }
  // Check capabilities for the first decoder in the list, which takes priority.
  MediaCodecInfo decoderInfo = decoderInfos.get(0);
  boolean isFormatSupported = decoderInfo.isFormatSupported(format);
  int adaptiveSupport =
      decoderInfo.isSeamlessAdaptationSupported(format)
          ? ADAPTIVE_SEAMLESS
          : ADAPTIVE_NOT_SEAMLESS;
  int tunnelingSupport = TUNNELING_NOT_SUPPORTED;
  if (isFormatSupported) {
    List<MediaCodecInfo> tunnelingDecoderInfos =
        mediaCodecSelector.getDecoderInfos(
            format.sampleMimeType,
            requiresSecureDecryption,
            /* requiresTunnelingDecoder= */ true);
    if (!tunnelingDecoderInfos.isEmpty()) {
      MediaCodecInfo tunnelingDecoderInfo = tunnelingDecoderInfos.get(0);
      if (tunnelingDecoderInfo.isFormatSupported(format)
          && tunnelingDecoderInfo.isSeamlessAdaptationSupported(format)) {
        tunnelingSupport = TUNNELING_SUPPORTED;
      }
    }
  }
  int formatSupport = isFormatSupported ? FORMAT_HANDLED : FORMAT_EXCEEDS_CAPABILITIES;
  return adaptiveSupport | tunnelingSupport | formatSupport;
}
 

/**
 * Returns {@link CodecMaxValues} suitable for configuring a codec for {@code format} in a way
 * that will allow possible adaptation to other compatible formats in {@code streamFormats}.
 *
 * @param codecInfo Information about the {@link MediaCodec} being configured.
 * @param format The format for which the codec is being configured.
 * @param streamFormats The possible stream formats.
 * @return Suitable {@link CodecMaxValues}.
 */
protected CodecMaxValues getCodecMaxValues(
    MediaCodecInfo codecInfo, Format format, Format[] streamFormats) {
  int maxWidth = format.width;
  int maxHeight = format.height;
  int maxInputSize = getMaxInputSize(codecInfo, format);
  if (streamFormats.length == 1) {
    // The single entry in streamFormats must correspond to the format for which the codec is
    // being configured.
    if (maxInputSize != Format.NO_VALUE) {
      int codecMaxInputSize =
          getCodecMaxInputSize(codecInfo, format.sampleMimeType, format.width, format.height);
      if (codecMaxInputSize != Format.NO_VALUE) {
        // Scale up the initial video decoder maximum input size so playlist item transitions with
        // small increases in maximum sample size don't require reinitialization. This only makes
        // a difference if the exact maximum sample sizes are known from the container.
        int scaledMaxInputSize =
            (int) (maxInputSize * INITIAL_FORMAT_MAX_INPUT_SIZE_SCALE_FACTOR);
        // Avoid exceeding the maximum expected for the codec.
        maxInputSize = Math.min(scaledMaxInputSize, codecMaxInputSize);
      }
    }
    return new CodecMaxValues(maxWidth, maxHeight, maxInputSize);
  }
  boolean haveUnknownDimensions = false;
  for (Format streamFormat : streamFormats) {
    if (codecInfo.isSeamlessAdaptationSupported(
        format, streamFormat, /* isNewFormatComplete= */ false)) {
      haveUnknownDimensions |=
          (streamFormat.width == Format.NO_VALUE || streamFormat.height == Format.NO_VALUE);
      maxWidth = Math.max(maxWidth, streamFormat.width);
      maxHeight = Math.max(maxHeight, streamFormat.height);
      maxInputSize = Math.max(maxInputSize, getMaxInputSize(codecInfo, streamFormat));
    }
  }
  if (haveUnknownDimensions) {
    Log.w(TAG, "Resolutions unknown. Codec max resolution: " + maxWidth + "x" + maxHeight);
    Point codecMaxSize = getCodecMaxSize(codecInfo, format);
    if (codecMaxSize != null) {
      maxWidth = Math.max(maxWidth, codecMaxSize.x);
      maxHeight = Math.max(maxHeight, codecMaxSize.y);
      maxInputSize =
          Math.max(
              maxInputSize,
              getCodecMaxInputSize(codecInfo, format.sampleMimeType, maxWidth, maxHeight));
      Log.w(TAG, "Codec max resolution adjusted to: " + maxWidth + "x" + maxHeight);
    }
  }
  return new CodecMaxValues(maxWidth, maxHeight, maxInputSize);
}
 

@Override
protected int supportsFormat(MediaCodecSelector mediaCodecSelector,
    DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, Format format)
    throws DecoderQueryException {
  String mimeType = format.sampleMimeType;
  if (!MimeTypes.isVideo(mimeType)) {
    return FORMAT_UNSUPPORTED_TYPE;
  }
  boolean requiresSecureDecryption = false;
  DrmInitData drmInitData = format.drmInitData;
  if (drmInitData != null) {
    for (int i = 0; i < drmInitData.schemeDataCount; i++) {
      requiresSecureDecryption |= drmInitData.get(i).requiresSecureDecryption;
    }
  }
  List<MediaCodecInfo> decoderInfos =
      getDecoderInfos(mediaCodecSelector, format, requiresSecureDecryption);
  if (decoderInfos.isEmpty()) {
    return requiresSecureDecryption
            && !mediaCodecSelector
                .getDecoderInfos(
                    format.sampleMimeType,
                    /* requiresSecureDecoder= */ false,
                    /* requiresTunnelingDecoder= */ false)
                .isEmpty()
        ? FORMAT_UNSUPPORTED_DRM
        : FORMAT_UNSUPPORTED_SUBTYPE;
  }
  if (!supportsFormatDrm(drmSessionManager, drmInitData)) {
    return FORMAT_UNSUPPORTED_DRM;
  }
  // Check capabilities for the first decoder in the list, which takes priority.
  MediaCodecInfo decoderInfo = decoderInfos.get(0);
  boolean isFormatSupported = decoderInfo.isFormatSupported(format);
  int adaptiveSupport =
      decoderInfo.isSeamlessAdaptationSupported(format)
          ? ADAPTIVE_SEAMLESS
          : ADAPTIVE_NOT_SEAMLESS;
  int tunnelingSupport = TUNNELING_NOT_SUPPORTED;
  if (isFormatSupported) {
    List<MediaCodecInfo> tunnelingDecoderInfos =
        mediaCodecSelector.getDecoderInfos(
            format.sampleMimeType,
            requiresSecureDecryption,
            /* requiresTunnelingDecoder= */ true);
    if (!tunnelingDecoderInfos.isEmpty()) {
      MediaCodecInfo tunnelingDecoderInfo = tunnelingDecoderInfos.get(0);
      if (tunnelingDecoderInfo.isFormatSupported(format)
          && tunnelingDecoderInfo.isSeamlessAdaptationSupported(format)) {
        tunnelingSupport = TUNNELING_SUPPORTED;
      }
    }
  }
  int formatSupport = isFormatSupported ? FORMAT_HANDLED : FORMAT_EXCEEDS_CAPABILITIES;
  return adaptiveSupport | tunnelingSupport | formatSupport;
}
 

/**
 * Returns {@link CodecMaxValues} suitable for configuring a codec for {@code format} in a way
 * that will allow possible adaptation to other compatible formats in {@code streamFormats}.
 *
 * @param codecInfo Information about the {@link MediaCodec} being configured.
 * @param format The format for which the codec is being configured.
 * @param streamFormats The possible stream formats.
 * @return Suitable {@link CodecMaxValues}.
 */
protected CodecMaxValues getCodecMaxValues(
    MediaCodecInfo codecInfo, Format format, Format[] streamFormats) {
  int maxWidth = format.width;
  int maxHeight = format.height;
  int maxInputSize = getMaxInputSize(codecInfo, format);
  if (streamFormats.length == 1) {
    // The single entry in streamFormats must correspond to the format for which the codec is
    // being configured.
    if (maxInputSize != Format.NO_VALUE) {
      int codecMaxInputSize =
          getCodecMaxInputSize(codecInfo, format.sampleMimeType, format.width, format.height);
      if (codecMaxInputSize != Format.NO_VALUE) {
        // Scale up the initial video decoder maximum input size so playlist item transitions with
        // small increases in maximum sample size don't require reinitialization. This only makes
        // a difference if the exact maximum sample sizes are known from the container.
        int scaledMaxInputSize =
            (int) (maxInputSize * INITIAL_FORMAT_MAX_INPUT_SIZE_SCALE_FACTOR);
        // Avoid exceeding the maximum expected for the codec.
        maxInputSize = Math.min(scaledMaxInputSize, codecMaxInputSize);
      }
    }
    return new CodecMaxValues(maxWidth, maxHeight, maxInputSize);
  }
  boolean haveUnknownDimensions = false;
  for (Format streamFormat : streamFormats) {
    if (codecInfo.isSeamlessAdaptationSupported(
        format, streamFormat, /* isNewFormatComplete= */ false)) {
      haveUnknownDimensions |=
          (streamFormat.width == Format.NO_VALUE || streamFormat.height == Format.NO_VALUE);
      maxWidth = Math.max(maxWidth, streamFormat.width);
      maxHeight = Math.max(maxHeight, streamFormat.height);
      maxInputSize = Math.max(maxInputSize, getMaxInputSize(codecInfo, streamFormat));
    }
  }
  if (haveUnknownDimensions) {
    Log.w(TAG, "Resolutions unknown. Codec max resolution: " + maxWidth + "x" + maxHeight);
    Point codecMaxSize = getCodecMaxSize(codecInfo, format);
    if (codecMaxSize != null) {
      maxWidth = Math.max(maxWidth, codecMaxSize.x);
      maxHeight = Math.max(maxHeight, codecMaxSize.y);
      maxInputSize =
          Math.max(
              maxInputSize,
              getCodecMaxInputSize(codecInfo, format.sampleMimeType, maxWidth, maxHeight));
      Log.w(TAG, "Codec max resolution adjusted to: " + maxWidth + "x" + maxHeight);
    }
  }
  return new CodecMaxValues(maxWidth, maxHeight, maxInputSize);
}