media / cdm / win / test / media_foundation_clear_key_cdm.cc [blame]

// Copyright 2023 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/cdm/win/test/media_foundation_clear_key_cdm.h"

#include <mfapi.h>
#include <mferror.h>
#include <windows.media.protection.playready.h>
#include <wrl.h>
#include <wrl/client.h>
#include <wrl/implements.h>

#include "base/notreached.h"
#include "media/base/win/mf_feature_checks.h"
#include "media/base/win/mf_helpers.h"
#include "media/cdm/clear_key_cdm_common.h"
#include "media/cdm/win/test/media_foundation_clear_key_guids.h"
#include "media/cdm/win/test/media_foundation_clear_key_session.h"
#include "media/cdm/win/test/media_foundation_clear_key_trusted_input.h"
#include "media/cdm/win/test/mock_media_protection_pmp_server.h"

namespace media {

using Microsoft::WRL::ComPtr;
using Microsoft::WRL::MakeAndInitialize;

namespace {

static HRESULT AddPropertyToSet(
    _Inout_ ABI::Windows::Foundation::Collections::IPropertySet* property_set,
    _In_ LPCWSTR name,
    _In_ IInspectable* inspectable) {
  boolean replaced = false;
  ComPtr<ABI::Windows::Foundation::Collections::IMap<HSTRING, IInspectable*>>
      map;

  RETURN_IF_FAILED(property_set->QueryInterface(IID_PPV_ARGS(&map)));
  RETURN_IF_FAILED(
      map->Insert(Microsoft::WRL::Wrappers::HStringReference(name).Get(),
                  inspectable, &replaced));

  return S_OK;
}

static HRESULT AddStringToPropertySet(
    _Inout_ ABI::Windows::Foundation::Collections::IPropertySet* property_set,
    _In_ LPCWSTR name,
    _In_ LPCWSTR string) {
  ComPtr<ABI::Windows::Foundation::IPropertyValue> property_value;
  ComPtr<ABI::Windows::Foundation::IPropertyValueStatics>
      property_value_statics;

  RETURN_IF_FAILED(ABI::Windows::Foundation::GetActivationFactory(
      Microsoft::WRL::Wrappers::HStringReference(
          RuntimeClass_Windows_Foundation_PropertyValue)
          .Get(),
      &property_value_statics));

  RETURN_IF_FAILED(property_value_statics->CreateString(
      Microsoft::WRL::Wrappers::HStringReference(string).Get(),
      &property_value));
  RETURN_IF_FAILED(AddPropertyToSet(property_set, name, property_value.Get()));

  return S_OK;
}

static HRESULT AddBoolToPropertySet(
    _Inout_ ABI::Windows::Foundation::Collections::IPropertySet* property_set,
    _In_ LPCWSTR name,
    _In_ BOOL value) {
  ComPtr<ABI::Windows::Foundation::IPropertyValue> property_value;
  ComPtr<ABI::Windows::Foundation::IPropertyValueStatics>
      property_value_statics;

  RETURN_IF_FAILED(ABI::Windows::Foundation::GetActivationFactory(
      Microsoft::WRL::Wrappers::HStringReference(
          RuntimeClass_Windows_Foundation_PropertyValue)
          .Get(),
      &property_value_statics));

  RETURN_IF_FAILED(
      property_value_statics->CreateBoolean(!!value, &property_value));
  RETURN_IF_FAILED(AddPropertyToSet(property_set, name, property_value.Get()));

  return S_OK;
}

}  // namespace

MediaFoundationClearKeyCdm::MediaFoundationClearKeyCdm() {
  DVLOG_FUNC(1);
}

MediaFoundationClearKeyCdm::~MediaFoundationClearKeyCdm() {
  DVLOG_FUNC(1);
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  Shutdown();
}

HRESULT MediaFoundationClearKeyCdm::RuntimeClassInitialize(
    _In_ IPropertyStore* properties) {
  DVLOG_FUNC(1);
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);

  ComPtr<ABI::Windows::Foundation::Collections::IPropertySet> property_pmp;
  RETURN_IF_FAILED(Windows::Foundation::ActivateInstance(
      Microsoft::WRL::Wrappers::HStringReference(
          RuntimeClass_Windows_Foundation_Collections_PropertySet)
          .Get(),
      &property_pmp));

  // As a workaround to create an in-process PMP server, use the PlayReady media
  // protection system ID here as the MediaEngine will call
  // MFIsContentProtectionDeviceSupported() to determine whether the specified
  // protection system ID is supported.
  RETURN_IF_FAILED(AddStringToPropertySet(
      property_pmp.Get(), L"Windows.Media.Protection.MediaProtectionSystemId",
      PLAYREADY_GUID_MEDIA_PROTECTION_SYSTEM_ID_STRING));

  // Setting this to TRUE allows the system to create an in-process PMP server,
  // pretending to use hardware protection layer.
  RETURN_IF_FAILED(AddBoolToPropertySet(
      property_pmp.Get(),
      L"Windows.Media.Protection.UseHardwareProtectionLayer", TRUE));

