widget/gtk/DMABufSurface.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 DMABufSurface_h__
   8 #define DMABufSurface_h__
   9
  10 #include <stdint.h>
  11 #include "mozilla/widget/nsWaylandDisplay.h"
  12 #include "mozilla/widget/va_drmcommon.h"
  13 #include "GLTypes.h"
  14
  15 typedef void* EGLImageKHR;
  16 typedef void* EGLSyncKHR;
  17
  18 #define DMABUF_BUFFER_PLANES 4
  19
  20 #ifndef VA_FOURCC_NV12
  21 #  define VA_FOURCC_NV12 0x3231564E
  22 #endif
  23 #ifndef VA_FOURCC_YV12
  24 #  define VA_FOURCC_YV12 0x32315659
  25 #endif
  26 #ifndef VA_FOURCC_P010
  27 #  define VA_FOURCC_P010 0x30313050
  28 #endif
  29
  30 namespace mozilla {
  31 namespace gfx {
  32 class SourceSurface;
  33 }
  34 namespace layers {
  35 class SurfaceDescriptor;
  36 class SurfaceDescriptorDMABuf;
  37 }  // namespace layers
  38 namespace gl {
  39 class GLContext;
  40 }
  41 }  // namespace mozilla
  42
  43 typedef enum {
  44   // Use alpha pixel format
  45   DMABUF_ALPHA = 1 << 0,
  46   // Surface is used as texture and may be also shared
  47   DMABUF_TEXTURE = 1 << 1,
  48   // Use modifiers. Such dmabuf surface may have more planes
  49   // and complex internal structure (tiling/compression/etc.)
  50   // so we can't do direct rendering to it.
  51   DMABUF_USE_MODIFIERS = 1 << 3,
  52 } DMABufSurfaceFlags;
  53
  54 class DMABufSurfaceRGBA;
  55 class DMABufSurfaceYUV;
  56
  57 class DMABufSurface {
  58  public:
  59   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(DMABufSurface)
  60
  61   enum SurfaceType {
  62     SURFACE_RGBA,
  63     SURFACE_NV12,
  64     SURFACE_YUV420,
  65   };
  66
  67   // Import surface from SurfaceDescriptor. This is usually
  68   // used to copy surface from another process over IPC.
  69   // When a global reference counter was created for the surface
  70   // (see bellow) it's automatically referenced.
  71   static already_AddRefed<DMABufSurface> CreateDMABufSurface(
  72       const mozilla::layers::SurfaceDescriptor& aDesc);
  73
  74   // Export surface to another process via. SurfaceDescriptor.
  75   virtual bool Serialize(
  76       mozilla::layers::SurfaceDescriptor& aOutDescriptor) = 0;
  77
  78   virtual int GetWidth(int aPlane = 0) = 0;
  79   virtual int GetHeight(int aPlane = 0) = 0;
  80   virtual mozilla::gfx::SurfaceFormat GetFormat() = 0;
  81   virtual mozilla::gfx::SurfaceFormat GetFormatGL() = 0;
  82
  83   virtual bool CreateTexture(mozilla::gl::GLContext* aGLContext,
  84                              int aPlane = 0) = 0;
  85   virtual void ReleaseTextures() = 0;
  86   virtual GLuint GetTexture(int aPlane = 0) = 0;
  87   virtual EGLImageKHR GetEGLImage(int aPlane = 0) = 0;
  88
  89   SurfaceType GetSurfaceType() { return mSurfaceType; };
  90   virtual int GetTextureCount() = 0;
  91
  92   bool IsMapped(int aPlane = 0) { return (mMappedRegion[aPlane] != nullptr); };
  93   void Unmap(int aPlane = 0);
  94
  95   virtual DMABufSurfaceRGBA* GetAsDMABufSurfaceRGBA() { return nullptr; }
  96   virtual DMABufSurfaceYUV* GetAsDMABufSurfaceYUV() { return nullptr; }
  97
  98   virtual mozilla::gfx::YUVColorSpace GetYUVColorSpace() {
  99     return mozilla::gfx::YUVColorSpace::Default;
 100   };
 101
 102   bool IsFullRange() { return mColorRange == mozilla::gfx::ColorRange::FULL; };
 103   void SetColorRange(mozilla::gfx::ColorRange aColorRange) {
 104     mColorRange = aColorRange;
 105   };
 106
 107   void FenceSet();
 108   void FenceWait();
 109   void FenceDelete();
 110
 111   // Set and get a global surface UID. The UID is shared across process
 112   // and it's used to track surface lifetime in various parts of rendering
 113   // engine.
 114   uint32_t GetUID() const { return mUID; };
 115
 116   // Creates a global reference counter objects attached to the surface.
 117   // It's created as unreferenced, i.e. IsGlobalRefSet() returns false
 118   // right after GlobalRefCountCreate() call.
 119   //
 120   // The counter is shared by all surface instances across processes
 121   // so it tracks global surface usage.
 122   //
 123   // The counter is automatically referenced when a new surface instance is
 124   // created with SurfaceDescriptor (usually copied to another process over IPC)
 125   // and it's unreferenced when surface is deleted.
 126   //
 127   // So without any additional GlobalRefAdd()/GlobalRefRelease() calls
 128   // the IsGlobalRefSet() returns true if any other process use the surface.
 129   void GlobalRefCountCreate();
 130
 131   // If global reference counter was created by GlobalRefCountCreate()
 132   // returns true when there's an active surface reference.
 133   bool IsGlobalRefSet() const;
 134
 135   // Add/Remove additional reference to the surface global reference counter.
 136   void GlobalRefAdd();
 137   void GlobalRefRelease();
 138
 139   // Release all underlying data.
 140   virtual void ReleaseSurface() = 0;
 141
 142 #ifdef DEBUG
 143   virtual void DumpToFile(const char* pFile){};
 144 #endif
 145
 146   DMABufSurface(SurfaceType aSurfaceType);
 147
 148  protected:
 149   virtual bool Create(const mozilla::layers::SurfaceDescriptor& aDesc) = 0;
 150
 151   void GlobalRefCountImport(int aFd);
 152   void GlobalRefCountDelete();
 153
 154   void ReleaseDMABuf();
 155
 156   void* MapInternal(uint32_t aX, uint32_t aY, uint32_t aWidth, uint32_t aHeight,
 157                     uint32_t* aStride, int aGbmFlags, int aPlane = 0);
 158
 159   // We want to keep number of opened file descriptors low so open/close
 160   // DMABuf file handles only when we need them, i.e. when DMABuf is exported
 161   // to another process or to EGL.
 162   virtual bool OpenFileDescriptorForPlane(
 163       const mozilla::MutexAutoLock& aProofOfLock, int aPlane) = 0;
 164   virtual void CloseFileDescriptorForPlane(
 165       const mozilla::MutexAutoLock& aProofOfLock, int aPlane,
 166       bool aForceClose = false) = 0;
 167   bool OpenFileDescriptors(const mozilla::MutexAutoLock& aProofOfLock);
 168   void CloseFileDescriptors(const mozilla::MutexAutoLock& aProofOfLock,
 169                             bool aForceClose = false);
 170
 171   virtual ~DMABufSurface();
 172
 173   SurfaceType mSurfaceType;
 174   uint64_t mBufferModifiers[DMABUF_BUFFER_PLANES];
 175
 176   int mBufferPlaneCount;
 177   int mDmabufFds[DMABUF_BUFFER_PLANES];
 178   uint32_t mDrmFormats[DMABUF_BUFFER_PLANES];
 179   uint32_t mStrides[DMABUF_BUFFER_PLANES];
 180   uint32_t mOffsets[DMABUF_BUFFER_PLANES];
 181
 182   struct gbm_bo* mGbmBufferObject[DMABUF_BUFFER_PLANES];
 183   void* mMappedRegion[DMABUF_BUFFER_PLANES];
 184   void* mMappedRegionData[DMABUF_BUFFER_PLANES];
 185   uint32_t mMappedRegionStride[DMABUF_BUFFER_PLANES];
 186
 187   int mSyncFd;
 188   EGLSyncKHR mSync;
 189   RefPtr<mozilla::gl::GLContext> mGL;
 190
 191   int mGlobalRefCountFd;
 192   uint32_t mUID;
 193   mozilla::Mutex mSurfaceLock MOZ_UNANNOTATED;
 194
 195   mozilla::gfx::ColorRange mColorRange = mozilla::gfx::ColorRange::LIMITED;
 196 };
 197
 198 class DMABufSurfaceRGBA : public DMABufSurface {
 199  public:
 200   static already_AddRefed<DMABufSurfaceRGBA> CreateDMABufSurface(
 201       int aWidth, int aHeight, int aDMABufSurfaceFlags);
 202
 203   bool Serialize(mozilla::layers::SurfaceDescriptor& aOutDescriptor);
 204
 205   DMABufSurfaceRGBA* GetAsDMABufSurfaceRGBA() { return this; }
 206
 207   void Clear();
 208
 209   void ReleaseSurface();
 210
 211   bool CopyFrom(class DMABufSurface* aSourceSurface);
 212
 213   int GetWidth(int aPlane = 0) { return mWidth; };
 214   int GetHeight(int aPlane = 0) { return mHeight; };
 215   mozilla::gfx::SurfaceFormat GetFormat();
 216   mozilla::gfx::SurfaceFormat GetFormatGL();
 217   bool HasAlpha();
 218
 219   void* MapReadOnly(uint32_t aX, uint32_t aY, uint32_t aWidth, uint32_t aHeight,
 220                     uint32_t* aStride = nullptr);
 221   void* MapReadOnly(uint32_t* aStride = nullptr);
 222   void* Map(uint32_t aX, uint32_t aY, uint32_t aWidth, uint32_t aHeight,
 223             uint32_t* aStride = nullptr);
 224   void* Map(uint32_t* aStride = nullptr);
 225   void* GetMappedRegion(int aPlane = 0) { return mMappedRegion[aPlane]; };
 226   uint32_t GetMappedRegionStride(int aPlane = 0) {
 227     return mMappedRegionStride[aPlane];
 228   };
 229
 230   bool CreateTexture(mozilla::gl::GLContext* aGLContext, int aPlane = 0);
 231   void ReleaseTextures();
 232   GLuint GetTexture(int aPlane = 0) { return mTexture; };
 233   EGLImageKHR GetEGLImage(int aPlane = 0) { return mEGLImage; };
 234
 235   bool CreateWlBuffer();
 236   void ReleaseWlBuffer();
 237   wl_buffer* GetWlBuffer() { return mWlBuffer; };
 238
 239   int GetTextureCount() { return 1; };
 240
 241 #ifdef DEBUG
 242   virtual void DumpToFile(const char* pFile);
 243 #endif
 244
 245   DMABufSurfaceRGBA();
 246
 247  private:
 248   ~DMABufSurfaceRGBA();
 249
 250   bool Create(int aWidth, int aHeight, int aDMABufSurfaceFlags);
 251   bool Create(const mozilla::layers::SurfaceDescriptor& aDesc);
 252
 253   bool ImportSurfaceDescriptor(const mozilla::layers::SurfaceDescriptor& aDesc);
 254
 255   bool OpenFileDescriptorForPlane(const mozilla::MutexAutoLock& aProofOfLock,
 256                                   int aPlane);
 257   void CloseFileDescriptorForPlane(const mozilla::MutexAutoLock& aProofOfLock,
 258                                    int aPlane, bool aForceClose);
 259
 260  private:
 261   int mSurfaceFlags;
 262
 263   int mWidth;
 264   int mHeight;
 265   mozilla::widget::GbmFormat* mGmbFormat;
 266
 267   EGLImageKHR mEGLImage;
 268   GLuint mTexture;
 269   uint32_t mGbmBufferFlags;
 270   wl_buffer* mWlBuffer;
 271 };
 272
 273 class DMABufSurfaceYUV : public DMABufSurface {
 274  public:
 275   static already_AddRefed<DMABufSurfaceYUV> CreateYUVSurface(
 276       int aWidth, int aHeight, void** aPixelData = nullptr,
 277       int* aLineSizes = nullptr);
 278
 279   static already_AddRefed<DMABufSurfaceYUV> CreateYUVSurface(
 280       const VADRMPRIMESurfaceDescriptor& aDesc, int aWidth, int aHeight);
 281
 282   bool Serialize(mozilla::layers::SurfaceDescriptor& aOutDescriptor);
 283
 284   DMABufSurfaceYUV* GetAsDMABufSurfaceYUV() { return this; };
 285
 286   int GetWidth(int aPlane = 0) { return mWidth[aPlane]; }
 287   int GetHeight(int aPlane = 0) { return mHeight[aPlane]; }
 288   mozilla::gfx::SurfaceFormat GetFormat();
 289   mozilla::gfx::SurfaceFormat GetFormatGL();
 290
 291   bool CreateTexture(mozilla::gl::GLContext* aGLContext, int aPlane = 0);
 292   void ReleaseTextures();
 293
 294   void ReleaseSurface();
 295
 296   GLuint GetTexture(int aPlane = 0) { return mTexture[aPlane]; };
 297   EGLImageKHR GetEGLImage(int aPlane = 0) { return mEGLImage[aPlane]; };
 298
 299   int GetTextureCount();
 300
 301   void SetYUVColorSpace(mozilla::gfx::YUVColorSpace aColorSpace) {
 302     mColorSpace = aColorSpace;
 303   }
 304   mozilla::gfx::YUVColorSpace GetYUVColorSpace() { return mColorSpace; }
 305
 306   DMABufSurfaceYUV();
 307
 308   bool UpdateYUVData(void** aPixelData, int* aLineSizes);
 309   bool UpdateYUVData(const VADRMPRIMESurfaceDescriptor& aDesc, int aWidth,
 310                      int aHeight);
 311
 312   bool VerifyTextureCreation();
 313
 314  private:
 315   ~DMABufSurfaceYUV();
 316
 317   bool Create(const mozilla::layers::SurfaceDescriptor& aDesc);
 318   bool Create(int aWidth, int aHeight, void** aPixelData, int* aLineSizes);
 319   bool CreateYUVPlane(int aPlane, int aWidth, int aHeight, int aDrmFormat);
 320   void UpdateYUVPlane(int aPlane, void* aPixelData, int aLineSize);
 321
 322   bool ImportSurfaceDescriptor(
 323       const mozilla::layers::SurfaceDescriptorDMABuf& aDesc);
 324
 325   bool OpenFileDescriptorForPlane(const mozilla::MutexAutoLock& aProofOfLock,
 326                                   int aPlane);
 327   void CloseFileDescriptorForPlane(const mozilla::MutexAutoLock& aProofOfLock,
 328                                    int aPlane, bool aForceClose);
 329
 330   bool CreateEGLImage(mozilla::gl::GLContext* aGLContext, int aPlane);
 331   void ReleaseEGLImages(mozilla::gl::GLContext* aGLContext);
 332
 333   int mWidth[DMABUF_BUFFER_PLANES];
 334   int mHeight[DMABUF_BUFFER_PLANES];
 335   // Aligned size of the surface imported from VADRMPRIMESurfaceDescriptor.
 336   // It's used only internally to create EGLImage as some GL drivers
 337   // needs that (Bug 1724385).
 338   int mWidthAligned[DMABUF_BUFFER_PLANES];
 339   int mHeightAligned[DMABUF_BUFFER_PLANES];
 340   EGLImageKHR mEGLImage[DMABUF_BUFFER_PLANES];
 341   GLuint mTexture[DMABUF_BUFFER_PLANES];
 342   mozilla::gfx::YUVColorSpace mColorSpace =
 343       mozilla::gfx::YUVColorSpace::Default;
 344 };
 345
 346 #endif