blob: 547a3ec0bf9e3fe8a457b8f79331c167ae629031 [file] [log] [blame]
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <stddef.h>
#include <stdint.h>
#include "base/memory/unsafe_shared_memory_region.h"
#include "build/build_config.h"
#include "ui/gfx/buffer_types.h"
#include "ui/gfx/generic_shared_memory_id.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/gfx_export.h"
#if defined(USE_OZONE) || defined(OS_LINUX)
#include "ui/gfx/native_pixmap_handle.h"
#elif defined(OS_MACOSX) && !defined(OS_IOS)
#include "ui/gfx/mac/io_surface.h"
#elif defined(OS_WIN)
#include "ipc/ipc_platform_file.h" // nogncheck
#elif defined(OS_ANDROID)
#include "base/android/scoped_hardware_buffer_handle.h"
extern "C" typedef struct _ClientBuffer* ClientBuffer;
namespace base {
namespace trace_event {
class ProcessMemoryDump;
class MemoryAllocatorDumpGuid;
} // namespace trace_event
} // namespace base
namespace gfx {
class ColorSpace;
enum GpuMemoryBufferType {
using GpuMemoryBufferId = GenericSharedMemoryId;
// TODO( Convert this to a proper class to ensure the state is
// always consistent, particularly that the only one handle is set at the same
// time and it corresponds to |type|.
struct GFX_EXPORT GpuMemoryBufferHandle {
GpuMemoryBufferHandle(GpuMemoryBufferHandle&& other);
GpuMemoryBufferHandle& operator=(GpuMemoryBufferHandle&& other);
GpuMemoryBufferHandle Clone() const;
bool is_null() const { return type == EMPTY_BUFFER; }
GpuMemoryBufferType type;
GpuMemoryBufferId id;
base::UnsafeSharedMemoryRegion region;
uint32_t offset;
int32_t stride;
#if defined(OS_LINUX) || defined(OS_FUCHSIA)
NativePixmapHandle native_pixmap_handle;
#elif defined(OS_MACOSX) && !defined(OS_IOS)
ScopedRefCountedIOSurfaceMachPort mach_port;
#elif defined(OS_WIN)
// TODO( convert this to a scoped handle.
IPC::PlatformFileForTransit dxgi_handle;
#elif defined(OS_ANDROID)
base::android::ScopedHardwareBufferHandle android_hardware_buffer;
// This interface typically correspond to a type of shared memory that is also
// shared with the GPU. A GPU memory buffer can be written to directly by
// regular CPU code, but can also be read by the GPU.
class GFX_EXPORT GpuMemoryBuffer {
virtual ~GpuMemoryBuffer() {}
// Maps each plane of the buffer into the client's address space so it can be
// written to by the CPU. This call may block, for instance if the GPU needs
// to finish accessing the buffer or if CPU caches need to be synchronized.
// Returns false on failure.
virtual bool Map() = 0;
// Returns a pointer to the memory address of a plane. Buffer must have been
// successfully mapped using a call to Map() before calling this function.
virtual void* memory(size_t plane) = 0;
// Unmaps the buffer. It's illegal to use any pointer returned by memory()
// after this has been called.
virtual void Unmap() = 0;
// Returns the size for the buffer.
virtual Size GetSize() const = 0;
// Returns the format for the buffer.
virtual BufferFormat GetFormat() const = 0;
// Fills the stride in bytes for each plane of the buffer. The stride of
// plane K is stored at index K-1 of the |stride| array.
virtual int stride(size_t plane) const = 0;
// Set the color space in which this buffer should be interpreted when used
// as an overlay. Note that this will not impact texturing from the buffer.
virtual void SetColorSpace(const gfx::ColorSpace& color_space);
// Returns a unique identifier associated with buffer.
virtual GpuMemoryBufferId GetId() const = 0;
// Returns the type of this buffer.
virtual GpuMemoryBufferType GetType() const = 0;
// Returns a platform specific handle for this buffer which in particular can
// be sent over IPC. This duplicates file handles as appropriate, so that a
// caller takes ownership of the returned handle.
virtual GpuMemoryBufferHandle CloneHandle() const = 0;
// Type-checking downcast routine.
virtual ClientBuffer AsClientBuffer() = 0;
// Dumps information about the memory backing the GpuMemoryBuffer to |pmd|.
// The memory usage is attributed to |buffer_dump_guid|.
// |tracing_process_id| uniquely identifies the process owning the memory.
// |importance| is relevant only for the cases of co-ownership, the memory
// gets attributed to the owner with the highest importance.
virtual void OnMemoryDump(
base::trace_event::ProcessMemoryDump* pmd,
const base::trace_event::MemoryAllocatorDumpGuid& buffer_dump_guid,
uint64_t tracing_process_id,
int importance) const = 0;
} // namespace gfx