gfx/layers/CompositorTypes.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_COMPOSITORTYPES_H
   8 #define MOZILLA_LAYERS_COMPOSITORTYPES_H
   9
  10 #include <stdint.h>       // for uint32_t
  11 #include <sys/types.h>    // for int32_t
  12 #include "LayersTypes.h"  // for LayersBackend, etc
  13 #include "nsXULAppAPI.h"  // for GeckoProcessType, etc
  14 #include "mozilla/gfx/Types.h"
  15 #include "mozilla/EnumSet.h"
  16
  17 #include "mozilla/TypedEnumBits.h"
  18
  19 namespace mozilla {
  20 namespace layers {
  21
  22 /**
  23  * Flags used by texture clients and texture hosts. These are passed from client
  24  * side to host side when textures and compositables are created. Usually set
  25  * by the compositableCient, they may be modified by either the compositable or
  26  * texture clients.
  27  */
  28 enum class TextureFlags : uint32_t {
  29   NO_FLAGS = 0,
  30   // Use nearest-neighbour texture filtering (as opposed to linear filtering).
  31   USE_NEAREST_FILTER = 1 << 0,
  32   // The compositor assumes everything is origin-top-left by default.
  33   ORIGIN_BOTTOM_LEFT = 1 << 1,
  34   // Force the texture to be represented using a single tile (note that this
  35   // means tiled textures, not tiled layers).
  36   DISALLOW_BIGIMAGE = 1 << 2,
  37   // The buffer will be treated as if the RB bytes are swapped.
  38   // This is useful for rendering using Cairo/Thebes, because there is no
  39   // BGRX Android pixel format, and so we have to do byte swapping.
  40   //
  41   // For example, if the GraphicBuffer has an Android pixel format of
  42   // PIXEL_FORMAT_RGBA_8888 and isRBSwapped is true, when it is sampled
  43   // (for example, with GL), a BGRA shader should be used.
  44   RB_SWAPPED = 1 << 3,
  45   // Data in this texture has not been alpha-premultiplied.
  46   // XXX - Apparently only used with ImageClient/Host
  47   NON_PREMULTIPLIED = 1 << 4,
  48   // The TextureClient should be recycled with recycle callback when no longer
  49   // in used. When the texture is used in host side, ref count of TextureClient
  50   // is transparently added by ShadowLayerForwarder or ImageBridgeChild.
  51   RECYCLE = 1 << 5,
  52   // If DEALLOCATE_CLIENT is set, the shared data is deallocated on the
  53   // client side and requires some extra synchronizaion to ensure race-free
  54   // deallocation.
  55   // The default behaviour is to deallocate on the host side.
  56   DEALLOCATE_CLIENT = 1 << 6,
  57   DEALLOCATE_SYNC = 1 << 6,  // XXX - make it a separate flag.
  58   DEALLOCATE_MAIN_THREAD = 1 << 8,
  59   // After being shared ith the compositor side, an immutable texture is never
  60   // modified, it can only be read. It is safe to not Lock/Unlock immutable
  61   // textures.
  62   IMMUTABLE = 1 << 9,
  63   // The contents of the texture must be uploaded or copied immediately
  64   // during the transaction, because the producer may want to write
  65   // to it again.
  66   IMMEDIATE_UPLOAD = 1 << 10,
  67   // The texture is part of a component-alpha pair
  68   COMPONENT_ALPHA = 1 << 11,
  69   // The texture is being allocated for a compositor that no longer exists.
  70   // This flag is only used in the parent process.
  71   INVALID_COMPOSITOR = 1 << 12,
  72   // The texture was created by converting from YCBCR to RGB
  73   RGB_FROM_YCBCR = 1 << 13,
  74   // The texture is used for snapshot.
  75   SNAPSHOT = 1 << 14,
  76   // Enable a non blocking read lock.
  77   NON_BLOCKING_READ_LOCK = 1 << 15,
  78   // Enable a blocking read lock.
  79   BLOCKING_READ_LOCK = 1 << 16,
  80   // Keep TextureClient alive when host side is used
  81   WAIT_HOST_USAGE_END = 1 << 17,
  82
  83   // OR union of all valid bits
  84   ALL_BITS = (1 << 18) - 1,
  85   // the default flags
  86   DEFAULT = NO_FLAGS
  87 };
  88 MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(TextureFlags)
  89
  90 static inline bool TextureRequiresLocking(TextureFlags aFlags) {
  91   // If we're not double buffered, or uploading
  92   // within a transaction, then we need to support
  93   // locking correctly.
  94   return !(aFlags & (TextureFlags::IMMEDIATE_UPLOAD | TextureFlags::IMMUTABLE));
  95 }
  96
  97 /**
  98  * The type of debug diagnostic to enable.
  99  */
 100 enum class DiagnosticTypes : uint8_t {
 101   NO_DIAGNOSTIC = 0,
 102   TILE_BORDERS = 1 << 0,
 103   LAYER_BORDERS = 1 << 1,
 104   BIGIMAGE_BORDERS = 1 << 2,
 105   FLASH_BORDERS = 1 << 3,
 106   ALL_BITS = (1 << 4) - 1
 107 };
 108 MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(DiagnosticTypes)
 109
 110 #define DIAGNOSTIC_FLASH_COUNTER_MAX 100
 111
 112 /**
 113  * Information about the object that is being diagnosed.
 114  */
 115 enum class DiagnosticFlags : uint16_t {
 116   NO_DIAGNOSTIC = 0,
 117   IMAGE = 1 << 0,
 118   CONTENT = 1 << 1,
 119   CANVAS = 1 << 2,
 120   COLOR = 1 << 3,
 121   CONTAINER = 1 << 4,
 122   TILE = 1 << 5,
 123   BIGIMAGE = 1 << 6,
 124   COMPONENT_ALPHA = 1 << 7,
 125   REGION_RECT = 1 << 8,
 126   NV12 = 1 << 9,
 127   YCBCR = 1 << 10
 128 };
 129 MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(DiagnosticFlags)
 130
 131 /**
 132  * See gfx/layers/Effects.h
 133  */
 134 enum class EffectTypes : uint8_t {
 135   MASK,
 136   BLEND_MODE,
 137   COLOR_MATRIX,
 138   MAX_SECONDARY,  // sentinel for the count of secondary effect types
 139   RGB,
 140   YCBCR,
 141   NV12,
 142   COMPONENT_ALPHA,
 143   SOLID_COLOR,
 144   RENDER_TARGET,
 145   MAX  // sentinel for the count of all effect types
 146 };
 147
 148 /**
 149  * How the Compositable should manage textures.
 150  */
 151 enum class CompositableType : uint8_t {
 152   UNKNOWN,
 153   CONTENT_TILED,   // tiled painted layer
 154   IMAGE,           // image with single buffering
 155   IMAGE_BRIDGE,    // ImageBridge protocol
 156   CONTENT_SINGLE,  // painted layer interface, single buffering
 157   CONTENT_DOUBLE,  // painted layer interface, double buffering
 158   COUNT
 159 };
 160
 161 #ifdef XP_WIN
 162 typedef void* SyncHandle;
 163 #else
 164 typedef uintptr_t SyncHandle;
 165 #endif  // XP_WIN
 166
 167 /**
 168  * Sent from the compositor to the content-side LayerManager, includes
 169  * properties of the compositor and should (in the future) include information
 170  * about what kinds of buffer and texture clients to create.
 171  */
 172 struct TextureFactoryIdentifier {
 173   LayersBackend mParentBackend;
 174   GeckoProcessType mParentProcessType;
 175   int32_t mMaxTextureSize;
 176   bool mSupportsTextureDirectMapping;
 177   bool mCompositorUseANGLE;
 178   bool mCompositorUseDComp;
 179   bool mUseCompositorWnd;
 180   bool mSupportsTextureBlitting;
 181   bool mSupportsPartialUploads;
 182   bool mSupportsComponentAlpha;
 183   bool mUsingAdvancedLayers;
 184   SyncHandle mSyncHandle;
 185
 186   explicit TextureFactoryIdentifier(
 187       LayersBackend aLayersBackend = LayersBackend::LAYERS_NONE,
 188       GeckoProcessType aParentProcessType = GeckoProcessType_Default,
 189       int32_t aMaxTextureSize = 4096,
 190       bool aSupportsTextureDirectMapping = false,
 191       bool aCompositorUseANGLE = false, bool aCompositorUseDComp = false,
 192       bool aUseCompositorWnd = false, bool aSupportsTextureBlitting = false,
 193       bool aSupportsPartialUploads = false, bool aSupportsComponentAlpha = true,
 194       SyncHandle aSyncHandle = 0)
 195       : mParentBackend(aLayersBackend),
 196         mParentProcessType(aParentProcessType),
 197         mMaxTextureSize(aMaxTextureSize),
 198         mSupportsTextureDirectMapping(aSupportsTextureDirectMapping),
 199         mCompositorUseANGLE(aCompositorUseANGLE),
 200         mCompositorUseDComp(aCompositorUseDComp),
 201         mUseCompositorWnd(aUseCompositorWnd),
 202         mSupportsTextureBlitting(aSupportsTextureBlitting),
 203         mSupportsPartialUploads(aSupportsPartialUploads),
 204         mSupportsComponentAlpha(aSupportsComponentAlpha),
 205         mUsingAdvancedLayers(false),
 206         mSyncHandle(aSyncHandle) {}
 207
 208   bool operator==(const TextureFactoryIdentifier& aOther) const {
 209     return mParentBackend == aOther.mParentBackend &&
 210            mParentProcessType == aOther.mParentProcessType &&
 211            mMaxTextureSize == aOther.mMaxTextureSize &&
 212            mSupportsTextureDirectMapping ==
 213                aOther.mSupportsTextureDirectMapping &&
 214            mCompositorUseANGLE == aOther.mCompositorUseANGLE &&
 215            mCompositorUseDComp == aOther.mCompositorUseDComp &&
 216            mUseCompositorWnd == aOther.mUseCompositorWnd &&
 217            mSupportsTextureBlitting == aOther.mSupportsTextureBlitting &&
 218            mSupportsPartialUploads == aOther.mSupportsPartialUploads &&
 219            mSupportsComponentAlpha == aOther.mSupportsComponentAlpha &&
 220            mUsingAdvancedLayers == aOther.mUsingAdvancedLayers &&
 221            mSyncHandle == aOther.mSyncHandle;
 222   }
 223 };
 224
 225 /**
 226  * Information required by the compositor from the content-side for creating or
 227  * using compositables and textures.
 228  * XXX - TextureInfo is a bad name: this information is useful for the
 229  * compositable, not the Texture. And ith new Textures, only the compositable
 230  * type is really useful. This may (should) be removed in the near future.
 231  */
 232 struct TextureInfo {
 233   CompositableType mCompositableType;
 234   TextureFlags mTextureFlags;
 235
 236   TextureInfo()
 237       : mCompositableType(CompositableType::UNKNOWN),
 238         mTextureFlags(TextureFlags::NO_FLAGS) {}
 239
 240   explicit TextureInfo(CompositableType aType,
 241                        TextureFlags aTextureFlags = TextureFlags::DEFAULT)
 242       : mCompositableType(aType), mTextureFlags(aTextureFlags) {}
 243
 244   bool operator==(const TextureInfo& aOther) const {
 245     return mCompositableType == aOther.mCompositableType &&
 246            mTextureFlags == aOther.mTextureFlags;
 247   }
 248 };
 249
 250 /**
 251  * How a SurfaceDescriptor will be opened.
 252  *
 253  * See ShadowLayerForwarder::OpenDescriptor for example.
 254  */
 255 enum class OpenMode : uint8_t {
 256   OPEN_NONE = 0,
 257   OPEN_READ = 0x1,
 258   OPEN_WRITE = 0x2,
 259   // This is only used in conjunction with OMTP to indicate that the DrawTarget
 260   // that is being borrowed will be painted asynchronously, and so will outlive
 261   // the write lock.
 262   OPEN_ASYNC = 0x04,
 263
 264   OPEN_READ_WRITE = OPEN_READ | OPEN_WRITE,
 265   OPEN_READ_WRITE_ASYNC = OPEN_READ | OPEN_WRITE | OPEN_ASYNC,
 266   OPEN_READ_ASYNC = OPEN_READ | OPEN_ASYNC,
 267   OPEN_READ_ONLY = OPEN_READ,
 268   OPEN_WRITE_ONLY = OPEN_WRITE,
 269 };
 270 MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(OpenMode)
 271
 272 // The kinds of mask texture a shader can support
 273 // We rely on the items in this enum being sequential
 274 enum class MaskType : uint8_t {
 275   MaskNone = 0,  // no mask layer
 276   Mask,          // mask layer
 277   NumMaskTypes
 278 };
 279
 280 }  // namespace layers
 281 }  // namespace mozilla
 282
 283 #endif