// Copyright 2022 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "starboard/android/shared/media_capabilities_cache.h"

#include <utility>

#include "starboard/android/shared/jni_utils.h"
#include "starboard/android/shared/media_common.h"
#include "starboard/common/log.h"
#include "starboard/once.h"
#include "starboard/shared/starboard/media/key_system_supportability_cache.h"
#include "starboard/shared/starboard/media/mime_supportability_cache.h"
#include "starboard/thread.h"

namespace starboard {
namespace android {
namespace shared {
namespace {

using ::starboard::shared::starboard::media::KeySystemSupportabilityCache;
using ::starboard::shared::starboard::media::MimeSupportabilityCache;

// https://developer.android.com/reference/android/view/Display.HdrCapabilities.html#HDR_TYPE_HDR10
const jint HDR_TYPE_DOLBY_VISION = 1;
const jint HDR_TYPE_HDR10 = 2;
const jint HDR_TYPE_HLG = 3;
const jint HDR_TYPE_HDR10_PLUS = 4;

const char SECURE_DECODER_SUFFIX[] = ".secure";

// Constants for output types from
// https://developer.android.com/reference/android/media/AudioDeviceInfo.
constexpr int TYPE_AUX_LINE = 19;
constexpr int TYPE_BLE_BROADCAST = 30;
constexpr int TYPE_BLE_HEADSET = 26;
constexpr int TYPE_BLE_SPEAKER = 27;
constexpr int TYPE_BLUETOOTH_A2DP = 8;
constexpr int TYPE_BLUETOOTH_SCO = 7;
constexpr int TYPE_BUILTIN_EARPIECE = 1;
constexpr int TYPE_BUILTIN_MIC = 15;
constexpr int TYPE_BUILTIN_SPEAKER = 2;
constexpr int TYPE_BUILTIN_SPEAKER_SAFE = 24;
constexpr int TYPE_BUS = 21;
constexpr int TYPE_DOCK = 13;
constexpr int TYPE_DOCK_ANALOG = 31;
constexpr int TYPE_FM = 14;
constexpr int TYPE_FM_TUNER = 16;
constexpr int TYPE_HDMI = 9;
constexpr int TYPE_HDMI_ARC = 10;
constexpr int TYPE_HDMI_EARC = 29;
constexpr int TYPE_HEARING_AID = 23;
constexpr int TYPE_IP = 20;
constexpr int TYPE_LINE_ANALOG = 5;
constexpr int TYPE_LINE_DIGITAL = 6;
constexpr int TYPE_REMOTE_SUBMIX = 25;
constexpr int TYPE_TELEPHONY = 18;
constexpr int TYPE_TV_TUNER = 17;
constexpr int TYPE_UNKNOWN = 0;
constexpr int TYPE_USB_ACCESSORY = 12;
constexpr int TYPE_USB_DEVICE = 11;
constexpr int TYPE_USB_HEADSET = 22;
constexpr int TYPE_WIRED_HEADPHONES = 4;
constexpr int TYPE_WIRED_HEADSET = 3;

#if SB_API_VERSION >= 15
SbMediaAudioConnector GetConnectorFromAndroidOutputType(
    int android_output_device_type) {
  switch (android_output_device_type) {
    case TYPE_AUX_LINE:
      return kSbMediaAudioConnectorAnalog;
    case TYPE_BLE_BROADCAST:
      return kSbMediaAudioConnectorBluetooth;
    case TYPE_BLE_HEADSET:
      return kSbMediaAudioConnectorBluetooth;
    case TYPE_BLE_SPEAKER:
      return kSbMediaAudioConnectorBluetooth;
    case TYPE_BLUETOOTH_A2DP:
      return kSbMediaAudioConnectorBluetooth;
    case TYPE_BLUETOOTH_SCO:
      return kSbMediaAudioConnectorBluetooth;
    case TYPE_BUILTIN_EARPIECE:
      return kSbMediaAudioConnectorBuiltIn;
    case TYPE_BUILTIN_MIC:
      return kSbMediaAudioConnectorBuiltIn;
    case TYPE_BUILTIN_SPEAKER:
      return kSbMediaAudioConnectorBuiltIn;
    case TYPE_BUILTIN_SPEAKER_SAFE:
      return kSbMediaAudioConnectorBuiltIn;
    case TYPE_BUS:
      return kSbMediaAudioConnectorUnknown;
    case TYPE_DOCK:
      return kSbMediaAudioConnectorUnknown;
    case TYPE_DOCK_ANALOG:
      return kSbMediaAudioConnectorAnalog;
    case TYPE_FM:
      return kSbMediaAudioConnectorUnknown;
    case TYPE_FM_TUNER:
      return kSbMediaAudioConnectorUnknown;
    case TYPE_HDMI:
      return kSbMediaAudioConnectorHdmi;
    case TYPE_HDMI_ARC:
      return kSbMediaAudioConnectorHdmi;
    case TYPE_HDMI_EARC:
      return kSbMediaAudioConnectorHdmi;
    case TYPE_HEARING_AID:
      return kSbMediaAudioConnectorUnknown;
    case TYPE_IP:
      return kSbMediaAudioConnectorRemoteWired;
    case TYPE_LINE_ANALOG:
      return kSbMediaAudioConnectorAnalog;
    case TYPE_LINE_DIGITAL:
      return kSbMediaAudioConnectorUnknown;
    case TYPE_REMOTE_SUBMIX:
      return kSbMediaAudioConnectorRemoteOther;
    case TYPE_TELEPHONY:
      return kSbMediaAudioConnectorUnknown;
    case TYPE_TV_TUNER:
      return kSbMediaAudioConnectorUnknown;
    case TYPE_UNKNOWN:
      return kSbMediaAudioConnectorUnknown;
    case TYPE_USB_ACCESSORY:
      return kSbMediaAudioConnectorUsb;
    case TYPE_USB_DEVICE:
      return kSbMediaAudioConnectorUsb;
    case TYPE_USB_HEADSET:
      return kSbMediaAudioConnectorUsb;
    case TYPE_WIRED_HEADPHONES:
      return kSbMediaAudioConnectorAnalog;
    case TYPE_WIRED_HEADSET:
      return kSbMediaAudioConnectorAnalog;
  }

  SB_LOG(WARNING) << "Encountered unknown audio output device type "
                  << android_output_device_type;
  return kSbMediaAudioConnectorUnknown;
}
#endif  // SB_API_VERSION >= 15

bool EndsWith(const std::string& str, const std::string& suffix) {
  if (str.size() < suffix.size()) {
    return false;
  }
  return strcmp(str.c_str() + (str.size() - suffix.size()), suffix.c_str()) ==
         0;
}

Range ConvertJavaRangeToRange(JniEnvExt* env, jobject j_range) {
  ScopedLocalJavaRef<jobject> j_upper_comparable(env->CallObjectMethodOrAbort(
      j_range, "getUpper", "()Ljava/lang/Comparable;"));
  jint j_upper_int =
      env->CallIntMethodOrAbort(j_upper_comparable.Get(), "intValue", "()I");

  ScopedLocalJavaRef<jobject> j_lower_comparable(env->CallObjectMethodOrAbort(
      j_range, "getLower", "()Ljava/lang/Comparable;"));
  jint j_lower_int =
      env->CallIntMethodOrAbort(j_lower_comparable.Get(), "intValue", "()I");
  return Range(j_lower_int, j_upper_int);
}

void ConvertStringToLowerCase(std::string* str) {
  for (int i = 0; i < str->length(); i++) {
    (*str)[i] = std::tolower((*str)[i]);
  }
}

bool GetIsWidevineSupported() {
  return JniEnvExt::Get()->CallStaticBooleanMethodOrAbort(
             "dev/cobalt/media/MediaDrmBridge",
             "isWidevineCryptoSchemeSupported", "()Z") == JNI_TRUE;
}

bool GetIsCbcsSupported() {
  return JniEnvExt::Get()->CallStaticBooleanMethodOrAbort(
             "dev/cobalt/media/MediaDrmBridge", "isCbcsSchemeSupported",
             "()Z") == JNI_TRUE;
}

std::set<SbMediaTransferId> GetSupportedHdrTypes() {
  std::set<SbMediaTransferId> supported_transfer_ids;

  JniEnvExt* env = JniEnvExt::Get();
  jintArray j_supported_hdr_types = static_cast<jintArray>(
      env->CallStarboardObjectMethodOrAbort("getSupportedHdrTypes", "()[I"));

  if (!j_supported_hdr_types) {
    // Failed to get supported hdr types.
    SB_LOG(ERROR) << "Failed to load supported hdr types.";
    return std::set<SbMediaTransferId>();
  }

  jsize length = env->GetArrayLength(j_supported_hdr_types);
  jint* numbers = env->GetIntArrayElements(j_supported_hdr_types, 0);
  for (int i = 0; i < length; i++) {
    switch (numbers[i]) {
      case HDR_TYPE_DOLBY_VISION:
        continue;
      case HDR_TYPE_HDR10:
        supported_transfer_ids.insert(kSbMediaTransferIdSmpteSt2084);
        continue;
      case HDR_TYPE_HLG:
        supported_transfer_ids.insert(kSbMediaTransferIdAribStdB67);
        continue;
      case HDR_TYPE_HDR10_PLUS:
        continue;
    }
  }
  env->ReleaseIntArrayElements(j_supported_hdr_types, numbers, 0);

  return supported_transfer_ids;
}

bool GetIsPassthroughSupported(SbMediaAudioCodec codec) {
  SbMediaAudioCodingType coding_type;
  switch (codec) {
    case kSbMediaAudioCodecAc3:
      coding_type = kSbMediaAudioCodingTypeAc3;
      break;
    case kSbMediaAudioCodecEac3:
      coding_type = kSbMediaAudioCodingTypeDolbyDigitalPlus;
      break;
    default:
      return false;
  }
  int encoding = GetAudioFormatSampleType(coding_type);
  JniEnvExt* env = JniEnvExt::Get();
  ScopedLocalJavaRef<jobject> j_audio_output_manager(
      env->CallStarboardObjectMethodOrAbort(
          "getAudioOutputManager", "()Ldev/cobalt/media/AudioOutputManager;"));
  return env->CallBooleanMethodOrAbort(j_audio_output_manager.Get(),
                                       "hasPassthroughSupportFor", "(I)Z",
                                       encoding) == JNI_TRUE;
}

bool GetAudioConfiguration(int index,
                           SbMediaAudioConfiguration* configuration) {
  *configuration = {};

  JniEnvExt* env = JniEnvExt::Get();
  ScopedLocalJavaRef<jobject> j_audio_output_manager(
      env->CallStarboardObjectMethodOrAbort(
          "getAudioOutputManager", "()Ldev/cobalt/media/AudioOutputManager;"));
  ScopedLocalJavaRef<jobject> j_output_device_info(env->NewObjectOrAbort(
      "dev/cobalt/media/AudioOutputManager$OutputDeviceInfo", "()V"));

  bool succeeded = env->CallBooleanMethodOrAbort(
      j_audio_output_manager.Get(), "getOutputDeviceInfo",
      "(ILdev/cobalt/media/AudioOutputManager$OutputDeviceInfo;)Z", index,
      j_output_device_info.Get());

  if (!succeeded) {
    SB_LOG(WARNING)
        << "Call to AudioOutputManager.getOutputDeviceInfo() failed.";
    return false;
  }

  auto call_int_method = [env, &j_output_device_info](const char* name) {
    return env->CallIntMethodOrAbort(j_output_device_info.Get(), name, "()I");
  };

#if SB_API_VERSION >= 15
  configuration->connector =
      GetConnectorFromAndroidOutputType(call_int_method("getType"));
#else   // SB_API_VERSION >= 15
  configuration->connector = kSbMediaAudioConnectorHdmi;
#endif  // SB_API_VERSION >= 15
  configuration->latency = 0;
  configuration->coding_type = kSbMediaAudioCodingTypePcm;
  configuration->number_of_channels = call_int_method("getChannels");

  if (configuration->connector != kSbMediaAudioConnectorHdmi) {
    configuration->number_of_channels = 2;
  }

  return true;
}

}  // namespace

CodecCapability::CodecCapability(JniEnvExt* env, jobject j_codec_info) {
  SB_DCHECK(env);
  SB_DCHECK(j_codec_info);

  ScopedLocalJavaRef<jstring> j_decoder_name(
      env->GetStringFieldOrAbort(j_codec_info, "decoderName"));
  name_ = env->GetStringStandardUTFOrAbort(j_decoder_name.Get());
  is_secure_required_ =
      env->CallBooleanMethodOrAbort(j_codec_info, "isSecureRequired", "()Z") ==
      JNI_TRUE;
  is_secure_supported_ =
      env->CallBooleanMethodOrAbort(j_codec_info, "isSecureSupported", "()Z") ==
      JNI_TRUE;
  is_tunnel_mode_required_ =
      env->CallBooleanMethodOrAbort(j_codec_info, "isTunnelModeRequired",
                                    "()Z") == JNI_TRUE;
  is_tunnel_mode_supported_ =
      env->CallBooleanMethodOrAbort(j_codec_info, "isTunnelModeSupported",
                                    "()Z") == JNI_TRUE;
}

AudioCodecCapability::AudioCodecCapability(JniEnvExt* env,
                                           jobject j_codec_info,
                                           jobject j_audio_capabilities)
    : CodecCapability(env, j_codec_info) {
  SB_DCHECK(env);
  SB_DCHECK(j_codec_info);
  SB_DCHECK(j_audio_capabilities);

  ScopedLocalJavaRef<jobject> j_bitrate_range(env->CallObjectMethodOrAbort(
      j_audio_capabilities, "getBitrateRange", "()Landroid/util/Range;"));
  supported_bitrates_ = ConvertJavaRangeToRange(env, j_bitrate_range.Get());

  // Overwrite the lower bound to 0.
  supported_bitrates_.minimum = 0;
}

bool AudioCodecCapability::IsBitrateSupported(int bitrate) const {
  return supported_bitrates_.Contains(bitrate);
}

VideoCodecCapability::VideoCodecCapability(JniEnvExt* env,
                                           jobject j_codec_info,
                                           jobject j_video_capabilities)
    : CodecCapability(env, j_codec_info) {
  SB_DCHECK(env);
  SB_DCHECK(j_codec_info);
  SB_DCHECK(j_video_capabilities);

  is_software_decoder_ = env->CallBooleanMethodOrAbort(
                             j_codec_info, "isSoftware", "()Z") == JNI_TRUE;

  is_hdr_capable_ = env->CallBooleanMethodOrAbort(j_codec_info, "isHdrCapable",
                                                  "()Z") == JNI_TRUE;

  j_video_capabilities_ = env->NewGlobalRef(j_video_capabilities);

  ScopedLocalJavaRef<jobject> j_width_range(env->CallObjectMethodOrAbort(
      j_video_capabilities_, "getSupportedWidths", "()Landroid/util/Range;"));
  supported_widths_ = ConvertJavaRangeToRange(env, j_width_range.Get());

  ScopedLocalJavaRef<jobject> j_height_range(env->CallObjectMethodOrAbort(
      j_video_capabilities_, "getSupportedHeights", "()Landroid/util/Range;"));
  supported_heights_ = ConvertJavaRangeToRange(env, j_height_range.Get());

  ScopedLocalJavaRef<jobject> j_bitrate_range(env->CallObjectMethodOrAbort(
      j_video_capabilities_, "getBitrateRange", "()Landroid/util/Range;"));
  supported_bitrates_ = ConvertJavaRangeToRange(env, j_bitrate_range.Get());

  ScopedLocalJavaRef<jobject> j_frame_rate_range(env->CallObjectMethodOrAbort(
      j_video_capabilities_, "getSupportedFrameRates",
      "()Landroid/util/Range;"));
  supported_frame_rates_ =
      ConvertJavaRangeToRange(env, j_frame_rate_range.Get());
}

VideoCodecCapability::~VideoCodecCapability() {
  JniEnvExt* env = JniEnvExt::Get();
  env->DeleteGlobalRef(j_video_capabilities_);
}

bool VideoCodecCapability::IsBitrateSupported(int bitrate) const {
  return supported_bitrates_.Contains(bitrate);
}

bool VideoCodecCapability::AreResolutionAndRateSupported(int frame_width,
                                                         int frame_height,
                                                         int fps) {
  if (frame_width != 0 && frame_height != 0 && fps != 0) {
    return JniEnvExt::Get()->CallBooleanMethodOrAbort(
               j_video_capabilities_, "areSizeAndRateSupported", "(IID)Z",
               frame_width, frame_height,
               static_cast<jdouble>(fps)) == JNI_TRUE;
  } else if (frame_width != 0 && frame_height != 0) {
    return JniEnvExt::Get()->CallBooleanMethodOrAbort(
               j_video_capabilities_, "isSizeSupported", "(II)Z", frame_width,
               frame_height) == JNI_TRUE;
  }
  if (frame_width != 0 && !supported_widths_.Contains(frame_width)) {
    return false;
  }
  if (frame_height != 0 && !supported_heights_.Contains(frame_height)) {
    return false;
  }
  if (fps != 0 && !supported_frame_rates_.Contains(fps)) {
    return false;
  }
  return true;
}

// static
SB_ONCE_INITIALIZE_FUNCTION(MediaCapabilitiesCache,
                            MediaCapabilitiesCache::GetInstance);

bool MediaCapabilitiesCache::IsWidevineSupported() {
  if (!is_enabled_) {
    return GetIsWidevineSupported();
  }
  ScopedLock scoped_lock(mutex_);
  UpdateMediaCapabilities_Locked();
  return is_widevine_supported_;
}

bool MediaCapabilitiesCache::IsCbcsSchemeSupported() {
  if (!is_enabled_) {
    return GetIsCbcsSupported();
  }
  ScopedLock scoped_lock(mutex_);
  UpdateMediaCapabilities_Locked();
  return is_cbcs_supported_;
}

bool MediaCapabilitiesCache::IsHDRTransferCharacteristicsSupported(
    SbMediaTransferId transfer_id) {
  if (!is_enabled_) {
    std::set<SbMediaTransferId> supported_transfer_ids = GetSupportedHdrTypes();
    return supported_transfer_ids.find(transfer_id) !=
           supported_transfer_ids.end();
  }
  ScopedLock scoped_lock(mutex_);
  UpdateMediaCapabilities_Locked();
  return supported_transfer_ids_.find(transfer_id) !=
         supported_transfer_ids_.end();
}

bool MediaCapabilitiesCache::IsPassthroughSupported(SbMediaAudioCodec codec) {
  if (!is_enabled_) {
    return GetIsPassthroughSupported(codec);
  }
  // IsPassthroughSupported() caches the results of previous quiries, and does
  // not rely on LazyInitialize(), which is different from other functions.
  ScopedLock scoped_lock(mutex_);
  auto iter = passthrough_supportabilities_.find(codec);
  if (iter != passthrough_supportabilities_.end()) {
    return iter->second;
  }
  bool supported = GetIsPassthroughSupported(codec);
  passthrough_supportabilities_[codec] = supported;
  return supported;
}

bool MediaCapabilitiesCache::GetAudioConfiguration(
    int index,
    SbMediaAudioConfiguration* configuration) {
  SB_DCHECK(index >= 0);
  if (!is_enabled_) {
    return ::starboard::android::shared::GetAudioConfiguration(index,
                                                               configuration);
  }

  ScopedLock scoped_lock(mutex_);
  UpdateMediaCapabilities_Locked();
  if (index < audio_configurations_.size()) {
    *configuration = audio_configurations_[index];
    return true;
  }
  return false;
}

bool MediaCapabilitiesCache::HasAudioDecoderFor(const std::string& mime_type,
                                                int bitrate) {
  return !FindAudioDecoder(mime_type, bitrate).empty();
}

bool MediaCapabilitiesCache::HasVideoDecoderFor(const std::string& mime_type,
                                                bool must_support_secure,
                                                bool must_support_hdr,
                                                bool must_support_tunnel_mode,
                                                int frame_width,
                                                int frame_height,
                                                int bitrate,
                                                int fps) {
  return !FindVideoDecoder(mime_type, must_support_secure, must_support_hdr,
                           false, must_support_tunnel_mode, frame_width,
                           frame_height, bitrate, fps)
              .empty();
}

std::string MediaCapabilitiesCache::FindAudioDecoder(
    const std::string& mime_type,
    int bitrate) {
  if (!is_enabled_) {
    JniEnvExt* env = JniEnvExt::Get();
    ScopedLocalJavaRef<jstring> j_mime(
        env->NewStringStandardUTFOrAbort(mime_type.c_str()));
    jobject j_decoder_name = env->CallStaticObjectMethodOrAbort(
        "dev/cobalt/media/MediaCodecUtil", "findAudioDecoder",
        "(Ljava/lang/String;I)Ljava/lang/String;", j_mime.Get(), bitrate);
    return env->GetStringStandardUTFOrAbort(
        static_cast<jstring>(j_decoder_name));
  }

  ScopedLock scoped_lock(mutex_);
  UpdateMediaCapabilities_Locked();

  for (auto& audio_capability : audio_codec_capabilities_map_[mime_type]) {
    // Reject if bitrate is not supported.
    if (!audio_capability->IsBitrateSupported(bitrate)) {
      continue;
    }
    return audio_capability->name();
  }

  return "";
}

std::string MediaCapabilitiesCache::FindVideoDecoder(
    const std::string& mime_type,
    bool must_support_secure,
    bool must_support_hdr,
    bool require_software_codec,
    bool must_support_tunnel_mode,
    int frame_width,
    int frame_height,
    int bitrate,
    int fps) {
  if (!is_enabled_) {
    JniEnvExt* env = JniEnvExt::Get();
    ScopedLocalJavaRef<jstring> j_mime(
        env->NewStringStandardUTFOrAbort(mime_type.c_str()));
    jobject j_decoder_name = env->CallStaticObjectMethodOrAbort(
        "dev/cobalt/media/MediaCodecUtil", "findVideoDecoder",
        "(Ljava/lang/String;ZZZZIIIII)Ljava/lang/String;", j_mime.Get(),
        must_support_secure, must_support_hdr,
        false,                        /* mustSupportSoftwareCodec */
        must_support_tunnel_mode, -1, /* decoderCacheTtlMs */
        frame_width, frame_height, bitrate, fps);
    return env->GetStringStandardUTFOrAbort(
        static_cast<jstring>(j_decoder_name));
  }

  ScopedLock scoped_lock(mutex_);
  UpdateMediaCapabilities_Locked();

  for (auto& video_capability : video_codec_capabilities_map_[mime_type]) {
    // Reject if secure decoder is required but codec doesn't support it.
    if (must_support_secure && !video_capability->is_secure_supported()) {
      continue;
    }
    // Reject if non secure decoder is required but codec doesn't support it.
    if (!must_support_secure && video_capability->is_secure_required()) {
      continue;
    }
    // Reject if tunnel mode is required but codec doesn't support it.
    if (must_support_tunnel_mode &&
        !video_capability->is_tunnel_mode_supported()) {
      continue;
    }
    // Reject if non tunnel mode is required but codec doesn't support it.
    if (!must_support_tunnel_mode &&
        video_capability->is_tunnel_mode_required()) {
      continue;
    }
    // Reject if software codec is required but codec is not.
    if (require_software_codec && !video_capability->is_software_decoder()) {
      continue;
    }
    // Reject if hdr is required but codec doesn't support it.
    if (must_support_hdr && !video_capability->is_hdr_capable()) {
      continue;
    }

    // Reject if resolution or frame rate is not supported.
    if (!video_capability->AreResolutionAndRateSupported(frame_width,
                                                         frame_height, fps)) {
      continue;
    }

    // Reject if bitrate is not supported.
    if (bitrate != 0 && !video_capability->IsBitrateSupported(bitrate)) {
      continue;
    }

    // Append ".secure" for secure decoder if not represents.
    if (must_support_secure &&
        !EndsWith(video_capability->name(), SECURE_DECODER_SUFFIX)) {
      return video_capability->name() + SECURE_DECODER_SUFFIX;
    }
    return video_capability->name();
  }

  return "";
}

MediaCapabilitiesCache::MediaCapabilitiesCache() {
  // Enable mime and key system caches.
  MimeSupportabilityCache::GetInstance()->SetCacheEnabled(true);
  KeySystemSupportabilityCache::GetInstance()->SetCacheEnabled(true);
}

void MediaCapabilitiesCache::UpdateMediaCapabilities_Locked() {
  mutex_.DCheckAcquired();
  if (capabilities_is_dirty_.exchange(false)) {
    // We use a different cache strategy (load and cache) for passthrough
    // supportabilities, so we only clear |passthrough_supportabilities_| here.
    passthrough_supportabilities_.clear();

    audio_codec_capabilities_map_.clear();
    video_codec_capabilities_map_.clear();
    audio_configurations_.clear();
    is_widevine_supported_ = GetIsWidevineSupported();
    is_cbcs_supported_ = GetIsCbcsSupported();
    supported_transfer_ids_ = GetSupportedHdrTypes();
    LoadCodecInfos_Locked();
    LoadAudioConfigurations_Locked();
  }
}

void MediaCapabilitiesCache::LoadCodecInfos_Locked() {
  SB_DCHECK(audio_codec_capabilities_map_.empty());
  SB_DCHECK(video_codec_capabilities_map_.empty());
  mutex_.DCheckAcquired();

  JniEnvExt* env = JniEnvExt::Get();
  ScopedLocalJavaRef<jobjectArray> j_codec_infos(
      static_cast<jobjectArray>(env->CallStaticObjectMethodOrAbort(
          "dev/cobalt/media/MediaCodecUtil", "getAllCodecCapabilityInfos",
          "()[Ldev/cobalt/media/MediaCodecUtil$CodecCapabilityInfo;")));
  jsize length = env->GetArrayLength(j_codec_infos.Get());
  // Note: Codec infos are sorted by the framework such that the best
  // decoders come first.
  // This order is maintained in the cache.
  for (int i = 0; i < length; i++) {
    ScopedLocalJavaRef<jobject> j_codec_info(
        env->GetObjectArrayElementOrAbort(j_codec_infos.Get(), i));

    ScopedLocalJavaRef<jstring> j_mime_type(
        env->GetStringFieldOrAbort(j_codec_info.Get(), "mimeType"));
    std::string mime_type = env->GetStringStandardUTFOrAbort(j_mime_type.Get());
    // Convert the mime type to lower case.
    ConvertStringToLowerCase(&mime_type);

    ScopedLocalJavaRef<jobject> j_audio_capabilities(env->GetObjectFieldOrAbort(
        j_codec_info.Get(), "audioCapabilities",
        "Landroid/media/MediaCodecInfo$AudioCapabilities;"));
    if (j_audio_capabilities) {
      // Found an audio decoder.
      std::unique_ptr<AudioCodecCapability> audio_codec_capabilities(
          new AudioCodecCapability(env, j_codec_info.Get(),
                                   j_audio_capabilities.Get()));
      audio_codec_capabilities_map_[mime_type].push_back(
          std::move(audio_codec_capabilities));
      continue;
    }
    ScopedLocalJavaRef<jobject> j_video_capabilities(env->GetObjectFieldOrAbort(
        j_codec_info.Get(), "videoCapabilities",
        "Landroid/media/MediaCodecInfo$VideoCapabilities;"));
    if (j_video_capabilities) {
      // Found a video decoder.
      std::unique_ptr<VideoCodecCapability> video_codec_capabilities(
          new VideoCodecCapability(env, j_codec_info.Get(),
                                   j_video_capabilities.Get()));
      video_codec_capabilities_map_[mime_type].push_back(
          std::move(video_codec_capabilities));
    }
  }
}

void MediaCapabilitiesCache::LoadAudioConfigurations_Locked() {
  SB_DCHECK(audio_configurations_.empty());
  mutex_.DCheckAcquired();

  // SbPlayerBridge::GetAudioConfigurations() reads up to 32 configurations. The
  // limit here is to avoid infinite loop and also match
  // SbPlayerBridge::GetAudioConfigurations().
  const int kMaxAudioConfigurations = 32;
  SbMediaAudioConfiguration configuration;
  while (audio_configurations_.size() < kMaxAudioConfigurations &&
         ::starboard::android::shared::GetAudioConfiguration(
             audio_configurations_.size(), &configuration)) {
    audio_configurations_.push_back(configuration);
  }
}

extern "C" SB_EXPORT_PLATFORM void
Java_dev_cobalt_util_DisplayUtil_nativeOnDisplayChanged() {
  // Display device change could change hdr capabilities.
  MediaCapabilitiesCache::GetInstance()->ClearCache();
  MimeSupportabilityCache::GetInstance()->ClearCachedMimeSupportabilities();
}

extern "C" SB_EXPORT_PLATFORM void
Java_dev_cobalt_media_AudioOutputManager_nativeOnAudioDeviceChanged() {
  // Audio output device change could change passthrough decoder capabilities,
  // so we have to reload codec capabilities.
  MediaCapabilitiesCache::GetInstance()->ClearCache();
  MimeSupportabilityCache::GetInstance()->ClearCachedMimeSupportabilities();
}

}  // namespace shared
}  // namespace android
}  // namespace starboard