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

#include "ImageContainer.h"

#include "OmxDataDecoder.h"

#include "OmxPlatformLayer.h"

#ifdef LOG

#undef LOG

#endif

#define LOG(arg, ...) MOZ_LOG(sPDMLog, mozilla::LogLevel::Debug, ("OmxPromiseLayer(%p)::%s: " arg, this, __func__, ##__VA_ARGS__))

namespace mozilla {

OmxPromiseLayer::OmxPromiseLayer(TaskQueue* aTaskQueue,

                                 OmxDataDecoder* aDataDecoder,

                                 layers::ImageContainer* aImageContainer)

  : mTaskQueue(aTaskQueue)

{

  mPlatformLayer = OmxPlatformLayer::Create(aDataDecoder,

                                            this,

                                            aTaskQueue,

                                            aImageContainer);

  MOZ_ASSERT(!!mPlatformLayer);

}

RefPtr<OmxPromiseLayer::OmxCommandPromise>

OmxPromiseLayer::Init(const TrackInfo* aInfo)

{

  MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn());

  OMX_ERRORTYPE err = mPlatformLayer->InitOmxToStateLoaded(aInfo);

  if (err != OMX_ErrorNone) {

    OmxCommandFailureHolder failure(OMX_ErrorUndefined, OMX_CommandStateSet);

    return OmxCommandPromise::CreateAndReject(failure, __func__);

  }

  OMX_STATETYPE state = GetState();

  if (state ==  OMX_StateLoaded) {

    return OmxCommandPromise::CreateAndResolve(OMX_CommandStateSet, __func__);

  } if (state == OMX_StateIdle) {

    return SendCommand(OMX_CommandStateSet, OMX_StateIdle, nullptr);

  }

  OmxCommandFailureHolder failure(OMX_ErrorUndefined, OMX_CommandStateSet);

  return OmxCommandPromise::CreateAndReject(failure, __func__);

}

OMX_ERRORTYPE

OmxPromiseLayer::Config()

{

  MOZ_ASSERT(GetState() == OMX_StateLoaded);

  return mPlatformLayer->Config();

}

RefPtr<OmxPromiseLayer::OmxBufferPromise>

OmxPromiseLayer::FillBuffer(BufferData* aData)

{

  MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn());

  LOG("buffer %p", aData->mBuffer);

  RefPtr<OmxBufferPromise> p = aData->mPromise.Ensure(__func__);

  OMX_ERRORTYPE err = mPlatformLayer->FillThisBuffer(aData);

  if (err != OMX_ErrorNone) {

    OmxBufferFailureHolder failure(err, aData);

    aData->mPromise.Reject(std::move(failure), __func__);

  } else {

    aData->mStatus = BufferData::BufferStatus::OMX_COMPONENT;

    GetBufferHolders(OMX_DirOutput)->AppendElement(aData);

  }

  return p;

}

RefPtr<OmxPromiseLayer::OmxBufferPromise>

OmxPromiseLayer::EmptyBuffer(BufferData* aData)

{

  MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn());

  LOG("buffer %p, size %lu", aData->mBuffer, aData->mBuffer->nFilledLen);

  RefPtr<OmxBufferPromise> p = aData->mPromise.Ensure(__func__);

  OMX_ERRORTYPE err = mPlatformLayer->EmptyThisBuffer(aData);

  if (err != OMX_ErrorNone) {

    OmxBufferFailureHolder failure(err, aData);

    aData->mPromise.Reject(std::move(failure), __func__);

  } else {

    if (aData->mRawData) {

      mRawDatas.AppendElement(std::move(aData->mRawData));

    }

    aData->mStatus = BufferData::BufferStatus::OMX_COMPONENT;

    GetBufferHolders(OMX_DirInput)->AppendElement(aData);

  }

  return p;

}

OmxPromiseLayer::BUFFERLIST*

OmxPromiseLayer::GetBufferHolders(OMX_DIRTYPE aType)

{

  MOZ_ASSERT(aType == OMX_DirInput || aType == OMX_DirOutput);

  if (aType == OMX_DirInput) {

    return &mInbufferHolders;

  }

  return &mOutbufferHolders;

}

already_AddRefed<MediaRawData>

OmxPromiseLayer::FindAndRemoveRawData(OMX_TICKS aTimecode)

{

  for (auto raw : mRawDatas) {

    if (raw->mTime.ToMicroseconds() == aTimecode) {

      mRawDatas.RemoveElement(raw);

      return raw.forget();

    }

  }

  return nullptr;

}

already_AddRefed<BufferData>

OmxPromiseLayer::FindAndRemoveBufferHolder(OMX_DIRTYPE aType,

                                           BufferData::BufferID aId)

