ui/gfx/gpu_memory_buffer.h

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef UI_GFX_GPU_MEMORY_BUFFER_H_
   6 #define UI_GFX_GPU_MEMORY_BUFFER_H_
   7
   8 #include "base/memory/shared_memory.h"
   9 #include "build/build_config.h"
  10 #include "ui/gfx/gfx_export.h"
  11
  12 extern "C" typedef struct _ClientBuffer* ClientBuffer;
  13
  14 namespace gfx {
  15
  16 enum GpuMemoryBufferType {
  17   EMPTY_BUFFER,
  18   SHARED_MEMORY_BUFFER,
  19   IO_SURFACE_BUFFER,
  20   SURFACE_TEXTURE_BUFFER,
  21   OZONE_NATIVE_BUFFER,
  22   GPU_MEMORY_BUFFER_TYPE_LAST = OZONE_NATIVE_BUFFER
  23 };
  24
  25 using GpuMemoryBufferId = int32;
  26
  27 struct GFX_EXPORT GpuMemoryBufferHandle {
  28   GpuMemoryBufferHandle();
  29   bool is_null() const { return type == EMPTY_BUFFER; }
  30   GpuMemoryBufferType type;
  31   GpuMemoryBufferId id;
  32   base::SharedMemoryHandle handle;
  33 #if defined(OS_MACOSX)
  34   uint32 io_surface_id;
  35 #endif
  36 };
  37
  38 // This interface typically correspond to a type of shared memory that is also
  39 // shared with the GPU. A GPU memory buffer can be written to directly by
  40 // regular CPU code, but can also be read by the GPU.
  41 class GFX_EXPORT GpuMemoryBuffer {
  42  public:
  43   // The format needs to be taken into account when mapping a buffer into the
  44   // client's address space.
  45   enum Format {
  46     ATC,
  47     ATCIA,
  48     DXT1,
  49     DXT5,
  50     ETC1,
  51     R_8,
  52     RGBA_4444,
  53     RGBA_8888,
  54     RGBX_8888,
  55     BGRA_8888,
  56     YUV_420,
  57
  58     FORMAT_LAST = YUV_420
  59   };
  60
  61   // The usage mode affects how a buffer can be used. Only buffers created with
  62   // MAP can be mapped into the client's address space and accessed by the CPU.
  63   // PERSISTENT_MAP adds the additional condition that successive Map() calls
  64   // (with Unmap() calls between) will return a pointer to the same memory
  65   // contents.
  66   enum Usage { MAP, PERSISTENT_MAP, SCANOUT, USAGE_LAST = SCANOUT };
  67
  68   virtual ~GpuMemoryBuffer() {}
  69
  70   // Maps each plane of the buffer into the client's address space so it can be
  71   // written to by the CPU. A pointer to plane K is stored at index K-1 of the
  72   // |data| array. This call may block, for instance if the GPU needs to finish
  73   // accessing the buffer or if CPU caches need to be synchronized. Returns
  74   // false on failure.
  75   virtual bool Map(void** data) = 0;
  76
  77   // Unmaps the buffer. It's illegal to use the pointer returned by Map() after
  78   // this has been called.
  79   virtual void Unmap() = 0;
  80
  81   // Returns true iff the buffer is mapped.
  82   virtual bool IsMapped() const = 0;
  83
  84   // Returns the format for the buffer.
  85   virtual Format GetFormat() const = 0;
  86
  87   // Fills the stride in bytes for each plane of the buffer. The stride of
  88   // plane K is stored at index K-1 of the |stride| array.
  89   virtual void GetStride(int* stride) const = 0;
  90
  91   // Returns a platform specific handle for this buffer.
  92   virtual GpuMemoryBufferHandle GetHandle() const = 0;
  93
  94   // Type-checking downcast routine.
  95   virtual ClientBuffer AsClientBuffer() = 0;
  96 };
  97
  98 }  // namespace gfx
  99
 100 #endif  // UI_GFX_GPU_MEMORY_BUFFER_H_