media / base / win / media_foundation_package_runtime_locator.cc [blame]

// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "media/base/win/media_foundation_package_runtime_locator.h"

#include <windows.h>

#include <map>
#include <optional>
#include <string>
#include <vector>

#include "base/files/file_util.h"
#include "base/logging.h"
#include "base/native_library.h"
#include "base/no_destructor.h"
#include "base/path_service.h"
#include "base/stl_util.h"
#include "build/build_config.h"
#include "media/base/win/media_foundation_package_locator_helper.h"

namespace media {

namespace {

constexpr wchar_t kMfPackageFamilyName_HEVC[] =
    L"Microsoft.HEVCVideoExtension_8wekyb3d8bbwe";
constexpr wchar_t kMfPackageFamilyName_HEVC_2[] =
    L"Microsoft.HEVCVideoExtensions_8wekyb3d8bbwe";
constexpr wchar_t kMfPackageFamilyName_DolbyVision[] =
    L"DolbyLaboratories.DolbyVisionAccess_rz1tebttyb220";
constexpr wchar_t kMfPackageFamilyName_DolbyVision_2[] =
    L"DolbyLaboratories.DolbyVisionHDR_rz1tebttyb220";
constexpr wchar_t kMfPackageFamilyName_AC4[] =
    L"DolbyLaboratories.DolbyAC4DecoderOEM_rz1tebttyb220";
constexpr wchar_t kMfPackageFamilyName_EAC3[] =
    L"DolbyLaboratories.DolbyDigitalPlusDecoderOEM_rz1tebttyb220";
constexpr wchar_t kMfLibraryName_AC4[] = L"DolbyAc4DecMft.dll";
constexpr wchar_t kMfLibraryName_EAC3[] = L"DolbyDDPDecMft.dll";

constexpr MediaFoundationCodecPackage kMfCodecPackages[] = {
    MediaFoundationCodecPackage::kEAC3, MediaFoundationCodecPackage::kAC4,
    MediaFoundationCodecPackage::kHEVC,
    MediaFoundationCodecPackage::kDolbyVision};

std::wstring GetMfCodecPackageName(MediaFoundationCodecPackage codec_package) {
  switch (codec_package) {
    case MediaFoundationCodecPackage::kAV1:
      return L"kAV1";
    case MediaFoundationCodecPackage::kHEVC:
      return L"kHEVC";
    case MediaFoundationCodecPackage::kVP9:
      return L"kVP9";
    case MediaFoundationCodecPackage::kDolbyVision:
      return L"kDolbyVision";
    case MediaFoundationCodecPackage::kAC4:
      return L"kAC4";
    case MediaFoundationCodecPackage::kEAC3:
      return L"kEAC3";
  }
}

std::vector<std::wstring_view> GetMfCodecPackageFamilyNames(
    MediaFoundationCodecPackage codec_package) {
  std::vector<std::wstring_view> package_family_names;
  switch (codec_package) {
    case MediaFoundationCodecPackage::kHEVC:
      package_family_names.push_back(kMfPackageFamilyName_HEVC);
      package_family_names.push_back(kMfPackageFamilyName_HEVC_2);
      break;
    case MediaFoundationCodecPackage::kDolbyVision:
      package_family_names.push_back(kMfPackageFamilyName_DolbyVision);
      package_family_names.push_back(kMfPackageFamilyName_DolbyVision_2);
      break;
    case MediaFoundationCodecPackage::kAC4:
      package_family_names.push_back(kMfPackageFamilyName_AC4);
      break;
    case MediaFoundationCodecPackage::kEAC3:
      package_family_names.push_back(kMfPackageFamilyName_EAC3);
      break;
    default:
      break;
  }
  return package_family_names;
}

std::wstring GetMfCodecPackageLibraryName(
    MediaFoundationCodecPackage codec_package) {
  switch (codec_package) {
    case MediaFoundationCodecPackage::kAC4:
      return kMfLibraryName_AC4;
    case MediaFoundationCodecPackage::kEAC3:
      return kMfLibraryName_EAC3;
    default:
      return L"";
  }
}

struct DllModuleInfo {
  std::vector<base::FilePath> Paths;
  std::optional<bool> Loaded;
};

// This helper class, based on media_foundation_package_locator_helper.h, offers
// two primary functionalities:
//   1. Detection of the existence of specific MediaFoundation codec packages on
//   the user's device. This capability can be utilized by the W3C Media
//   Capability checking API, including methods such as HTMLMediaElement:
//   canPlayType(), MediaSource: isTypeSupported(), and
//   mediaCapabilities.decodingInfo().
//   2. Loading codec libraries from codec packages into process memory.
//   Typically, the codec library is loaded into the Chromium GPU process before
//   it is sandboxed, aiming to resolve 'access denied' issues.
// It provides a static method to obtain a single instance of
// MediaFoundationPackageRuntimeLocator on-demand, which persists in process
// memory until the termination of the process.
class MediaFoundationPackageRuntimeLocator {
 public:
  static MediaFoundationPackageRuntimeLocator& GetInstance();
  MediaFoundationPackageRuntimeLocator(
      const MediaFoundationPackageRuntimeLocator&) = delete;
  MediaFoundationPackageRuntimeLocator& operator=(
      const MediaFoundationPackageRuntimeLocator&) = delete;
  bool FoundModule(MediaFoundationCodecPackage codec) const;
  bool LoadModule(MediaFoundationCodecPackage codec);

