chromium/third_party/angle/src/libANGLE/Surface.cpp

//
// Copyright 2002 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

// Surface.cpp: Implements the egl::Surface class, representing a drawing surface
// such as the client area of a window, including any back buffers.
// Implements EGLSurface and related functionality. [EGL 1.4] section 2.2 page 3.

#include "libANGLE/Surface.h"

#include <EGL/eglext.h>

#include "libANGLE/Config.h"
#include "libANGLE/Context.h"
#include "libANGLE/Display.h"
#include "libANGLE/Framebuffer.h"
#include "libANGLE/Texture.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/renderer/EGLImplFactory.h"
#include "libANGLE/trace.h"

namespace egl
{
namespace
{
angle::SubjectIndex kSurfaceImplSubjectIndex = …;
}  // namespace

SurfaceState::SurfaceState(SurfaceID idIn,
                           const egl::Config *configIn,
                           const AttributeMap &attributesIn)
    : … { … }

SurfaceState::~SurfaceState()
{ … }

bool SurfaceState::isRobustResourceInitEnabled() const
{ … }

bool SurfaceState::hasProtectedContent() const
{ … }

EGLint SurfaceState::getPreferredSwapInterval() const
{ … }

Surface::Surface(EGLint surfaceType,
                 SurfaceID id,
                 const egl::Config *config,
                 const AttributeMap &attributes,
                 bool forceRobustResourceInit,
                 EGLenum buftype)
    : … { … }

Surface::~Surface() { … }

rx::FramebufferAttachmentObjectImpl *Surface::getAttachmentImpl() const
{ … }

Error Surface::destroyImpl(const Display *display)
{ … }

void Surface::postSwap(const gl::Context *context)
{ … }

Error Surface::initialize(const Display *display)
{ … }

Error Surface::makeCurrent(const gl::Context *context)
{ … }

Error Surface::unMakeCurrent(const gl::Context *context)
{ … }

Error Surface::releaseRef(const Display *display)
{ … }

Error Surface::onDestroy(const Display *display)
{ … }

void Surface::setLabel(EGLLabelKHR label)
{ … }

EGLLabelKHR Surface::getLabel() const
{ … }

EGLint Surface::getType() const
{ … }

Error Surface::prepareSwap(const gl::Context *context)
{ … }

Error Surface::swap(gl::Context *context)
{ … }

Error Surface::swapWithDamage(gl::Context *context, const EGLint *rects, EGLint n_rects)
{ … }

Error Surface::swapWithFrameToken(gl::Context *context, EGLFrameTokenANGLE frameToken)
{ … }

Error Surface::postSubBuffer(const gl::Context *context,
                             EGLint x,
                             EGLint y,
                             EGLint width,
                             EGLint height)
{ … }

Error Surface::setPresentationTime(EGLnsecsANDROID time)
{ … }

Error Surface::querySurfacePointerANGLE(EGLint attribute, void **value)
{ … }

EGLint Surface::isPostSubBufferSupported() const
{ … }

void Surface::setSwapInterval(EGLint interval)
{ … }

void Surface::setMipmapLevel(EGLint level)
{ … }

void Surface::setMultisampleResolve(EGLenum resolve)
{ … }

void Surface::setSwapBehavior(EGLenum behavior)
{ … }

void Surface::setFixedWidth(EGLint width)
{ … }

void Surface::setFixedHeight(EGLint height)
{ … }

const Config *Surface::getConfig() const
{ … }

EGLint Surface::getPixelAspectRatio() const
{ … }

EGLenum Surface::getRenderBuffer() const
{ … }

EGLenum Surface::getSwapBehavior() const
{ … }

TextureFormat Surface::getTextureFormat() const
{ … }

EGLenum Surface::getTextureTarget() const
{ … }

bool Surface::getLargestPbuffer() const
{ … }

EGLenum Surface::getGLColorspace() const
{ … }

EGLenum Surface::getVGAlphaFormat() const
{ … }

EGLenum Surface::getVGColorspace() const
{ … }

bool Surface::getMipmapTexture() const
{ … }

EGLint Surface::getMipmapLevel() const
{ … }

EGLint Surface::getHorizontalResolution() const
{ … }

EGLint Surface::getVerticalResolution() const
{ … }

EGLenum Surface::getMultisampleResolve() const
{ … }

EGLint Surface::isFixedSize() const
{ … }

EGLint Surface::getWidth() const
{ … }

EGLint Surface::getHeight() const
{ … }

egl::Error Surface::getUserWidth(const egl::Display *display, EGLint *value) const
{ … }

egl::Error Surface::getUserHeight(const egl::Display *display, EGLint *value) const
{ … }

Error Surface::bindTexImage(gl::Context *context, gl::Texture *texture, EGLint buffer)
{ … }

Error Surface::releaseTexImage(const gl::Context *context, EGLint buffer)
{ … }

Error Surface::getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc)
{ … }

