kc3-lang/angle/src/libANGLE/Image.h

• Show log

  Commit

• Hash : 2eb54074
  Author :
  Date : 2018-08-22T16:41:26
  

  Fix EGLImage pixel format validation
  
  This fixes the scenario when EGLImage source and target have different types.
  For example, a texture is created with unsigned format using glTexImage2D,
  it is used as a source of EGLImage with eglCreateImageKHR,
  and then the EGLImage is used to create a renderbuffer target with
  glEGLImageTargetRenderbufferStorageOES.
  
  OES_EGL_image doesn't specify what should happen in this case,
  but GL implementations (Nexus 5X) seem to allow using this renderbuffer in
  glFramebufferRenderbuffer and the resulting framebuffer is complete.
  Thus, in this case, instead of checking whether the renderbuffer format
  can be used in glFramebufferRenderbuffer, we need to check whether the
  original texture can be used in glFramebufferTexture2D.
  Similarly in reverse direction.
  
  Also, for the case of source renderbuffer and target texture,
  presume that glEGLImageTargetTexture2DOES will succeed regardless of
  renderbuffer format.
  
  1. Add isRenderable and isTexturable checks to egl::Image class,
     and perform different checks depending on source type.
  2. Add isRenderable check to FramebufferAttachment and delegate EGLImage
     attachments check to egl::Image.
  3. Use these checks in validation of EGLImageTargetTexture2D,
     EGLImageTargetRenderbufferStorage and when checking attachment completeness
  
  Bug: angleproject:2567
  
  Change-Id: I8e9f4a2930a4075a4d8464f62582c6825270187e
  Reviewed-on: https://chromium-review.googlesource.com/1192585
  Commit-Queue: Yuly Novikov <ynovikov@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/Image.h

• //
  // Copyright (c) 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.h: Defines the egl::Image class representing the EGLimage object.
  
  #ifndef LIBANGLE_IMAGE_H_
  #define LIBANGLE_IMAGE_H_
  
  #include "common/angleutils.h"
  #include "libANGLE/AttributeMap.h"
  #include "libANGLE/Debug.h"
  #include "libANGLE/Error.h"
  #include "libANGLE/FramebufferAttachment.h"
  #include "libANGLE/RefCountObject.h"
  #include "libANGLE/formatutils.h"
  
  #include <set>
  
  namespace rx
  {
  class EGLImplFactory;
  class ImageImpl;
  }
  
  namespace egl
  {
  class Image;
  class Display;
  
  // Only currently Renderbuffers and Textures can be bound with images. This makes the relationship
  // explicit, and also ensures that an image sibling can determine if it's been initialized or not,
  // which is important for the robust resource init extension with Textures and EGLImages.
  class ImageSibling : public gl::FramebufferAttachmentObject
  {
    public:
      ImageSibling();
      ~ImageSibling() override;
  
      bool isEGLImageTarget() const;
      gl::InitState sourceEGLImageInitState() const;
      void setSourceEGLImageInitState(gl::InitState initState) const;
  
      bool isRenderable(const gl::Context *context,
                        GLenum binding,
                        const gl::ImageIndex &imageIndex) const override;
  
    protected:
      // Set the image target of this sibling
      void setTargetImage(const gl::Context *context, egl::Image *imageTarget);
  
      // Orphan all EGL image sources and targets
      gl::Error orphanImages(const gl::Context *context);
  
    private:
      friend class Image;
  
      // Called from Image only to add a new source image
      void addImageSource(egl::Image *imageSource);
  
      // Called from Image only to remove a source image when the Image is being deleted
      void removeImageSource(egl::Image *imageSource);
  
      std::set<Image *> mSourcesOf;
      BindingPointer<Image> mTargetOf;
  };
  
  struct ImageState : private angle::NonCopyable
  {
      ImageState(EGLenum target, ImageSibling *buffer, const AttributeMap &attribs);
      ~ImageState();
  
      EGLLabelKHR label;
      gl::ImageIndex imageIndex;
      ImageSibling *source;
      std::set<ImageSibling *> targets;
  
      gl::Format format;
      gl::Extents size;
      size_t samples;
      EGLenum sourceType;
  };
  
  class Image final : public RefCountObject, public LabeledObject
  {
    public:
      Image(rx::EGLImplFactory *factory,
            const gl::Context *context,
            EGLenum target,
            ImageSibling *buffer,
            const AttributeMap &attribs);
  
      Error onDestroy(const Display *display) override;
      ~Image() override;
  
      void setLabel(EGLLabelKHR label) override;
      EGLLabelKHR getLabel() const override;
  
      const gl::Format &getFormat() const;
      bool isRenderable(const gl::Context *context) const;
      bool isTexturable(const gl::Context *context) const;
      size_t getWidth() const;
      size_t getHeight() const;
      size_t getSamples() const;
  
      Error initialize(const Display *display);
  
      rx::ImageImpl *getImplementation() const;
  
      bool orphaned() const;
      gl::InitState sourceInitState() const;
      void setInitState(gl::InitState initState);
  
    private:
      friend class ImageSibling;
  
      // Called from ImageSibling only notify the image that a new target sibling exists for state
      // tracking.
      void addTargetSibling(ImageSibling *sibling);
  
      // Called from ImageSibling only to notify the image that a sibling (source or target) has
      // been respecified and state tracking should be updated.
      gl::Error orphanSibling(const gl::Context *context, ImageSibling *sibling);
  
      ImageState mState;
      rx::ImageImpl *mImplementation;
      bool mOrphanedAndNeedsInit;
  };
  }  // namespace egl
  
  #endif  // LIBANGLE_IMAGE_H_
  

Download