OmxPromiseLayer.h - mozsearch

Enable keyboard shortcuts

/* -*- 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/. */

#if !defined(OmxPromiseLayer_h_)

#  define OmxPromiseLayer_h_

#  include "mozilla/MozPromise.h"

#  include "mozilla/TaskQueue.h"

#  include "OMX_Core.h"

#  include "OMX_Types.h"

namespace mozilla {

namespace layers {

class ImageContainer;

class MediaData;

class MediaRawData;

class OmxDataDecoder;

class OmxPlatformLayer;

class TrackInfo;

/* This class acts as a middle layer between OmxDataDecoder and the underlying

 * OmxPlatformLayer.

 * This class has two purposes:

 * 1. Using promise instead of OpenMax async callback function.

 *    For example, OmxCommandPromise is used for OpenMax IL SendCommand.

 * 2. Manage the buffer exchanged between client and component.

 *    Because omx buffer works crossing threads, so each omx buffer has its own

 *    promise, it is defined in BufferData.

 * All of functions and members in this class should be run in the same

 * TaskQueue.

*/

class OmxPromiseLayer {

 protected:

  virtual ~OmxPromiseLayer() = default;

 public:

  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(OmxPromiseLayer)

  OmxPromiseLayer(TaskQueue* aTaskQueue, OmxDataDecoder* aDataDecoder,

                  layers::ImageContainer* aImageContainer);

  class BufferData;

  typedef nsTArray<RefPtr<BufferData>> BUFFERLIST;

  class OmxBufferFailureHolder {

   public:

    OmxBufferFailureHolder(OMX_ERRORTYPE aError, BufferData* aBuffer)

        : mError(aError), mBuffer(aBuffer) {}

    OMX_ERRORTYPE mError;

    BufferData* mBuffer;

};

  typedef MozPromise<BufferData*, OmxBufferFailureHolder,

                     /* IsExclusive = */ false>

      OmxBufferPromise;

  class OmxCommandFailureHolder {

   public:

    OmxCommandFailureHolder(OMX_ERRORTYPE aErrorType,

                            OMX_COMMANDTYPE aCommandType)

        : mErrorType(aErrorType), mCommandType(aCommandType) {}

    OMX_ERRORTYPE mErrorType;

    OMX_COMMANDTYPE mCommandType;

};

  typedef MozPromise<OMX_COMMANDTYPE, OmxCommandFailureHolder,

                     /* IsExclusive = */ true>

      OmxCommandPromise;

  typedef MozPromise<uint32_t, bool, /* IsExclusive = */ true>

      OmxPortConfigPromise;

  // TODO: maybe a generic promise is good enough for this case?

  RefPtr<OmxCommandPromise> Init(const TrackInfo* aInfo);

  OMX_ERRORTYPE Config();

  RefPtr<OmxBufferPromise> FillBuffer(BufferData* aData);

  RefPtr<OmxBufferPromise> EmptyBuffer(BufferData* aData);

  RefPtr<OmxCommandPromise> SendCommand(OMX_COMMANDTYPE aCmd, OMX_U32 aParam1,

                                        OMX_PTR aCmdData);

  nsresult AllocateOmxBuffer(OMX_DIRTYPE aType, BUFFERLIST* aBuffers);

  nsresult ReleaseOmxBuffer(OMX_DIRTYPE aType, BUFFERLIST* aBuffers);

  OMX_STATETYPE GetState();

  OMX_ERRORTYPE GetParameter(OMX_INDEXTYPE aParamIndex,

                             OMX_PTR aComponentParameterStructure,

                             OMX_U32 aComponentParameterSize);

  OMX_ERRORTYPE SetParameter(OMX_INDEXTYPE nIndex,

                             OMX_PTR aComponentParameterStructure,

                             OMX_U32 aComponentParameterSize);

  OMX_U32 InputPortIndex();

  OMX_U32 OutputPortIndex();

  nsresult Shutdown();

  // BufferData maintains the status of OMX buffer (OMX_BUFFERHEADERTYPE).

  // mStatus tracks the buffer owner.

  // And a promise because OMX buffer working among different threads.

  class BufferData {

   protected:

    virtual ~BufferData() = default;

   public:

    explicit BufferData(OMX_BUFFERHEADERTYPE* aBuffer)

