tor-browser

OmxPromiseLayer.h (7516B)

---

/* -*- 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 "OMX_Core.h"
#  include "OMX_Types.h"
#  include "mozilla/MozPromise.h"
#  include "mozilla/TaskQueue.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_ */