{

  MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn());

  RefPtr<BufferData> holder;

  BUFFERLIST* holders = GetBufferHolders(aType);

  for (uint32_t i = 0; i < holders->Length(); i++) {

    if (holders->ElementAt(i)->ID() == aId) {

      holder = holders->ElementAt(i);

      holders->RemoveElementAt(i);

      return holder.forget();

    }

  }

  return nullptr;

}

already_AddRefed<BufferData>

OmxPromiseLayer::FindBufferById(OMX_DIRTYPE aType, BufferData::BufferID aId)

{

  MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn());

  RefPtr<BufferData> holder;

  BUFFERLIST* holders = GetBufferHolders(aType);

  for (uint32_t i = 0; i < holders->Length(); i++) {

    if (holders->ElementAt(i)->ID() == aId) {

      holder = holders->ElementAt(i);

      return holder.forget();

    }

  }

  return nullptr;

}

void

OmxPromiseLayer::EmptyFillBufferDone(OMX_DIRTYPE aType, BufferData* aData)

{

  if (aData) {

    LOG("type %d, buffer %p", aType, aData->mBuffer);

    if (aType == OMX_DirOutput) {

      aData->mRawData = nullptr;

      aData->mRawData = FindAndRemoveRawData(aData->mBuffer->nTimeStamp);

    }

    aData->mStatus = BufferData::BufferStatus::OMX_CLIENT;

    aData->mPromise.Resolve(aData, __func__);

  } else {

    LOG("type %d, no buffer", aType);

  }

}

void

OmxPromiseLayer::EmptyFillBufferDone(OMX_DIRTYPE aType, BufferData::BufferID aID)

{

  RefPtr<BufferData> holder = FindAndRemoveBufferHolder(aType, aID);

  EmptyFillBufferDone(aType, holder);

}

RefPtr<OmxPromiseLayer::OmxCommandPromise>

OmxPromiseLayer::SendCommand(OMX_COMMANDTYPE aCmd, OMX_U32 aParam1, OMX_PTR aCmdData)

{

  if (aCmd == OMX_CommandFlush) {

    // It doesn't support another flush commands before previous one is completed.

    MOZ_RELEASE_ASSERT(!mFlushCommands.Length());

    // Some coomponents don't send event with OMX_ALL, they send flush complete

    // event with input port and another event for output port.

    // In prupose of better compatibility, we interpret the OMX_ALL to OMX_DirInput

    // and OMX_DirOutput flush separately.

    OMX_DIRTYPE types[] = {OMX_DIRTYPE::OMX_DirInput, OMX_DIRTYPE::OMX_DirOutput};

    for(const auto type : types) {

      if ((aParam1 == type) || (aParam1 == OMX_ALL)) {

        mFlushCommands.AppendElement(FlushCommand({type, aCmdData}));

      }

      if (type == OMX_DirInput) {

        // Clear all buffered raw data.

        mRawDatas.Clear();

      }

    }

    // Don't overlay more than one flush command, some components can't overlay flush commands.

    // So here we send another flush after receiving the previous flush completed event.

    if (mFlushCommands.Length()) {

      OMX_ERRORTYPE err =

        mPlatformLayer->SendCommand(OMX_CommandFlush,

                                    mFlushCommands.ElementAt(0).type,

                                    mFlushCommands.ElementAt(0).cmd);

      if (err != OMX_ErrorNone) {

        OmxCommandFailureHolder failure(OMX_ErrorNotReady, OMX_CommandFlush);

        return OmxCommandPromise::CreateAndReject(failure, __func__);

      }

    } else {

      LOG("OMX_CommandFlush parameter error");

      OmxCommandFailureHolder failure(OMX_ErrorNotReady, OMX_CommandFlush);

      return OmxCommandPromise::CreateAndReject(failure, __func__);

    }

  } else {

    OMX_ERRORTYPE err = mPlatformLayer->SendCommand(aCmd, aParam1, aCmdData);

    if (err != OMX_ErrorNone) {

      OmxCommandFailureHolder failure(OMX_ErrorNotReady, aCmd);

      return OmxCommandPromise::CreateAndReject(failure, __func__);

    }

  }

  RefPtr<OmxCommandPromise> p;

  if (aCmd == OMX_CommandStateSet) {

    p = mCommandStatePromise.Ensure(__func__);

  } else if (aCmd == OMX_CommandFlush) {

    p = mFlushPromise.Ensure(__func__);

  } else if (aCmd == OMX_CommandPortEnable) {

    p = mPortEnablePromise.Ensure(__func__);

  } else if (aCmd == OMX_CommandPortDisable) {

    p = mPortDisablePromise.Ensure(__func__);

  } else {

    LOG("error unsupport command");

    MOZ_ASSERT(0);

  }

  return p;

}

bool

