DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Mercurial (31ec81b5d7bb)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
/* 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/. */

include protocol PGrallocBuffer;


using gfxIntSize from "nsSize.h";
using struct gfxPoint from "gfxPoint.h";
using struct nsIntRect from "nsRect.h";
using nsIntRegion from "nsRegion.h";
using struct nsIntSize from "nsSize.h";
using struct mozilla::layers::MagicGrallocBufferHandle from "gfxipc/ShadowLayerUtils.h";
using struct mozilla::layers::SurfaceDescriptorX11 from "gfxipc/ShadowLayerUtils.h";
using struct mozilla::null_t from "ipc/IPCMessageUtils.h";
using mozilla::WindowsHandle from "ipc/IPCMessageUtils.h";
using mozilla::gl::SharedTextureHandle from "GLContextTypes.h";
using mozilla::gl::SharedTextureShareType from "GLContextTypes.h";
using mozilla::gfx::SurfaceStreamHandle from "SurfaceTypes.h";
using mozilla::gfx::SurfaceFormat from "mozilla/gfx/Types.h";
using mozilla::gfx::IntSize from "mozilla/gfx/Point.h";

namespace mozilla {
namespace layers {

union MaybeMagicGrallocBufferHandle {
  MagicGrallocBufferHandle;
  null_t;
};

struct SurfaceDescriptorD3D9 {
  // IDirect3DTexture9*
  uintptr_t texture;
};

struct SurfaceDescriptorDIB {
  // gfxWindowsSurface*
  uintptr_t surface;
};

struct SurfaceDescriptorD3D10 {
  WindowsHandle handle;
  bool hasAlpha;
};

struct SurfaceDescriptorMacIOSurface {
  uint32_t surface;
  double scaleFactor;
  bool hasAlpha;
};

struct SharedTextureDescriptor {
  SharedTextureShareType shareType;
  SharedTextureHandle handle;
  nsIntSize size;
  bool inverted;
};

struct BasicShmTileDescriptor {
  Shmem reusableSurface;
};

struct BasicTileDescriptor {
  uintptr_t reusableSurface;
};

struct PlaceholderTileDescriptor {
};

union TileDescriptor {
  BasicTileDescriptor;
  BasicShmTileDescriptor;
  PlaceholderTileDescriptor;
};

struct SurfaceDescriptorTiles {
  nsIntRegion validRegion;
  nsIntRegion paintedRegion;
  TileDescriptor[] tiles;
  int         retainedWidth;
  int         retainedHeight;
  float       resolution;
};

struct NewSurfaceDescriptorGralloc {
  PGrallocBuffer buffer;
  /**
   * android::GraphicBuffer has a size information. But there are cases
   * that GraphicBuffer's size and actual video's size are different.
   * Extra size member is necessary. See Bug 850566.
   */
  IntSize size;
};

// XXX - soon to be removed
struct SurfaceDescriptorGralloc {
  PGrallocBuffer buffer;
  /**
   * android::GraphicBuffer has a size information. But there are cases
   * that GraphicBuffer's size and actual video's size are different.
   * Extra size member is necessary. See Bug 850566.
   */
  nsIntSize size;

  /**
   * We can have one source producing gralloc buffers and sharing them
   * with another source that may also produce its own gralloc buffers.
   * This happens for camera preview buffers sent to video code.  When
   * that happens, the producer can mark the buffer as "external" to
   * prevent its consumer from mistakenly freeing the buffer.
   */
  bool external;

  /**
   * This gralloc 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.
   */
  bool isRBSwapped;
};

struct SurfaceStreamDescriptor {
  SurfaceStreamHandle handle;
  bool yflip;
};

// XXX - can be removed as soon as DeprecatedImageClientSingle is removed
struct YCbCrImage {
  Shmem data;
  uint64_t owner;
};

// XXX remove RGBImage (see bug 847914)
struct RGBImage {
  Shmem data;
  nsIntRect picture;
  uint32_t rgbFormat;
  uint64_t owner;
};

struct MemoryImage {
  uintptr_t data;
  gfxIntSize size;
  uint32_t stride;
  uint32_t format;
};

/**
 * Used for shmem-backed YCbCr and (flavors of) RGBA textures
 */
struct SurfaceDescriptorShmem {
  Shmem data;
  SurfaceFormat format;
};

/**
 * Used for "raw memory"-backed YCbCr and (flavors of) RGBA textures
 */
 struct SurfaceDescriptorMemory {
  uintptr_t data;
  SurfaceFormat format;
};

union SurfaceDescriptor {
  SurfaceDescriptorShmem;
  SurfaceDescriptorMemory;
  SurfaceDescriptorD3D9;
  SurfaceDescriptorDIB;
  SurfaceDescriptorD3D10;
  SurfaceDescriptorX11;
  SharedTextureDescriptor;
  SurfaceStreamDescriptor;
  SurfaceDescriptorMacIOSurface;
  NewSurfaceDescriptorGralloc;
  YCbCrImage;                 // XXX - deprecated
  SurfaceDescriptorGralloc;   // XXX - deprecated
  Shmem;                      // XXX - deprecated
  RGBImage;                   // XXX - deprecated
  MemoryImage;                // XXX - deprecated
  null_t;
};

} // namespace
} // namespace