/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "GMPContentChild.h"

#include "GMPChild.h"

#include "GMPVideoDecoderChild.h"

#include "GMPVideoEncoderChild.h"

#include "ChromiumCDMChild.h"

#include "base/task.h"

#include "GMPUtils.h"

namespace mozilla {

namespace gmp {

GMPContentChild::GMPContentChild(GMPChild* aChild)

  : mGMPChild(aChild)

{

  MOZ_COUNT_CTOR(GMPContentChild);

}

GMPContentChild::~GMPContentChild()

{

  MOZ_COUNT_DTOR(GMPContentChild);

}

MessageLoop*

GMPContentChild::GMPMessageLoop()

{

  return mGMPChild->GMPMessageLoop();

}

void

GMPContentChild::CheckThread()

{

  MOZ_ASSERT(mGMPChild->mGMPMessageLoop == MessageLoop::current());

}

void

GMPContentChild::ActorDestroy(ActorDestroyReason aWhy)

{

  mGMPChild->GMPContentChildActorDestroy(this);

}

void

GMPContentChild::ProcessingError(Result aCode, const char* aReason)

{

  mGMPChild->ProcessingError(aCode, aReason);

}

PGMPVideoDecoderChild*

GMPContentChild::AllocPGMPVideoDecoderChild(const uint32_t& aDecryptorId)

{

  GMPVideoDecoderChild* actor = new GMPVideoDecoderChild(this);

  actor->AddRef();

  return actor;

}

bool

GMPContentChild::DeallocPGMPVideoDecoderChild(PGMPVideoDecoderChild* aActor)

{

  static_cast<GMPVideoDecoderChild*>(aActor)->Release();

  return true;

}

PGMPVideoEncoderChild*

GMPContentChild::AllocPGMPVideoEncoderChild()

{

  GMPVideoEncoderChild* actor = new GMPVideoEncoderChild(this);

  actor->AddRef();

  return actor;

}

bool

GMPContentChild::DeallocPGMPVideoEncoderChild(PGMPVideoEncoderChild* aActor)

{

  static_cast<GMPVideoEncoderChild*>(aActor)->Release();

  return true;

}

PChromiumCDMChild*

GMPContentChild::AllocPChromiumCDMChild()

{

  ChromiumCDMChild* actor = new ChromiumCDMChild(this);

  actor->AddRef();

  return actor;

}

bool

GMPContentChild::DeallocPChromiumCDMChild(PChromiumCDMChild* aActor)

{

  static_cast<ChromiumCDMChild*>(aActor)->Release();

  return true;

}

mozilla::ipc::IPCResult

GMPContentChild::RecvPGMPVideoDecoderConstructor(PGMPVideoDecoderChild* aActor,

                                                 const uint32_t& aDecryptorId)

{

  auto vdc = static_cast<GMPVideoDecoderChild*>(aActor);

  void* vd = nullptr;

  GMPErr err = mGMPChild->GetAPI(GMP_API_VIDEO_DECODER, &vdc->Host(), &vd, aDecryptorId);

  if (err != GMPNoErr || !vd) {

    NS_WARNING("GMPGetAPI call failed trying to construct decoder.");

    return IPC_FAIL_NO_REASON(this);

  }

  vdc->Init(static_cast<GMPVideoDecoder*>(vd));

  return IPC_OK();

}

mozilla::ipc::IPCResult

GMPContentChild::RecvPGMPVideoEncoderConstructor(PGMPVideoEncoderChild* aActor)

{

  auto vec = static_cast<GMPVideoEncoderChild*>(aActor);

  void* ve = nullptr;

  GMPErr err = mGMPChild->GetAPI(GMP_API_VIDEO_ENCODER, &vec->Host(), &ve);

  if (err != GMPNoErr || !ve) {

    NS_WARNING("GMPGetAPI call failed trying to construct encoder.");

    return IPC_FAIL_NO_REASON(this);

  }

  vec->Init(static_cast<GMPVideoEncoder*>(ve));

  return IPC_OK();

}

// Convert CDM10 calls to CDM9 calls, massage args where needed

class ChromiumCDM9BackwardsCompat : public cdm::ContentDecryptionModule_10

{

public:

  explicit ChromiumCDM9BackwardsCompat(cdm::Host_10* aHost,

                                       cdm::ContentDecryptionModule_9* aCDM)

    : mCDM(aCDM)

    , mHost(aHost)

  {

  }

  void Initialize(bool aAllowDistinctiveIdentifier,

                  bool aAllowPersistentState,

                  bool /* aUseHardwareSecureCodec */) override

  {

    // aUseHardwareSecureCodec is not used by CDM9

    mCDM->Initialize(aAllowDistinctiveIdentifier, aAllowPersistentState);

  }

  void GetStatusForPolicy(uint32_t aPromiseId,

                          const cdm::Policy& policy) override

  {

    mCDM->GetStatusForPolicy(aPromiseId, policy);

  }

  void SetServerCertificate(uint32_t aPromiseId,

                            const uint8_t* aServerCertificateData,

                            uint32_t aServerCertificateDataSize) override