        : mEos(false), mStatus(BufferStatus::FREE), mBuffer(aBuffer) {}

    typedef void* BufferID;

    NS_INLINE_DECL_THREADSAFE_REFCOUNTING(BufferData)

    // In most cases, the ID of this buffer is the pointer address of mBuffer.

    // However, on some platforms it may be another value.

    virtual BufferID ID() { return mBuffer; }

    // Return the platform dependent MediaData().

    // For example, it returns the MediaData with Gralloc texture.

    // If it returns nullptr, then caller uses the normal way to

    // create MediaData().

    virtual already_AddRefed<MediaData> GetPlatformMediaData() {

      return nullptr;

    // The buffer could be used by several objects. And only one object owns the

    // buffer the same time.

    //   FREE:

    //     nobody uses it.

//

    //   OMX_COMPONENT:

    //     buffer is used by OMX component (OmxPlatformLayer).

//

    //   OMX_CLIENT:

    //     buffer is used by client which is wait for audio/video playing

    //     (OmxDataDecoder)

//

    //   OMX_CLIENT_OUTPUT:

    //     used by client to output decoded data (for example, Gecko layer in

    //     this case)

//

    // For output port buffer, the status transition is:

    // FREE -> OMX_COMPONENT -> OMX_CLIENT -> OMX_CLIENT_OUTPUT -> FREE

//

    // For input port buffer, the status transition is:

    // FREE -> OMX_COMPONENT -> OMX_CLIENT -> FREE

//

    enum BufferStatus {

      FREE,

      OMX_COMPONENT,

      OMX_CLIENT,

      OMX_CLIENT_OUTPUT,

      INVALID

};

    bool mEos;

    // The raw keeps in OmxPromiseLayer after EmptyBuffer and then passing to

    // output decoded buffer in EmptyFillBufferDone. It is used to keep the

    // records of the original data from demuxer, like duration, stream

    // offset...etc.

    RefPtr<MediaRawData> mRawData;

    // Because OMX buffer works across threads, so it uses a promise

    // for each buffer when the buffer is used by Omx component.

    MozPromiseHolder<OmxBufferPromise> mPromise;

    BufferStatus mStatus;

    OMX_BUFFERHEADERTYPE* mBuffer;

};

  void EmptyFillBufferDone(OMX_DIRTYPE aType, BufferData::BufferID aID);

  void EmptyFillBufferDone(OMX_DIRTYPE aType, BufferData* aData);

  already_AddRefed<BufferData> FindBufferById(OMX_DIRTYPE aType,

                                              BufferData::BufferID aId);

  already_AddRefed<BufferData> FindAndRemoveBufferHolder(

      OMX_DIRTYPE aType, BufferData::BufferID aId);

  // Return true if event is handled.

  bool Event(OMX_EVENTTYPE aEvent, OMX_U32 aData1, OMX_U32 aData2);

 protected:

  struct FlushCommand {

    OMX_DIRTYPE type;

    OMX_PTR cmd;

};

  BUFFERLIST* GetBufferHolders(OMX_DIRTYPE aType);

  already_AddRefed<MediaRawData> FindAndRemoveRawData(OMX_TICKS aTimecode);

  RefPtr<TaskQueue> mTaskQueue;

  MozPromiseHolder<OmxCommandPromise> mCommandStatePromise;

  MozPromiseHolder<OmxCommandPromise> mPortDisablePromise;

  MozPromiseHolder<OmxCommandPromise> mPortEnablePromise;

  MozPromiseHolder<OmxCommandPromise> mFlushPromise;

  nsTArray<FlushCommand> mFlushCommands;

  UniquePtr<OmxPlatformLayer> mPlatformLayer;

 private:

  // Elements are added to holders when FillBuffer() or FillBuffer(). And

  // removing element when the promise is resolved. Buffers in these lists

  // should NOT be used by other component; for example, output it to audio

  // output. These lists should be empty when engine is about to shutdown.

//

  // Note:

  //      There bufferlist should not be used by other class directly.

  BUFFERLIST mInbufferHolders;

  BUFFERLIST mOutbufferHolders;

  nsTArray<RefPtr<MediaRawData>> mRawDatas;

};

}  // namespace mozilla

#endif /* OmxPromiseLayer_h_ */