  // Note that we don't need to add this property
  // "Windows.Media.Protection.MediaProtectionSystemIdMapping".

  // Use a custom PMP server so that MediaEngine can create an in-process PMP
  // server regardless of the system's hardware decryption capability.
  RETURN_IF_FAILED((MakeAndInitialize<
                    MockMediaProtectionPMPServer,
                    ABI::Windows::Media::Protection::IMediaProtectionPMPServer>(
      &media_protection_pmp_server_, property_pmp.Get())));

  return S_OK;
}

// IMFContentDecryptionModule
STDMETHODIMP MediaFoundationClearKeyCdm::SetContentEnabler(
    _In_ IMFContentEnabler* content_enabler,
    _In_ IMFAsyncResult* result) {
  DVLOG_FUNC(1);

  // This method can be called from a different MF thread, so the
  // DCHECK_CALLED_ON_VALID_THREAD(thread_checker_) is not checked here.

  RETURN_IF_FAILED(GetShutdownStatus());

  if (!content_enabler || !result) {
    return E_INVALIDARG;
  }

  // Invoke the callback immediately but will determine whether the keyid exists
  // or not in the decryptor's ProcessOutput().
  RETURN_IF_FAILED(MFInvokeCallback(result));

  return S_OK;
}

STDMETHODIMP MediaFoundationClearKeyCdm::GetSuspendNotify(
    _COM_Outptr_ IMFCdmSuspendNotify** notify) {
  DVLOG_FUNC(3);

  // API not used.
  NOTIMPLEMENTED();
  return E_NOTIMPL;
}

STDMETHODIMP MediaFoundationClearKeyCdm::SetPMPHostApp(IMFPMPHostApp* host) {
  DVLOG_FUNC(3);

  // API not used.
  NOTIMPLEMENTED();
  return E_NOTIMPL;
}

STDMETHODIMP MediaFoundationClearKeyCdm::CreateSession(
    _In_ MF_MEDIAKEYSESSION_TYPE session_type,
    _In_ IMFContentDecryptionModuleSessionCallbacks* callbacks,
    _COM_Outptr_ IMFContentDecryptionModuleSession** session) {
  DVLOG_FUNC(1);
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  RETURN_IF_FAILED(GetShutdownStatus());

  RETURN_IF_FAILED((MakeAndInitialize<MediaFoundationClearKeySession,
                                      IMFContentDecryptionModuleSession>(
      session, session_type, callbacks, GetAesDecryptor(),
      base::BindOnce(&MediaFoundationClearKeyCdm::OnSessionIdCreated,
                     weak_factory_.GetWeakPtr()),
      base::BindOnce(&MediaFoundationClearKeyCdm::OnSessionIdRemoved,
                     weak_factory_.GetWeakPtr()))));

  return S_OK;
}

STDMETHODIMP MediaFoundationClearKeyCdm::SetServerCertificate(
    _In_reads_bytes_opt_(server_certificate_size)
        const BYTE* server_certificate,
    _In_ DWORD server_certificate_size) {
  DVLOG_FUNC(3);

  // API not used.
  NOTIMPLEMENTED();
  return E_NOTIMPL;
}

STDMETHODIMP MediaFoundationClearKeyCdm::CreateTrustedInput(
    _In_reads_bytes_(content_init_data_size) const BYTE* content_init_data,
    _In_ DWORD content_init_data_size,
    _COM_Outptr_ IMFTrustedInput** trusted_input) {
  DVLOG_FUNC(1);

  // This method can be called from a different MF thread, so the
  // DCHECK_CALLED_ON_VALID_THREAD(thread_checker_) is not checked here.

  RETURN_IF_FAILED(GetShutdownStatus());

  ComPtr<IMFTrustedInput> trusted_input_new;
  RETURN_IF_FAILED(
      (MakeAndInitialize<MediaFoundationClearKeyTrustedInput, IMFTrustedInput>(
          &trusted_input_new, GetAesDecryptor())));

  *trusted_input = trusted_input_new.Detach();

  return S_OK;
}

STDMETHODIMP MediaFoundationClearKeyCdm::GetProtectionSystemIds(
    _Outptr_result_buffer_(*count) GUID** system_ids,
    _Out_ DWORD* count) {
  DVLOG_FUNC(1);
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  RETURN_IF_FAILED(GetShutdownStatus());

  *system_ids = nullptr;
  *count = 0;

  GUID* system_id = static_cast<GUID*>(CoTaskMemAlloc(sizeof(GUID)));
  if (!system_id) {
    return E_OUTOFMEMORY;
  }

  *system_id = MEDIA_FOUNDATION_CLEARKEY_GUID_CLEARKEY_PROTECTION_SYSTEM_ID;
  *system_ids = system_id;
  *count = 1;

  return S_OK;
}