  {

    mCDM->SetServerCertificate(

      aPromiseId, aServerCertificateData, aServerCertificateDataSize);

  }

  void CreateSessionAndGenerateRequest(uint32_t aPromiseId,

                                       cdm::SessionType aSessionType,

                                       cdm::InitDataType aInitDataType,

                                       const uint8_t* aInitData,

                                       uint32_t aInitDataSize) override

  {

    mCDM->CreateSessionAndGenerateRequest(

      aPromiseId, aSessionType, aInitDataType, aInitData, aInitDataSize);

  }

  void LoadSession(uint32_t aPromiseId,

                   cdm::SessionType aSessionType,

                   const char* aSessionId,

                   uint32_t aSessionIdSize) override

  {

    mCDM->LoadSession(aPromiseId, aSessionType, aSessionId, aSessionIdSize);

  }

  void UpdateSession(uint32_t aPromiseId,

                     const char* aSessionId,

                     uint32_t aSessionIdSize,

                     const uint8_t* aResponse,

                     uint32_t aResponseSize) override

  {

    mCDM->UpdateSession(

      aPromiseId, aSessionId, aSessionIdSize, aResponse, aResponseSize);

  }

  void CloseSession(uint32_t aPromiseId,

                    const char* aSessionId,

                    uint32_t aSessionIdSize) override

  {

    mCDM->CloseSession(aPromiseId, aSessionId, aSessionIdSize);

  }

  void RemoveSession(uint32_t aPromiseId,

                     const char* aSessionId,

                     uint32_t aSessionIdSize) override

  {

    mCDM->RemoveSession(aPromiseId, aSessionId, aSessionIdSize);

  }

  void TimerExpired(void* aContext) override { mCDM->TimerExpired(aContext); }

  cdm::Status Decrypt(const cdm::InputBuffer_2& aEncryptedBuffer,

                      cdm::DecryptedBlock* aDecryptedBuffer) override

  {

    // Handle possible encryption mismatch

    if (!IsEncryptionSchemeSupported(aEncryptedBuffer.encryption_scheme)) {

      return cdm::Status::kDecryptError;

    }

    return mCDM->Decrypt(ConvertToInputBuffer_1(aEncryptedBuffer),

                         aDecryptedBuffer);

  }

  cdm::Status InitializeAudioDecoder(

    const cdm::AudioDecoderConfig_2& aAudioDecoderConfig) override

  {

    // Handle possible encryption mismatch

    if (!IsEncryptionSchemeSupported(aAudioDecoderConfig.encryption_scheme)) {

      return cdm::Status::kInitializationError;

    }

    return mCDM->InitializeAudioDecoder(

      ConverToAudioDecoderConfig_1(aAudioDecoderConfig));

  }

  cdm::Status InitializeVideoDecoder(

    const cdm::VideoDecoderConfig_2& aVideoDecoderConfig) override

  {

    // Handle possible encryption mismatch

    if (!IsEncryptionSchemeSupported(aVideoDecoderConfig.encryption_scheme)) {

      return cdm::Status::kInitializationError;

    }

    return mCDM->InitializeVideoDecoder(

      ConvertToVideoDecoderConfig_1(aVideoDecoderConfig));

  }

  void DeinitializeDecoder(cdm::StreamType aDecoderType) override

  {

    mCDM->DeinitializeDecoder(aDecoderType);

  }

  void ResetDecoder(cdm::StreamType aDecoderType) override

  {

    mCDM->ResetDecoder(aDecoderType);

  }

  cdm::Status DecryptAndDecodeFrame(const cdm::InputBuffer_2& aEncryptedBuffer,

                                    cdm::VideoFrame* aVideoFrame) override

  {

    // Handle possible encryption mismatch

    if (!IsEncryptionSchemeSupported(aEncryptedBuffer.encryption_scheme)) {

      return cdm::Status::kDecryptError;

    }

    return mCDM->DecryptAndDecodeFrame(ConvertToInputBuffer_1(aEncryptedBuffer),

                                       aVideoFrame);

  }

  cdm::Status DecryptAndDecodeSamples(

    const cdm::InputBuffer_2& aEncryptedBuffer,

    cdm::AudioFrames* aAudioFrames) override

  {

    // Handle possible encryption mismatch

    if (!IsEncryptionSchemeSupported(aEncryptedBuffer.encryption_scheme)) {

      return cdm::Status::kDecryptError;

    }

    return mCDM->DecryptAndDecodeSamples(

      ConvertToInputBuffer_1(aEncryptedBuffer), aAudioFrames);

  }

  void OnPlatformChallengeResponse(

    const cdm::PlatformChallengeResponse& aResponse) override

  {

    mCDM->OnPlatformChallengeResponse(aResponse);

  }

  void OnQueryOutputProtectionStatus(cdm::QueryResult aResult,

                                     uint32_t aLinkMask,

                                     uint32_t aOutputProtectionMask) override

  {

    mCDM->OnQueryOutputProtectionStatus(

      aResult, aLinkMask, aOutputProtectionMask);

  }

  void OnStorageId(uint32_t aVersion,

                   const uint8_t* aStorageId,

                   uint32_t aStorageIdSize) override

