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

/* vim:set ts=2 sw=2 sts=2 et cindent: */

/* 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 "AllocationPolicy.h"

#include "PDMFactory.h"

#include "MediaInfo.h"

#include "mozilla/ClearOnShutdown.h"

#include "mozilla/SystemGroup.h"

#ifdef MOZ_WIDGET_ANDROID

#include "mozilla/jni/Utils.h"

#endif

namespace mozilla {

using TrackType = TrackInfo::TrackType;

StaticMutex GlobalAllocPolicy::sMutex;

class GlobalAllocPolicy::AutoDeallocToken : public Token

{

public:

  explicit AutoDeallocToken(GlobalAllocPolicy& aPolicy) : mPolicy(aPolicy) { }

private:

  ~AutoDeallocToken()

  {

    mPolicy.Dealloc();

  }

  GlobalAllocPolicy& mPolicy; // reference to a singleton object.

};

static int32_t

MediaDecoderLimitDefault()

{

#ifdef MOZ_WIDGET_ANDROID

  if (jni::GetAPIVersion() < 18) {

    // Older Android versions have broken support for multiple simultaneous

    // decoders, see bug 1278574.

    return 1;

  }

#endif

  // Otherwise, set no decoder limit.

  return -1;

}

GlobalAllocPolicy::GlobalAllocPolicy()

  : mMonitor("DecoderAllocPolicy::mMonitor")

  , mDecoderLimit(MediaDecoderLimitDefault())

{

  SystemGroup::Dispatch(

    TaskCategory::Other,

    NS_NewRunnableFunction("GlobalAllocPolicy::GlobalAllocPolicy", [this]() {

      ClearOnShutdown(this, ShutdownPhase::ShutdownThreads);

    }));

}

GlobalAllocPolicy::~GlobalAllocPolicy()

{

  while (!mPromises.empty()) {

    RefPtr<PromisePrivate> p = mPromises.front().forget();

    mPromises.pop();

    p->Reject(true, __func__);

  }

}

GlobalAllocPolicy&

GlobalAllocPolicy::Instance(TrackType aTrack)

{

  StaticMutexAutoLock lock(sMutex);

  if (aTrack == TrackType::kAudioTrack) {

    static auto sAudioPolicy = new GlobalAllocPolicy();

    return *sAudioPolicy;

  } else {

    static auto sVideoPolicy = new GlobalAllocPolicy();

    return *sVideoPolicy;

  }

}

auto

GlobalAllocPolicy::Alloc() -> RefPtr<Promise>

{

  // No decoder limit set.

  if (mDecoderLimit < 0) {

    return Promise::CreateAndResolve(new Token(), __func__);

  }

  ReentrantMonitorAutoEnter mon(mMonitor);

  RefPtr<PromisePrivate> p = new PromisePrivate(__func__);

  mPromises.push(p);

  ResolvePromise(mon);

  return p.forget();

}

void

GlobalAllocPolicy::Dealloc()

{

  ReentrantMonitorAutoEnter mon(mMonitor);

  ++mDecoderLimit;

  ResolvePromise(mon);

}

void

GlobalAllocPolicy::ResolvePromise(ReentrantMonitorAutoEnter& aProofOfLock)

{

  MOZ_ASSERT(mDecoderLimit >= 0);

  if (mDecoderLimit > 0 && !mPromises.empty()) {

    --mDecoderLimit;

    RefPtr<PromisePrivate> p = mPromises.front().forget();

    mPromises.pop();

    p->Resolve(new AutoDeallocToken(*this), __func__);

  }

}

void

GlobalAllocPolicy::operator=(std::nullptr_t)

{

  delete this;

}

AllocationWrapper::AllocationWrapper(

  already_AddRefed<MediaDataDecoder> aDecoder,

  already_AddRefed<Token> aToken)

  : mDecoder(aDecoder)

  , mToken(aToken)

{

  DecoderDoctorLogger::LogConstructionAndBase(

    "AllocationWrapper", this, static_cast<const MediaDataDecoder*>(this));

  DecoderDoctorLogger::LinkParentAndChild(

    "AllocationWrapper", this, "decoder", mDecoder.get());

}

AllocationWrapper::~AllocationWrapper()

{

  DecoderDoctorLogger::LogDestruction("AllocationWrapper", this);

}

RefPtr<ShutdownPromise>

AllocationWrapper::Shutdown()

{

  RefPtr<MediaDataDecoder> decoder = mDecoder.forget();

  RefPtr<Token> token = mToken.forget();

  return decoder->Shutdown()->Then(

    AbstractThread::GetCurrent(), __func__, [token]() {

      return ShutdownPromise::CreateAndResolve(true, __func__);

    });

}

/* static */ RefPtr<AllocationWrapper::AllocateDecoderPromise>

AllocationWrapper::CreateDecoder(const CreateDecoderParams& aParams)

{

  // aParams.mConfig is guaranteed to stay alive during the lifetime of the

  // MediaDataDecoder, so keeping a pointer to the object is safe.

  const TrackInfo* config = &aParams.mConfig;

  RefPtr<TaskQueue> taskQueue = aParams.mTaskQueue;

  DecoderDoctorDiagnostics* diagnostics = aParams.mDiagnostics;

  RefPtr<layers::ImageContainer> imageContainer = aParams.mImageContainer;

  RefPtr<layers::KnowsCompositor> knowsCompositor = aParams.mKnowsCompositor;

  RefPtr<GMPCrashHelper> crashHelper = aParams.mCrashHelper;

  CreateDecoderParams::UseNullDecoder useNullDecoder = aParams.mUseNullDecoder;

  CreateDecoderParams::NoWrapper noWrapper = aParams.mNoWrapper;

  TrackInfo::TrackType type = aParams.mType;

  MediaEventProducer<TrackInfo::TrackType>* onWaitingForKeyEvent =

    aParams.mOnWaitingForKeyEvent;

  CreateDecoderParams::OptionSet options = aParams.mOptions;

  CreateDecoderParams::VideoFrameRate rate = aParams.mRate;

  RefPtr<AllocateDecoderPromise> p =

    GlobalAllocPolicy::Instance(aParams.mType)

      .Alloc()

      ->Then(

        AbstractThread::GetCurrent(),

        __func__,

        [=](RefPtr<Token> aToken) {

          // result may not always be updated by PDMFactory::CreateDecoder

          // either when the creation succeeded or failed, as such it must be

          // initialized to a fatal error by default.

          MediaResult result = MediaResult(

            NS_ERROR_DOM_MEDIA_FATAL_ERR,

            nsPrintfCString("error creating %s decoder", TrackTypeToStr(type)));

          RefPtr<PDMFactory> pdm = new PDMFactory();

          CreateDecoderParams params{ *config,

                                      taskQueue,

                                      diagnostics,

                                      imageContainer,

                                      &result,

                                      knowsCompositor,

                                      crashHelper,

                                      useNullDecoder,

                                      noWrapper,

                                      type,

                                      onWaitingForKeyEvent,

                                      options,

                                      rate };

          RefPtr<MediaDataDecoder> decoder = pdm->CreateDecoder(params);

          if (decoder) {

            RefPtr<AllocationWrapper> wrapper =

              new AllocationWrapper(decoder.forget(), aToken.forget());

            return AllocateDecoderPromise::CreateAndResolve(wrapper, __func__);

          }

          return AllocateDecoderPromise::CreateAndReject(result, __func__);

        },

        []() {

          return AllocateDecoderPromise::CreateAndReject(

            MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR,

                        "Allocation policy expired"),

            __func__);

        });

  return p;

}

} // namespace mozilla