diff -r 000000000000 -r 6474c204b198 gfx/layers/CompositorTypes.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gfx/layers/CompositorTypes.h Wed Dec 31 06:09:35 2014 +0100 @@ -0,0 +1,269 @@ +/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*- +* 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/. */ + +#ifndef MOZILLA_LAYERS_COMPOSITORTYPES_H +#define MOZILLA_LAYERS_COMPOSITORTYPES_H + +#include // for uint32_t +#include // for int32_t +#include "LayersTypes.h" // for LayersBackend, etc +#include "nsXULAppAPI.h" // for GeckoProcessType, etc + +namespace mozilla { +namespace layers { + +typedef int32_t SurfaceDescriptorType; +const SurfaceDescriptorType SURFACEDESCRIPTOR_UNKNOWN = 0; + +/** + * Flags used by texture clients and texture hosts. These are passed from client + * side to host side when textures and compositables are created. Usually set + * by the compositableCient, they may be modified by either the compositable or + * texture clients. + * + * XXX - switch to all caps constant names which seems to be the standard in gecko + */ +typedef uint32_t TextureFlags; +// Use nearest-neighbour texture filtering (as opposed to linear filtering). +const TextureFlags TEXTURE_USE_NEAREST_FILTER = 1 << 0; +// The texture should be flipped around the y-axis when composited. +const TextureFlags TEXTURE_NEEDS_Y_FLIP = 1 << 1; +// Force the texture to be represented using a single tile (note that this means +// tiled textures, not tiled layers). +const TextureFlags TEXTURE_DISALLOW_BIGIMAGE = 1 << 2; +// Allow using 'repeat' mode for wrapping. +const TextureFlags TEXTURE_ALLOW_REPEAT = 1 << 3; +// The texture represents a tile which is newly created. +const TextureFlags TEXTURE_NEW_TILE = 1 << 4; +// The texture is part of a component-alpha pair +const TextureFlags TEXTURE_COMPONENT_ALPHA = 1 << 5; +// The buffer will be treated as if the RB bytes are swapped. +// This is useful for rendering using Cairo/Thebes, because there is no +// BGRX Android pixel format, and so we have to do byte swapping. +// +// For example, if the GraphicBuffer has an Android pixel format of +// PIXEL_FORMAT_RGBA_8888 and isRBSwapped is true, when it is sampled +// (for example, with GL), a BGRA shader should be used. +const TextureFlags TEXTURE_RB_SWAPPED = 1 << 6; + +const TextureFlags TEXTURE_FRONT = 1 << 12; +// A texture host on white for component alpha +const TextureFlags TEXTURE_ON_WHITE = 1 << 13; + // A texture host on black for component alpha +const TextureFlags TEXTURE_ON_BLACK = 1 << 14; +// A texture host that supports tiling +const TextureFlags TEXTURE_TILE = 1 << 15; +// A texture should be recycled when no longer in used +const TextureFlags TEXTURE_RECYCLE = 1 << 16; +// Texture contents should be initialized +// from the previous texture. +const TextureFlags TEXTURE_COPY_PREVIOUS = 1 << 24; +// Who is responsible for deallocating the shared data. +// if TEXTURE_DEALLOCATE_CLIENT is set, the shared data is deallocated on the +// client side and requires some extra synchronizaion to ensure race-free +// deallocation. +// The default behaviour is to deallocate on the host side. +const TextureFlags TEXTURE_DEALLOCATE_CLIENT = 1 << 25; +// After being shared ith the compositor side, an immutable texture is never +// modified, it can only be read. It is safe to not Lock/Unlock immutable +// textures. +const TextureFlags TEXTURE_IMMUTABLE = 1 << 27; +// The contents of the texture must be uploaded or copied immediately +// during the transaction, because the producer may want to write +// to it again. +const TextureFlags TEXTURE_IMMEDIATE_UPLOAD = 1 << 28; +// The texture is going to be used as part of a double +// buffered pair, and so we can guarantee that the producer/consumer +// won't be racing to access its contents. +const TextureFlags TEXTURE_DOUBLE_BUFFERED = 1 << 29; +// We've previously tried a texture and it didn't work for some reason. If there +// is a fallback available, try that. +const TextureFlags TEXTURE_ALLOC_FALLBACK = 1 << 31; + +// the default flags +const TextureFlags TEXTURE_FLAGS_DEFAULT = TEXTURE_FRONT; + +static inline bool +TextureRequiresLocking(TextureFlags aFlags) +{ + // If we're not double buffered, or uploading + // within a transaction, then we need to support + // locking correctly. + return !(aFlags & (TEXTURE_IMMEDIATE_UPLOAD | + TEXTURE_DOUBLE_BUFFERED | + TEXTURE_IMMUTABLE)); +} + +/** + * The type of debug diagnostic to enable. + */ +typedef uint32_t DiagnosticTypes; +const DiagnosticTypes DIAGNOSTIC_NONE = 0; +const DiagnosticTypes DIAGNOSTIC_TILE_BORDERS = 1 << 0; +const DiagnosticTypes DIAGNOSTIC_LAYER_BORDERS = 1 << 1; +const DiagnosticTypes DIAGNOSTIC_BIGIMAGE_BORDERS = 1 << 2; +const DiagnosticTypes DIAGNOSTIC_FLASH_BORDERS = 1 << 3; + +#define DIAGNOSTIC_FLASH_COUNTER_MAX 100 + +/** + * Information about the object that is being diagnosed. + */ +typedef uint32_t DiagnosticFlags; +const DiagnosticFlags DIAGNOSTIC_IMAGE = 1 << 0; +const DiagnosticFlags DIAGNOSTIC_CONTENT = 1 << 1; +const DiagnosticFlags DIAGNOSTIC_CANVAS = 1 << 2; +const DiagnosticFlags DIAGNOSTIC_COLOR = 1 << 3; +const DiagnosticFlags DIAGNOSTIC_CONTAINER = 1 << 4; +const DiagnosticFlags DIAGNOSTIC_TILE = 1 << 5; +const DiagnosticFlags DIAGNOSTIC_BIGIMAGE = 1 << 6; +const DiagnosticFlags DIAGNOSTIC_COMPONENT_ALPHA = 1 << 7; +const DiagnosticFlags DIAGNOSTIC_REGION_RECT = 1 << 8; + +/** + * See gfx/layers/Effects.h + */ +enum EffectTypes +{ + EFFECT_MASK, + EFFECT_MAX_SECONDARY, // sentinel for the count of secondary effect types + EFFECT_RGB, + EFFECT_YCBCR, + EFFECT_COMPONENT_ALPHA, + EFFECT_SOLID_COLOR, + EFFECT_RENDER_TARGET, + EFFECT_MAX //sentinel for the count of all effect types +}; + +/** + * How the Compositable should manage textures. + */ +enum CompositableType +{ + BUFFER_UNKNOWN, + // the deprecated compositable types + BUFFER_IMAGE_SINGLE, // image/canvas with a single texture, single buffered + BUFFER_IMAGE_BUFFERED, // canvas, double buffered + BUFFER_BRIDGE, // image bridge protocol + BUFFER_CONTENT_INC, // thebes layer interface, only sends incremental + // updates to a texture on the compositor side. + // somewhere in the middle + BUFFER_TILED, // tiled thebes layer + BUFFER_SIMPLE_TILED, + // the new compositable types + COMPOSITABLE_IMAGE, // image with single buffering + COMPOSITABLE_CONTENT_SINGLE, // thebes layer interface, single buffering + COMPOSITABLE_CONTENT_DOUBLE, // thebes layer interface, double buffering + BUFFER_COUNT +}; + +/** + * How the texture host is used for composition, + */ +enum DeprecatedTextureHostFlags +{ + TEXTURE_HOST_DEFAULT = 0, // The default texture host for the given + // SurfaceDescriptor + TEXTURE_HOST_TILED = 1 << 0, // A texture host that supports tiling + TEXTURE_HOST_COPY_PREVIOUS = 1 << 1 // Texture contents should be initialized + // from the previous texture. +}; + +/** + * Sent from the compositor to the content-side LayerManager, includes properties + * of the compositor and should (in the future) include information about what + * kinds of buffer and texture clients to create. + */ +struct TextureFactoryIdentifier +{ + LayersBackend mParentBackend; + GeckoProcessType mParentProcessId; + int32_t mMaxTextureSize; + bool mSupportsTextureBlitting; + bool mSupportsPartialUploads; + + TextureFactoryIdentifier(LayersBackend aLayersBackend = LayersBackend::LAYERS_NONE, + GeckoProcessType aParentProcessId = GeckoProcessType_Default, + int32_t aMaxTextureSize = 0, + bool aSupportsTextureBlitting = false, + bool aSupportsPartialUploads = false) + : mParentBackend(aLayersBackend) + , mParentProcessId(aParentProcessId) + , mMaxTextureSize(aMaxTextureSize) + , mSupportsTextureBlitting(aSupportsTextureBlitting) + , mSupportsPartialUploads(aSupportsPartialUploads) + {} +}; + +/** + * Identify a texture to a compositable. Many textures can have the same id, but + * the id is unique for any texture owned by a particular compositable. + * XXX - This is now redundant with TextureFlags. it ill be removed along with + * deprecated texture classes. + */ +typedef uint32_t TextureIdentifier; +const TextureIdentifier TextureFront = 1; +const TextureIdentifier TextureBack = 2; +const TextureIdentifier TextureOnWhiteFront = 3; +const TextureIdentifier TextureOnWhiteBack = 4; + +/** + * Information required by the compositor from the content-side for creating or + * using compositables and textures. + * XXX - TextureInfo is a bad name: this information is useful for the compositable, + * not the Texture. And ith new Textures, only the compositable type is really + * useful. This may (should) be removed in the near future. + */ +struct TextureInfo +{ + CompositableType mCompositableType; + uint32_t mDeprecatedTextureHostFlags; + uint32_t mTextureFlags; + + TextureInfo() + : mCompositableType(BUFFER_UNKNOWN) + , mDeprecatedTextureHostFlags(0) + , mTextureFlags(0) + {} + + TextureInfo(CompositableType aType) + : mCompositableType(aType) + , mDeprecatedTextureHostFlags(0) + , mTextureFlags(0) + {} + + bool operator==(const TextureInfo& aOther) const + { + return mCompositableType == aOther.mCompositableType && + mDeprecatedTextureHostFlags == aOther.mDeprecatedTextureHostFlags && + mTextureFlags == aOther.mTextureFlags; + } +}; + +/** + * How a SurfaceDescriptor will be opened. + * + * See ShadowLayerForwarder::OpenDescriptor for example. + */ +typedef uint32_t OpenMode; +const OpenMode OPEN_READ = 0x1; +const OpenMode OPEN_WRITE = 0x2; +const OpenMode OPEN_READ_WRITE = OPEN_READ|OPEN_WRITE; +const OpenMode OPEN_READ_ONLY = OPEN_READ; +const OpenMode OPEN_WRITE_ONLY = OPEN_WRITE; + +// The kinds of mask texture a shader can support +// We rely on the items in this enum being sequential +enum MaskType { + MaskNone = 0, // no mask layer + Mask2d, // mask layer for layers with 2D transforms + Mask3d, // mask layer for layers with 3D transforms + NumMaskTypes +}; + +} // namespace layers +} // namespace mozilla + +#endif