kc3-lang/angle/src/libANGLE/renderer/vulkan/ImageVk.cpp

• Show log

  Commit

• Hash : e755a537
  Author :
  Date : 2019-04-10T09:58:21
  

  Vulkan: Add a new garbage type gated by fences.
  
  This allows Vulkan EGL objects such as EGL Syncs and EGL Images to give their
  garbage to the renderer before destroying.
  
  BUG=angleproject:2464
  
  Change-Id: I59b8e1080e4292bd0856e59a928750c7e77a372e
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1562522
  Commit-Queue: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/renderer/vulkan/ImageVk.cpp

• //
  // Copyright 2016 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.
  //
  // ImageVk.cpp:
  //    Implements the class methods for ImageVk.
  //
  
  #include "libANGLE/renderer/vulkan/ImageVk.h"
  
  #include "common/debug.h"
  #include "libANGLE/Context.h"
  #include "libANGLE/Display.h"
  #include "libANGLE/renderer/vulkan/ContextVk.h"
  #include "libANGLE/renderer/vulkan/DisplayVk.h"
  #include "libANGLE/renderer/vulkan/RenderbufferVk.h"
  #include "libANGLE/renderer/vulkan/TextureVk.h"
  #include "libANGLE/renderer/vulkan/vk_utils.h"
  
  namespace rx
  {
  
  ImageVk::ImageVk(const egl::ImageState &state, const gl::Context *context)
      : ImageImpl(state), mImageLevel(0), mOwnsImage(false), mImage(nullptr), mContext(context)
  {}
  
  ImageVk::~ImageVk() {}
  
  void ImageVk::onDestroy(const egl::Display *display)
  {
      DisplayVk *displayVk = vk::GetImpl(display);
      RendererVk *renderer = displayVk->getRenderer();
  
      std::vector<vk::GarbageObjectBase> garbage;
  
      if (mImage != nullptr && mOwnsImage)
      {
          mImage->releaseImage(displayVk, &garbage);
          mImage->releaseStagingBuffer(displayVk, &garbage);
          delete mImage;
      }
      else if (egl::IsExternalImageTarget(mState.target))
      {
          ASSERT(mState.source != nullptr);
          ExternalImageSiblingVk *externalImageSibling =
              GetImplAs<ExternalImageSiblingVk>(GetAs<egl::ExternalImageSibling>(mState.source));
          externalImageSibling->release(displayVk, &garbage);
      }
      mImage = nullptr;
  
      if (!garbage.empty())
      {
          renderer->addGarbage(std::move(mImageLastUseFences), std::move(garbage));
      }
      else
      {
          for (vk::Shared<vk::Fence> &fence : mImageLastUseFences)
          {
              fence.reset(displayVk->getDevice());
          }
      }
  }
  
  egl::Error ImageVk::initialize(const egl::Display *display)
  {
      if (egl::IsTextureTarget(mState.target))
      {
          TextureVk *textureVk = GetImplAs<TextureVk>(GetAs<gl::Texture>(mState.source));
  
          // Make sure the texture has created its backing storage
          ASSERT(mContext != nullptr);
          ContextVk *contextVk = vk::GetImpl(mContext);
          ANGLE_TRY(ResultToEGL(textureVk->ensureImageInitialized(contextVk)));
  
          mImage = &textureVk->getImage();
  
          // The staging buffer for a texture source should already be initialized
  
          mOwnsImage = false;
  
          mImageTextureType = mState.imageIndex.getType();
          mImageLevel       = mState.imageIndex.getLevelIndex();
          mImageLayer       = mState.imageIndex.hasLayer() ? mState.imageIndex.getLayerIndex() : 0;
      }
      else
      {
          RendererVk *renderer = nullptr;
          if (egl::IsRenderbufferTarget(mState.target))
          {
              RenderbufferVk *renderbufferVk =
                  GetImplAs<RenderbufferVk>(GetAs<gl::Renderbuffer>(mState.source));
              mImage = renderbufferVk->getImage();
  
              ASSERT(mContext != nullptr);
              renderer = vk::GetImpl(mContext)->getRenderer();
              ;
          }
          else if (egl::IsExternalImageTarget(mState.target))
          {
              const ExternalImageSiblingVk *externalImageSibling =
                  GetImplAs<ExternalImageSiblingVk>(GetAs<egl::ExternalImageSibling>(mState.source));
              mImage = externalImageSibling->getImage();
  
              ASSERT(mContext == nullptr);
              renderer = vk::GetImpl(display)->getRenderer();
          }
          else
          {
              UNREACHABLE();
              return egl::EglBadAccess();
          }
  
          // Make sure a staging buffer is ready to use to upload data
          mImage->initStagingBuffer(renderer, mImage->getFormat());
  
          mOwnsImage = false;
  
          mImageTextureType = gl::TextureType::_2D;
          mImageLevel       = 0;
          mImageLayer       = 0;
      }
  
      return egl::NoError();
  }
  
  angle::Result ImageVk::orphan(const gl::Context *context, egl::ImageSibling *sibling)
  {
      if (sibling == mState.source)
      {
          if (egl::IsTextureTarget(mState.target))
          {
              TextureVk *textureVk = GetImplAs<TextureVk>(GetAs<gl::Texture>(mState.source));
              ASSERT(mImage == &textureVk->getImage());
              textureVk->releaseOwnershipOfImage(context);
              mOwnsImage = true;
          }
          else if (egl::IsRenderbufferTarget(mState.target))
          {
              RenderbufferVk *renderbufferVk =
                  GetImplAs<RenderbufferVk>(GetAs<gl::Renderbuffer>(mState.source));
              ASSERT(mImage == renderbufferVk->getImage());
              renderbufferVk->releaseOwnershipOfImage(context);
              mOwnsImage = true;
          }
          else
          {
              ANGLE_VK_UNREACHABLE(vk::GetImpl(context));
              return angle::Result::Stop;
          }
      }
  
      // Grab a fence from the releasing context to know when the image is no longer used
      ASSERT(mContext != nullptr);
      ContextVk *contextVk = vk::GetImpl(mContext);
  
      // Flush the context to make sure the fence has been submitted.
      ANGLE_TRY(contextVk->flushImpl());
  
      vk::Shared<vk::Fence> fence = contextVk->getRenderer()->getLastSubmittedFence();
      if (fence.isReferenced())
      {
          mImageLastUseFences.push_back(std::move(fence));
      }
  
      return angle::Result::Continue;
  }
  
  }  // namespace rx
  

Download