  {

    mCDM->OnStorageId(aVersion, aStorageId, aStorageIdSize);

  }

  void Destroy() override

  {

    mCDM->Destroy();

    delete this;

  }

  cdm::ContentDecryptionModule_9* mCDM;

  cdm::Host_10* mHost;

private:

  // CDM9 supports non-encrypted or cenc encrypted media, anything else should

  // be rejected.

  static bool IsEncryptionSchemeSupported(

    const cdm::EncryptionScheme& aEncryptionScheme)

  {

    return aEncryptionScheme == cdm::EncryptionScheme::kUnencrypted ||

           aEncryptionScheme == cdm::EncryptionScheme::kCenc;

  }

  // Conversion functions that drop the encryption scheme member. CDMs prior to

  // 10 assumed no encryption or cenc encryption (if encryption is present). So

  // we can drop the scheme member if we check to make sure it was one of these

  // two options.

  static cdm::InputBuffer_1 ConvertToInputBuffer_1(

    const cdm::InputBuffer_2& aInputBuffer)

  {

    MOZ_ASSERT(

      IsEncryptionSchemeSupported(aInputBuffer.encryption_scheme),

      "Encryption scheme should be checked before attempting conversion!");

    return { aInputBuffer.data,       aInputBuffer.data_size,

             aInputBuffer.key_id,     aInputBuffer.key_id_size,

             aInputBuffer.iv,         aInputBuffer.iv_size,

             aInputBuffer.subsamples, aInputBuffer.num_subsamples,

             aInputBuffer.timestamp };

  }

  static cdm::AudioDecoderConfig_1 ConverToAudioDecoderConfig_1(

    const cdm::AudioDecoderConfig_2& aAudioConfig)

  {

    MOZ_ASSERT(

      IsEncryptionSchemeSupported(aAudioConfig.encryption_scheme),

      "Encryption scheme should be checked before attempting conversion!");

    return { aAudioConfig.codec,

             aAudioConfig.channel_count,

             aAudioConfig.bits_per_channel,

             aAudioConfig.samples_per_second,

             aAudioConfig.extra_data,

             aAudioConfig.extra_data_size };

  }

  static cdm::VideoDecoderConfig_1 ConvertToVideoDecoderConfig_1(

    const cdm::VideoDecoderConfig_2& aVideoConfig)

  {

    MOZ_ASSERT(

      IsEncryptionSchemeSupported(aVideoConfig.encryption_scheme),

      "Encryption scheme should be checked before attempting conversion!");

    return { aVideoConfig.codec,      aVideoConfig.profile,

             aVideoConfig.format,     aVideoConfig.coded_size,

             aVideoConfig.extra_data, aVideoConfig.extra_data_size };

  }

}; // class ChromiumCDM9BackwardsCompat

mozilla::ipc::IPCResult

GMPContentChild::RecvPChromiumCDMConstructor(PChromiumCDMChild* aActor)

{

  ChromiumCDMChild* child = static_cast<ChromiumCDMChild*>(aActor);

  // TODO: Once we support CDM10, create one here, for now try and create CDM9

  cdm::Host_9* host9 = child;

  void* cdm = nullptr;

  GMPErr err = mGMPChild->GetAPI(CHROMIUM_CDM_API_BACKWARD_COMPAT, host9, &cdm);

  if (err != GMPNoErr || !cdm) {

    NS_WARNING("GMPGetAPI call failed trying to get CDM.");

    return IPC_FAIL_NO_REASON(this);

  }

  cdm::Host_10* host10 = child;

  cdm = new ChromiumCDM9BackwardsCompat(

    host10, static_cast<cdm::ContentDecryptionModule_9*>(cdm));

  child->Init(static_cast<cdm::ContentDecryptionModule_10*>(cdm),

              mGMPChild->mStorageId);

  return IPC_OK();

}

void

GMPContentChild::CloseActive()

{

  // Invalidate and remove any remaining API objects.

  const ManagedContainer<PGMPVideoDecoderChild>& videoDecoders =

    ManagedPGMPVideoDecoderChild();

  for (auto iter = videoDecoders.ConstIter(); !iter.Done(); iter.Next()) {

    iter.Get()->GetKey()->SendShutdown();

  }

  const ManagedContainer<PGMPVideoEncoderChild>& videoEncoders =

    ManagedPGMPVideoEncoderChild();

  for (auto iter = videoEncoders.ConstIter(); !iter.Done(); iter.Next()) {

    iter.Get()->GetKey()->SendShutdown();

  }

  const ManagedContainer<PChromiumCDMChild>& cdms = ManagedPChromiumCDMChild();

  for (auto iter = cdms.ConstIter(); !iter.Done(); iter.Next()) {

    iter.Get()->GetKey()->SendShutdown();

  }

}

bool

GMPContentChild::IsUsed()

{

  return !ManagedPGMPVideoDecoderChild().IsEmpty() ||

         !ManagedPGMPVideoEncoderChild().IsEmpty() ||

         !ManagedPChromiumCDMChild().IsEmpty();

}

} // namespace gmp

} // namespace mozilla