// IMFGetService
STDMETHODIMP MediaFoundationClearKeyCdm::GetService(
    __RPC__in REFGUID guid_service,
    __RPC__in REFIID riid,
    __RPC__deref_out_opt LPVOID* object) {
  DVLOG_FUNC(1);

  // This method can be called from a different MF thread, so the
  // DCHECK_CALLED_ON_VALID_THREAD(thread_checker_) is not checked here.

  RETURN_IF_FAILED(GetShutdownStatus());

  if (MF_CONTENTDECRYPTIONMODULE_SERVICE != guid_service) {
    return MF_E_UNSUPPORTED_SERVICE;
  }

  if (media_protection_pmp_server_ == nullptr) {
    return MF_INVALID_STATE_ERR;
  }

  if (riid == ABI::Windows::Media::Protection::IID_IMediaProtectionPMPServer) {
    RETURN_IF_FAILED(media_protection_pmp_server_.CopyTo(riid, object));
  } else {
    ComPtr<IMFGetService> get_service;
    RETURN_IF_FAILED(media_protection_pmp_server_.As(&get_service));
    RETURN_IF_FAILED(get_service->GetService(MF_PMP_SERVICE, riid, object));
  }

  return S_OK;
}

// IMFShutdown
STDMETHODIMP MediaFoundationClearKeyCdm::Shutdown() {
  DVLOG_FUNC(1);
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);

  base::AutoLock lock(lock_);
  if (is_shutdown_) {
    return MF_E_SHUTDOWN;
  }

  is_shutdown_ = true;
  return S_OK;
}

STDMETHODIMP MediaFoundationClearKeyCdm::GetShutdownStatus(
    MFSHUTDOWN_STATUS* status) {
  DVLOG_FUNC(1);
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);

  // Per IMFShutdown::GetShutdownStatus spec, MF_E_INVALIDREQUEST is returned if
  // Shutdown has not been called beforehand.
  base::AutoLock lock(lock_);
  if (!is_shutdown_) {
    return MF_E_INVALIDREQUEST;
  }

  return S_OK;
}

scoped_refptr<AesDecryptor> MediaFoundationClearKeyCdm::GetAesDecryptor() {
  DVLOG_FUNC(1);

  if (!aes_decryptor_) {
    aes_decryptor_ = base::MakeRefCounted<AesDecryptor>(
        base::BindRepeating(&MediaFoundationClearKeyCdm::OnSessionMessage,
                            weak_factory_.GetWeakPtr()),
        base::BindRepeating(&MediaFoundationClearKeyCdm::OnSessionClosed,
                            weak_factory_.GetWeakPtr()),
        base::BindRepeating(&MediaFoundationClearKeyCdm::OnSessionKeysChange,
                            weak_factory_.GetWeakPtr()),
        base::DoNothing());  // AesDecryptor never calls this.
  }

  return aes_decryptor_;
}

void MediaFoundationClearKeyCdm::OnSessionMessage(
    const std::string& session_id,
    CdmMessageType message_type,
    const std::vector<uint8_t>& message) {
  DVLOG_FUNC(1) << "session_id=" << session_id
                << ", message_type=" << static_cast<int>(message_type);
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);

  auto* session = FindSession(session_id);
  CHECK(session);
  session->OnSessionMessage(session_id, message_type, message);
}

void MediaFoundationClearKeyCdm::OnSessionClosed(
    const std::string& session_id,
    CdmSessionClosedReason reason) {
  DVLOG_FUNC(1) << "session_id=" << session_id
                << ", reason=" << static_cast<int>(reason);
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);

  auto* session = FindSession(session_id);
  CHECK(session);
  session->OnSessionClosed(session_id, reason);
}

void MediaFoundationClearKeyCdm::OnSessionKeysChange(
    const std::string& session_id,
    bool has_additional_usable_key,
    CdmKeysInfo keys_info) {
  DVLOG_FUNC(1) << "session_id=" << session_id
                << ", has_additional_usable_key=" << has_additional_usable_key;
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);

  auto* session = FindSession(session_id);
  CHECK(session);
  session->OnSessionKeysChange(session_id, has_additional_usable_key,
                               std::move(keys_info));
}

void MediaFoundationClearKeyCdm::OnSessionIdCreated(
    const std::string& session_id,
    Microsoft::WRL::ComPtr<IMFContentDecryptionModuleSession> session) {
  DVLOG_FUNC(1) << "session_id=" << session_id;
  CHECK(FindSession(session_id) == nullptr);
  CHECK(session);

  sessions_.emplace(session_id, session);
}

void MediaFoundationClearKeyCdm::OnSessionIdRemoved(
    const std::string& session_id) {
  DVLOG_FUNC(1) << "session_id=" << session_id;
  auto it = sessions_.find(session_id);
  CHECK(it != sessions_.end());
  sessions_.erase(it);
}

MediaFoundationClearKeySession* MediaFoundationClearKeyCdm::FindSession(
    const std::string& session_id) {
  DVLOG_FUNC(3) << "session_id=" << session_id;
  auto it = sessions_.find(session_id);
  return it == sessions_.end()
             ? nullptr
             : static_cast<MediaFoundationClearKeySession*>(it->second.Get());
}

}  // namespace media