Error Surface::getMscRate(EGLint *numerator, EGLint *denominator)
{ … }

Error Surface::releaseTexImageFromTexture(const gl::Context *context)
{ … }

gl::Extents Surface::getAttachmentSize(const gl::ImageIndex & /*target*/) const
{ … }

gl::Format Surface::getAttachmentFormat(GLenum binding, const gl::ImageIndex &target) const
{ … }

GLsizei Surface::getAttachmentSamples(const gl::ImageIndex &target) const
{ … }

bool Surface::isRenderable(const gl::Context *context,
                           GLenum binding,
                           const gl::ImageIndex &imageIndex) const
{ … }

bool Surface::isYUV() const
{ … }

bool Surface::isExternalImageWithoutIndividualSync() const
{ … }

bool Surface::hasFrontBufferUsage() const
{ … }

GLuint Surface::getId() const
{ … }

Error Surface::getBufferAgeImpl(const gl::Context *context, EGLint *age) const
{ … }

Error Surface::getBufferAge(const gl::Context *context, EGLint *age)
{ … }

gl::InitState Surface::initState(GLenum binding, const gl::ImageIndex & /*imageIndex*/) const
{ … }

void Surface::setInitState(GLenum binding,
                           const gl::ImageIndex & /*imageIndex*/,
                           gl::InitState initState)
{ … }

void Surface::setTimestampsEnabled(bool enabled)
{ … }

bool Surface::isTimestampsEnabled() const
{ … }

Error Surface::setAutoRefreshEnabled(bool enabled)
{ … }

bool Surface::hasProtectedContent() const
{ … }

const SupportedCompositorTiming &Surface::getSupportedCompositorTimings() const
{ … }

Error Surface::getCompositorTiming(EGLint numTimestamps,
                                   const EGLint *names,
                                   EGLnsecsANDROID *values) const
{ … }

Error Surface::getNextFrameId(EGLuint64KHR *frameId) const
{ … }

const SupportedTimestamps &Surface::getSupportedTimestamps() const
{ … }

Error Surface::getFrameTimestamps(EGLuint64KHR frameId,
                                  EGLint numTimestamps,
                                  const EGLint *timestamps,
                                  EGLnsecsANDROID *values) const
{ … }

void Surface::onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message)
{ … }

Error Surface::setRenderBuffer(EGLint renderBuffer)
{ … }

bool Surface::isLocked() const
{ … }

EGLint Surface::getBitmapPitch() const
{ … }

EGLint Surface::getBitmapOrigin() const
{ … }

EGLint Surface::getRedOffset() const
{ … }

EGLint Surface::getGreenOffset() const
{ … }

EGLint Surface::getBlueOffset() const
{ … }

EGLint Surface::getAlphaOffset() const
{ … }

EGLint Surface::getLuminanceOffset() const
{ … }

EGLint Surface::getBitmapPixelSize() const
{ … }

EGLAttribKHR Surface::getBitmapPointer() const
{ … }

egl::Error Surface::lockSurfaceKHR(const egl::Display *display, const AttributeMap &attributes)
{ … }

egl::Error Surface::unlockSurfaceKHR(const egl::Display *display)
{ … }

WindowSurface::WindowSurface(rx::EGLImplFactory *implFactory,
                             SurfaceID id,
                             const egl::Config *config,
                             EGLNativeWindowType window,
                             const AttributeMap &attribs,
                             bool robustResourceInit)
    : … { … }

void Surface::setDamageRegion(const EGLint *rects, EGLint n_rects)
{ … }

WindowSurface::~WindowSurface() { … }

PbufferSurface::PbufferSurface(rx::EGLImplFactory *implFactory,
                               SurfaceID id,
                               const Config *config,
                               const AttributeMap &attribs,
                               bool robustResourceInit)
    : … { … }

PbufferSurface::PbufferSurface(rx::EGLImplFactory *implFactory,
                               SurfaceID id,
                               const Config *config,
                               EGLenum buftype,
                               EGLClientBuffer clientBuffer,
                               const AttributeMap &attribs,
                               bool robustResourceInit)
    : … { … }

PbufferSurface::~PbufferSurface() { … }

PixmapSurface::PixmapSurface(rx::EGLImplFactory *implFactory,
                             SurfaceID id,
                             const Config *config,
                             NativePixmapType nativePixmap,
                             const AttributeMap &attribs,
                             bool robustResourceInit)
    : … { … }

PixmapSurface::~PixmapSurface() { … }

// SurfaceDeleter implementation.

SurfaceDeleter::SurfaceDeleter(const Display *display) : … { … }

SurfaceDeleter::~SurfaceDeleter() { … }

void SurfaceDeleter::operator()(Surface *surface)
{ … }

}  // namespace egl