gfx/layers/AndroidHardwareBuffer.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef MOZILLA_LAYERS_ANDROID_HARDWARE_BUFFER
   8 #define MOZILLA_LAYERS_ANDROID_HARDWARE_BUFFER
   9
  10 #include <android/hardware_buffer.h>
  11 #include <atomic>
  12 #include <unordered_map>
  13
  14 #include "mozilla/layers/TextureClient.h"
  15 #include "mozilla/gfx/Types.h"
  16 #include "mozilla/gfx/2D.h"
  17 #include "mozilla/Monitor.h"
  18 #include "mozilla/RefPtr.h"
  19 #include "mozilla/StaticPtr.h"
  20 #include "mozilla/ThreadSafeWeakPtr.h"
  21
  22 namespace mozilla {
  23 namespace layers {
  24
  25 /**
  26  * AndroidHardwareBufferApi provides apis for managing AHardwareBuffer.
  27  * The apis are supported since Android O(APIVersion 26).
  28  */
  29 class AndroidHardwareBufferApi final {
  30  public:
  31   static void Init();
  32   static void Shutdown();
  33
  34   static AndroidHardwareBufferApi* Get() { return sInstance; }
  35
  36   void Allocate(const AHardwareBuffer_Desc* aDesc,
  37                 AHardwareBuffer** aOutBuffer);
  38   void Acquire(AHardwareBuffer* aBuffer);
  39   void Release(AHardwareBuffer* aBuffer);
  40   void Describe(const AHardwareBuffer* aBuffer, AHardwareBuffer_Desc* aOutDesc);
  41   int Lock(AHardwareBuffer* aBuffer, uint64_t aUsage, int32_t aFence,
  42            const ARect* aRect, void** aOutVirtualAddress);
  43   int Unlock(AHardwareBuffer* aBuffer, int32_t* aFence);
  44   int SendHandleToUnixSocket(const AHardwareBuffer* aBuffer, int aSocketFd);
  45   int RecvHandleFromUnixSocket(int aSocketFd, AHardwareBuffer** aOutBuffer);
  46
  47  private:
  48   AndroidHardwareBufferApi();
  49   bool Load();
  50
  51   using _AHardwareBuffer_allocate = int (*)(const AHardwareBuffer_Desc* desc,
  52                                             AHardwareBuffer** outBuffer);
  53   using _AHardwareBuffer_acquire = void (*)(AHardwareBuffer* buffer);
  54   using _AHardwareBuffer_release = void (*)(AHardwareBuffer* buffer);
  55   using _AHardwareBuffer_describe = void (*)(const AHardwareBuffer* buffer,
  56                                              AHardwareBuffer_Desc* outDesc);
  57   using _AHardwareBuffer_lock = int (*)(AHardwareBuffer* buffer, uint64_t usage,
  58                                         int32_t fence, const ARect* rect,
  59                                         void** outVirtualAddress);
  60   using _AHardwareBuffer_unlock = int (*)(AHardwareBuffer* buffer,
  61                                           int32_t* fence);
  62   using _AHardwareBuffer_sendHandleToUnixSocket =
  63       int (*)(const AHardwareBuffer* buffer, int socketFd);
  64   using _AHardwareBuffer_recvHandleFromUnixSocket =
  65       int (*)(int socketFd, AHardwareBuffer** outBuffer);
  66
  67   _AHardwareBuffer_allocate mAHardwareBuffer_allocate = nullptr;
  68   _AHardwareBuffer_acquire mAHardwareBuffer_acquire = nullptr;
  69   _AHardwareBuffer_release mAHardwareBuffer_release = nullptr;
  70   _AHardwareBuffer_describe mAHardwareBuffer_describe = nullptr;
  71   _AHardwareBuffer_lock mAHardwareBuffer_lock = nullptr;
  72   _AHardwareBuffer_unlock mAHardwareBuffer_unlock = nullptr;
  73   _AHardwareBuffer_sendHandleToUnixSocket
  74       mAHardwareBuffer_sendHandleToUnixSocket = nullptr;
  75   _AHardwareBuffer_recvHandleFromUnixSocket
  76       mAHardwareBuffer_recvHandleFromUnixSocket = nullptr;
  77
  78   static StaticAutoPtr<AndroidHardwareBufferApi> sInstance;
  79 };
  80
  81 /**
  82  * AndroidHardwareBuffer is a wrapper of AHardwareBuffer. AHardwareBuffer wraps
  83  * android GraphicBuffer. It is supported since Android O(APIVersion 26).
  84  * The manager is mainly used for release fences delivery from
  85  * host side to client side.
  86  */
  87 class AndroidHardwareBuffer
  88     : public SupportsThreadSafeWeakPtr<AndroidHardwareBuffer> {
  89  public:
  90   MOZ_DECLARE_REFCOUNTED_TYPENAME(AndroidHardwareBuffer)
  91
  92   static already_AddRefed<AndroidHardwareBuffer> Create(
  93       gfx::IntSize aSize, gfx::SurfaceFormat aFormat);
  94
  95   virtual ~AndroidHardwareBuffer();
  96
  97   int Lock(uint64_t aUsage, const ARect* aRect, void** aOutVirtualAddress);
  98   int Unlock();
  99
 100   AHardwareBuffer* GetNativeBuffer() const { return mNativeBuffer; }
 101
 102   void SetAcquireFence(ipc::FileDescriptor&& aFenceFd);
 103
 104   void SetReleaseFence(ipc::FileDescriptor&& aFenceFd);
 105
 106   ipc::FileDescriptor GetAndResetReleaseFence();
 107
 108   ipc::FileDescriptor GetAndResetAcquireFence();
 109
 110   ipc::FileDescriptor GetAcquireFence();
 111
 112   const gfx::IntSize mSize;
 113   const uint32_t mStride;
 114   const gfx::SurfaceFormat mFormat;
 115   const uint64_t mId;
 116
 117  protected:
 118   AndroidHardwareBuffer(AHardwareBuffer* aNativeBuffer, gfx::IntSize aSize,
 119                         uint32_t aStride, gfx::SurfaceFormat aFormat,
 120                         uint64_t aId);
 121
 122   void SetReleaseFence(ipc::FileDescriptor&& aFenceFd,
 123                        const MonitorAutoLock& aAutoLock);
 124
 125   AHardwareBuffer* mNativeBuffer;
 126
 127   // When true, AndroidHardwareBuffer is registered to
 128   // AndroidHardwareBufferManager.
 129   bool mIsRegistered;
 130
 131   // protected by AndroidHardwareBufferManager::mMonitor
 132
 133   // FileDescriptor of release fence.
 134   // Release fence is a fence that is used for waiting until usage/composite of
 135   // AHardwareBuffer is ended. The fence is delivered via ImageBridge.
 136   ipc::FileDescriptor mReleaseFenceFd;
 137
 138   // FileDescriptor of acquire fence.
 139   // Acquire fence is a fence that is used for waiting until rendering to
 140   // its AHardwareBuffer is completed.
 141   ipc::FileDescriptor mAcquireFenceFd;
 142
 143   static uint64_t GetNextId();
 144
 145   friend class AndroidHardwareBufferManager;
 146 };
 147
 148 /**
 149  * AndroidHardwareBufferManager manages AndroidHardwareBuffers that is
 150  * allocated by client side.
 151  * Host side only uses mMonitor for thread safety of AndroidHardwareBuffer.
 152  */
 153 class AndroidHardwareBufferManager {
 154  public:
 155   static void Init();
 156   static void Shutdown();
 157
 158   AndroidHardwareBufferManager();
 159
 160   static AndroidHardwareBufferManager* Get() { return sInstance; }
 161
 162   void Register(RefPtr<AndroidHardwareBuffer> aBuffer);
 163
 164   void Unregister(AndroidHardwareBuffer* aBuffer);
 165
 166   already_AddRefed<AndroidHardwareBuffer> GetBuffer(uint64_t aBufferId);
 167
 168   Monitor& GetMonitor() { return mMonitor; }
 169
 170  private:
 171   Monitor mMonitor MOZ_UNANNOTATED;
 172   std::unordered_map<uint64_t, ThreadSafeWeakPtr<AndroidHardwareBuffer>>
 173       mBuffers;
 174
 175   static StaticAutoPtr<AndroidHardwareBufferManager> sInstance;
 176 };
 177
 178 }  // namespace layers
 179 }  // namespace mozilla
 180
 181 #endif