OmxPromiseLayer::Event(OMX_EVENTTYPE aEvent, OMX_U32 aData1, OMX_U32 aData2)

{

  OMX_COMMANDTYPE cmd = (OMX_COMMANDTYPE) aData1;

  switch (aEvent) {

    case OMX_EventCmdComplete:

    {

      if (cmd == OMX_CommandStateSet) {

        mCommandStatePromise.Resolve(OMX_CommandStateSet, __func__);

      } else if (cmd == OMX_CommandFlush) {

        MOZ_RELEASE_ASSERT(mFlushCommands.ElementAt(0).type == aData2);

        LOG("OMX_CommandFlush completed port type %lu", aData2);

        mFlushCommands.RemoveElementAt(0);

        // Sending next flush command.

        if (mFlushCommands.Length()) {

          OMX_ERRORTYPE err =

            mPlatformLayer->SendCommand(OMX_CommandFlush,

                                        mFlushCommands.ElementAt(0).type,

                                        mFlushCommands.ElementAt(0).cmd);

          if (err != OMX_ErrorNone) {

            OmxCommandFailureHolder failure(OMX_ErrorNotReady, OMX_CommandFlush);

            mFlushPromise.Reject(failure, __func__);

          }

        } else {

          mFlushPromise.Resolve(OMX_CommandFlush, __func__);

        }

      } else if (cmd == OMX_CommandPortDisable) {

        mPortDisablePromise.Resolve(OMX_CommandPortDisable, __func__);

      } else if (cmd == OMX_CommandPortEnable) {

        mPortEnablePromise.Resolve(OMX_CommandPortEnable, __func__);

      }

      break;

    }

    case OMX_EventError:

    {

      if (cmd == OMX_CommandStateSet) {

        OmxCommandFailureHolder failure(OMX_ErrorUndefined, OMX_CommandStateSet);

        mCommandStatePromise.Reject(failure, __func__);

      } else if (cmd == OMX_CommandFlush) {

        OmxCommandFailureHolder failure(OMX_ErrorUndefined, OMX_CommandFlush);

        mFlushPromise.Reject(failure, __func__);

      } else if (cmd == OMX_CommandPortDisable) {

        OmxCommandFailureHolder failure(OMX_ErrorUndefined, OMX_CommandPortDisable);

        mPortDisablePromise.Reject(failure, __func__);

      } else if (cmd == OMX_CommandPortEnable) {

        OmxCommandFailureHolder failure(OMX_ErrorUndefined, OMX_CommandPortEnable);

        mPortEnablePromise.Reject(failure, __func__);

      } else {

        return false;

      }

      break;

    }

    default:

    {

      return false;

    }

  }

  return true;

}

nsresult

OmxPromiseLayer::AllocateOmxBuffer(OMX_DIRTYPE aType, BUFFERLIST* aBuffers)

{

  return mPlatformLayer->AllocateOmxBuffer(aType, aBuffers);

}

nsresult

OmxPromiseLayer::ReleaseOmxBuffer(OMX_DIRTYPE aType, BUFFERLIST* aBuffers)

{

  return mPlatformLayer->ReleaseOmxBuffer(aType, aBuffers);

}

OMX_STATETYPE

OmxPromiseLayer::GetState()

{

  OMX_STATETYPE state;

  OMX_ERRORTYPE err = mPlatformLayer->GetState(&state);

  return err == OMX_ErrorNone ? state : OMX_StateInvalid;

}

OMX_ERRORTYPE

OmxPromiseLayer::GetParameter(OMX_INDEXTYPE aParamIndex,

                              OMX_PTR aComponentParameterStructure,

                              OMX_U32 aComponentParameterSize)

{

  return mPlatformLayer->GetParameter(aParamIndex,

                                      aComponentParameterStructure,

                                      aComponentParameterSize);

}

OMX_ERRORTYPE

OmxPromiseLayer::SetParameter(OMX_INDEXTYPE aParamIndex,

                              OMX_PTR aComponentParameterStructure,

                              OMX_U32 aComponentParameterSize)

{

  return mPlatformLayer->SetParameter(aParamIndex,

                                      aComponentParameterStructure,

                                      aComponentParameterSize);

}

OMX_U32

OmxPromiseLayer::InputPortIndex()

{

  return mPlatformLayer->InputPortIndex();

}

OMX_U32

OmxPromiseLayer::OutputPortIndex()

{

  return mPlatformLayer->OutputPortIndex();

}

nsresult

OmxPromiseLayer::Shutdown()

{

  LOG("");

  MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn());

  MOZ_ASSERT(!GetBufferHolders(OMX_DirInput)->Length());

  MOZ_ASSERT(!GetBufferHolders(OMX_DirOutput)->Length());

  return mPlatformLayer->Shutdown();

}

}