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

//
// Copyright 2015 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.
//

// Image.cpp: Implements the egl::Image class representing the EGLimage object.

#include "libANGLE/Image.h"

#include "common/debug.h"
#include "common/utilities.h"
#include "libANGLE/Context.h"
#include "libANGLE/Renderbuffer.h"
#include "libANGLE/Texture.h"
#include "libANGLE/angletypes.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/renderer/EGLImplFactory.h"
#include "libANGLE/renderer/ImageImpl.h"

namespace egl
{

namespace
{
gl::ImageIndex GetImageIndex(EGLenum eglTarget, const egl::AttributeMap &attribs)
{ … }

const Display *DisplayFromContext(const gl::Context *context)
{ … }

angle::SubjectIndex kExternalImageImplSubjectIndex = …;
}  // anonymous namespace

ImageSibling::ImageSibling() : … { … }

ImageSibling::~ImageSibling()
{ … }

void ImageSibling::setTargetImage(const gl::Context *context, egl::Image *imageTarget)
{ … }

angle::Result ImageSibling::orphanImages(const gl::Context *context,
                                         RefCountObjectReleaser<Image> *outReleaseImage)
{ … }

void ImageSibling::addImageSource(egl::Image *imageSource)
{ … }

void ImageSibling::removeImageSource(egl::Image *imageSource)
{ … }

bool ImageSibling::isEGLImageTarget() const
{ … }

gl::InitState ImageSibling::sourceEGLImageInitState() const
{ … }

void ImageSibling::setSourceEGLImageInitState(gl::InitState initState) const
{ … }

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

bool ImageSibling::isYUV() const
{ … }

bool ImageSibling::isExternalImageWithoutIndividualSync() const
{ … }

bool ImageSibling::hasFrontBufferUsage() const
{ … }

bool ImageSibling::hasProtectedContent() const
{ … }

void ImageSibling::notifySiblings(angle::SubjectMessage message)
{ … }

ExternalImageSibling::ExternalImageSibling(rx::EGLImplFactory *factory,
                                           const gl::Context *context,
                                           EGLenum target,
                                           EGLClientBuffer buffer,
                                           const AttributeMap &attribs)
    : … { … }

ExternalImageSibling::~ExternalImageSibling() = default;

void ExternalImageSibling::onDestroy(const egl::Display *display)
{ … }

Error ExternalImageSibling::initialize(const egl::Display *display, const gl::Context *context)
{ … }

gl::Extents ExternalImageSibling::getAttachmentSize(const gl::ImageIndex &imageIndex) const
{ … }

gl::Format ExternalImageSibling::getAttachmentFormat(GLenum binding,
                                                     const gl::ImageIndex &imageIndex) const
{ … }

GLsizei ExternalImageSibling::getAttachmentSamples(const gl::ImageIndex &imageIndex) const
{ … }

GLuint ExternalImageSibling::getLevelCount() const
{ … }

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

bool ExternalImageSibling::isTextureable(const gl::Context *context) const
{ … }

bool ExternalImageSibling::isYUV() const
{ … }

bool ExternalImageSibling::hasFrontBufferUsage() const
{ … }

bool ExternalImageSibling::isCubeMap() const
{ … }

bool ExternalImageSibling::hasProtectedContent() const
{ … }

void ExternalImageSibling::onAttach(const gl::Context *context, rx::UniqueSerial framebufferSerial)
{ … }

void ExternalImageSibling::onDetach(const gl::Context *context, rx::UniqueSerial framebufferSerial)
{ … }

GLuint ExternalImageSibling::getId() const
{ … }

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

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

rx::ExternalImageSiblingImpl *ExternalImageSibling::getImplementation() const
{ … }

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

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

ImageState::ImageState(ImageID id,
                       EGLenum target,
                       ImageSibling *buffer,
                       const AttributeMap &attribs)
    : … { … }

ImageState::~ImageState() { … }

Image::Image(rx::EGLImplFactory *factory,
             ImageID id,
             const gl::Context *context,
             EGLenum target,
             ImageSibling *buffer,
             const AttributeMap &attribs)
    : … { … }

void Image::onDestroy(const Display *display)
{ … }

Image::~Image()
{ … }

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

EGLLabelKHR Image::getLabel() const
{ … }

void Image::addTargetSibling(ImageSibling *sibling)
{ … }

angle::Result Image::orphanSibling(const gl::Context *context, ImageSibling *sibling)
{ … }

const gl::Format &Image::getFormat() const
{ … }

bool Image::isRenderable(const gl::Context *context) const
{ … }

bool Image::isTexturable(const gl::Context *context) const
{ … }

bool Image::isYUV() const
{ … }

bool Image::isExternalImageWithoutIndividualSync() const
{ … }

bool Image::hasFrontBufferUsage() const
{ … }

bool Image::isCubeMap() const
{ … }

size_t Image::getWidth() const
{ … }

size_t Image::getHeight() const
{ … }

const gl::Extents &Image::getExtents() const
{ … }

bool Image::isLayered() const
{ … }

size_t Image::getSamples() const
{ … }

GLuint Image::getLevelCount() const
{ … }

bool Image::hasProtectedContent() const
{ … }

rx::ImageImpl *Image::getImplementation() const
{ … }

Error Image::initialize(const Display *display, const gl::Context *context)
{ … }

bool Image::orphaned() const
{ … }

gl::InitState Image::sourceInitState() const
{ … }

void Image::setInitState(gl::InitState initState)
{ … }

Error Image::exportVkImage(void *vkImage, void *vkImageCreateInfo)
{ … }

void Image::notifySiblings(const ImageSibling *notifier, angle::SubjectMessage message)
{ … }

}  // namespace egl