 private:
  friend class base::NoDestructor<MediaFoundationPackageRuntimeLocator>;
  MediaFoundationPackageRuntimeLocator();
  ~MediaFoundationPackageRuntimeLocator() = default;
  std::map<MediaFoundationCodecPackage, DllModuleInfo> mf_dll_module_;
};

// static method to get a single MediaFoundationPackageRuntimeLocator
// instance on-demand.
MediaFoundationPackageRuntimeLocator&
MediaFoundationPackageRuntimeLocator::GetInstance() {
  static base::NoDestructor<MediaFoundationPackageRuntimeLocator> instance;
  return *instance;
}

MediaFoundationPackageRuntimeLocator::MediaFoundationPackageRuntimeLocator() {
  DVLOG(1) << __func__;
  for (auto& codec_package : kMfCodecPackages) {
    auto package_names = GetMfCodecPackageFamilyNames(codec_package);
    auto package_library = GetMfCodecPackageLibraryName(codec_package);
    std::vector<base::FilePath> paths = MediaFoundationPackageInstallPaths(
        package_names, package_library, codec_package);
    if (paths.empty()) {
      DVLOG(2) << __func__ << ": MediaFoundation codec package ("
               << GetMfCodecPackageName(codec_package) << ") is not installed.";
      continue;
    }

    mf_dll_module_[codec_package] = DllModuleInfo{std::move(paths)};
  }
}

bool MediaFoundationPackageRuntimeLocator::FoundModule(
    MediaFoundationCodecPackage codec_package) const {
  auto result = mf_dll_module_.find(codec_package);
  if (result == mf_dll_module_.cend()) {
    DVLOG(2) << __func__ << ": Can not find codec package ("
             << GetMfCodecPackageName(codec_package) << ")";
    return false;
  }

  auto& module_info = result->second;
  if (module_info.Paths.empty()) {
    DVLOG(2) << __func__ << ": Found codec package ("
             << GetMfCodecPackageName(codec_package)
             << "), but it's library path is empty";
    return false;
  }

  if (module_info.Loaded.has_value() && !module_info.Loaded.value()) {
    DVLOG(2) << __func__ << ": Found codec package ("
             << GetMfCodecPackageName(codec_package)
             << "), but load it's library module failed";
    return false;
  }

  return true;
}

bool MediaFoundationPackageRuntimeLocator::LoadModule(
    MediaFoundationCodecPackage codec_package) {
  auto result = mf_dll_module_.find(codec_package);
  if (result == mf_dll_module_.cend()) {
    DVLOG(2) << __func__ << ": Can not find codec package ("
             << GetMfCodecPackageName(codec_package) << ")";
    return false;
  }

  auto& module_info = result->second;
  if (module_info.Loaded.has_value()) {
    return module_info.Loaded.value();
  }

  if (module_info.Paths.empty()) {
    DVLOG(2) << __func__ << ": Found codec package ("
             << GetMfCodecPackageName(codec_package)
             << "), but it's library path is empty";
    return false;
  }

  for (auto& path : module_info.Paths) {
    if (LoadNativeLibrary(path, nullptr)) {
      // Intentionally don't call UnloadNativeLibrary, to ensure it
      // stays loaded
      module_info.Loaded = true;
      DVLOG(3) << __func__ << ": MediaFoundation package "
               << GetMfCodecPackageName(codec_package) << " loaded";
      return true;
    }
  }
  module_info.Loaded = false;
  return false;
}

std::optional<MediaFoundationCodecPackage>
AudioCodecToMediaFoundationCodecPackage(AudioCodec codec) {
  std::optional<MediaFoundationCodecPackage> package_type{std::nullopt};
  switch (codec) {
    case AudioCodec::kAC3:
    case AudioCodec::kEAC3:
      package_type = MediaFoundationCodecPackage::kEAC3;
      break;
    case AudioCodec::kAC4:
      package_type = MediaFoundationCodecPackage::kAC4;
      break;
    default:
      DVLOG(3) << "Audio codec " << GetCodecName(codec)
               << " has no MediaFoundation package.";
      break;
  }
  return package_type;
}

}  // namespace

bool LoadMediaFoundationPackageDecoder(AudioCodec codec) {
  auto codec_package = AudioCodecToMediaFoundationCodecPackage(codec);
  return codec_package.has_value()
             ? MediaFoundationPackageRuntimeLocator::GetInstance().LoadModule(
                   codec_package.value())
             : false;
}

bool FindMediaFoundationPackageDecoder(AudioCodec codec) {
  auto codec_package = AudioCodecToMediaFoundationCodecPackage(codec);
  return codec_package.has_value()
             ? MediaFoundationPackageRuntimeLocator::GetInstance().FoundModule(
                   codec_package.value())
             : false;
}

}  // namespace media