shell/gpu/gpu_surface_gl.cc - mirrors/engine - Git at Google

 // Copyright 2016 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 "gpu_surface_gl.h"

 #include "flutter/glue/trace_event.h"
 #include "lib/fxl/arraysize.h"
 #include "lib/fxl/logging.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrBackendSurface.h"
 #include "third_party/skia/include/gpu/GrContextOptions.h"
 #include "third_party/skia/include/gpu/gl/GrGLInterface.h"

 namespace shell {

 // Default maximum number of budgeted resources in the cache.
 static const int kGrCacheMaxCount = 8192;

 // Default maximum number of bytes of GPU memory of budgeted resources in the
 // cache.
 static const size_t kGrCacheMaxByteSize = 512 * (1 << 20);

 GPUSurfaceGL::GPUSurfaceGL(GPUSurfaceGLDelegate* delegate)
     : delegate_(delegate), weak_factory_(this) {
   if (!delegate_->GLContextMakeCurrent()) {
     FXL_LOG(ERROR)
         << "Could not make the context current to setup the gr context.";
     return;
   }

   auto backend_context =
       reinterpret_cast<GrBackendContext>(GrGLCreateNativeInterface());

   GrContextOptions options;
   options.fRequireDecodeDisableForSRGB = false;

   auto context = sk_sp<GrContext>(
       GrContext::Create(kOpenGL_GrBackend, backend_context, options));

   if (context == nullptr) {
     FXL_LOG(ERROR) << "Failed to setup Skia Gr context.";
     return;
   }

   context_ = std::move(context);

   context_->setResourceCacheLimits(kGrCacheMaxCount, kGrCacheMaxByteSize);

   delegate_->GLContextClearCurrent();

   valid_ = true;
 }

 GPUSurfaceGL::~GPUSurfaceGL() {
   if (!valid_) {
     return;
   }

   if (!delegate_->GLContextMakeCurrent()) {
     FXL_LOG(ERROR) << "Could not make the context current to destroy the "
                       "GrContext resources.";
     return;
   }

   onscreen_surface_ = nullptr;
   offscreen_surface_ = nullptr;
   context_->releaseResourcesAndAbandonContext();
   context_ = nullptr;

   delegate_->GLContextClearCurrent();
 }

 bool GPUSurfaceGL::IsValid() {
   return valid_;
 }

 static GrPixelConfig FirstSupportedNonSRGBConfig(GrContext* context) {
 #define RETURN_IF_RENDERABLE(x)                          \
   if (context->caps()->isConfigRenderable((x), false)) { \
     return (x);                                          \
   }

   RETURN_IF_RENDERABLE(kRGBA_8888_GrPixelConfig);
   RETURN_IF_RENDERABLE(kRGBA_4444_GrPixelConfig);
   RETURN_IF_RENDERABLE(kRGB_565_GrPixelConfig);
   return kUnknown_GrPixelConfig;
 }

 static sk_sp<SkSurface> WrapOnscreenSurface(GrContext* context,
                                             const SkISize& size,
                                             intptr_t fbo,
                                             bool supports_srgb) {
   const GrGLFramebufferInfo framebuffer_info = {
       .fFBOID = static_cast<GrGLuint>(fbo),
   };

   const GrPixelConfig pixel_config = supports_srgb
                                          ? kSRGBA_8888_GrPixelConfig
                                          : FirstSupportedNonSRGBConfig(context);

   GrBackendRenderTarget render_target(size.fWidth,      // width
                                       size.fHeight,     // height
                                       0,                // sample count
                                       0,                // stencil bits (TODO)
                                       pixel_config,     // pixel config
                                       framebuffer_info  // framebuffer info
   );

   sk_sp<SkColorSpace> colorspace =
       supports_srgb ? SkColorSpace::MakeSRGB() : nullptr;

   SkSurfaceProps surface_props(
       SkSurfaceProps::InitType::kLegacyFontHost_InitType);

   return SkSurface::MakeFromBackendRenderTarget(
       context,                                       // gr context
       render_target,                                 // render target
       GrSurfaceOrigin::kBottomLeft_GrSurfaceOrigin,  // origin
       colorspace,                                    // colorspace
       &surface_props                                 // surface properties
   );
 }

 static sk_sp<SkSurface> CreateOffscreenSurface(GrContext* context,
                                                const SkISize& size) {
   const SkImageInfo image_info =
       SkImageInfo::MakeS32(size.fWidth, size.fHeight, kOpaque_SkAlphaType);

   const SkSurfaceProps surface_props(
       SkSurfaceProps::InitType::kLegacyFontHost_InitType);

   return SkSurface::MakeRenderTarget(
       context,                      // context
       SkBudgeted::kNo,              // budgeted
       image_info,                   // image info
       0,                            // sample count
       kBottomLeft_GrSurfaceOrigin,  // surface origin
       &surface_props                // surface props
   );
 }

 bool GPUSurfaceGL::CreateOrUpdateSurfaces(const SkISize& size) {
   if (onscreen_surface_ != nullptr &&
       size == SkISize::Make(onscreen_surface_->width(),
                             onscreen_surface_->height())) {
     // We know that if there is an offscreen surface, it will be sized to be
     // equal to the size of the onscreen surface. And the onscreen surface size
     // appears unchanged. So bail.
     return true;
   }

   // We need to do some updates.
   TRACE_EVENT0("flutter", "UpdateSurfacesSize");

   // Either way, we need to get rid of previous surfaces.
   onscreen_surface_ = nullptr;
   offscreen_surface_ = nullptr;

   if (size.isEmpty()) {
     FXL_LOG(ERROR) << "Cannot create surfaces of empty size.";
     return false;
   }

   sk_sp<SkSurface> onscreen_surface, offscreen_surface;

   const bool surface_supports_srgb = delegate_->SurfaceSupportsSRGB();

   onscreen_surface = WrapOnscreenSurface(
       context_.get(), size, delegate_->GLContextFBO(), surface_supports_srgb);

   if (onscreen_surface == nullptr) {
     // If the onscreen surface could not be wrapped. There is absolutely no
     // point in moving forward.
     FXL_LOG(ERROR) << "Could not wrap onscreen surface.";
     return false;
   }

   if (!surface_supports_srgb) {
     offscreen_surface = CreateOffscreenSurface(context_.get(), size);
     if (offscreen_surface == nullptr) {
       // If the offscreen surface was needed but could not be wrapped. Render to
       // the onscreen surface directly but warn the user that color correctness
       // is not available.
       static bool warned_once = false;
       if (!warned_once) {
         warned_once = true;
         FXL_LOG(ERROR) << "WARNING: Could not create offscreen surface. This "
                           "device or emulator does not support "
                           "color correct rendering. Fallbacks are in effect. "
                           "Colors on this device will differ from those "
                           "displayed on most other devices. This warning will "
                           "only be logged once.";
       }
     }
   }

   onscreen_surface_ = std::move(onscreen_surface);
   offscreen_surface_ = std::move(offscreen_surface);

   return true;
 }

 std::unique_ptr<SurfaceFrame> GPUSurfaceGL::AcquireFrame(const SkISize& size) {
   if (delegate_ == nullptr) {
     return nullptr;
   }

   if (!delegate_->GLContextMakeCurrent()) {
     FXL_LOG(ERROR)
         << "Could not make the context current to acquire the frame.";
     return nullptr;
   }

   sk_sp<SkSurface> surface = AcquireRenderSurface(size);

   if (surface == nullptr) {
     return nullptr;
   }

   auto weak_this = weak_factory_.GetWeakPtr();

   SurfaceFrame::SubmitCallback submit_callback =
       [weak_this](const SurfaceFrame& surface_frame, SkCanvas* canvas) {
         return weak_this ? weak_this->PresentSurface(canvas) : false;
       };

   return std::make_unique<SurfaceFrame>(surface, submit_callback);
 }

 bool GPUSurfaceGL::PresentSurface(SkCanvas* canvas) {
   if (delegate_ == nullptr || canvas == nullptr || context_ == nullptr) {
     return false;
   }

   if (offscreen_surface_ != nullptr) {
     // Because the surface did not support sRGB, we rendered to an offscreen
     // surface. Now we must ensure that the texture is copied onscreen.
     TRACE_EVENT0("flutter", "CopyTextureOnscreen");
     SkPaint paint;
     const GrCaps* caps = context_->caps();
     if (caps->srgbSupport() && !caps->srgbDecodeDisableSupport()) {
       paint.setColorFilter(SkColorFilter::MakeLinearToSRGBGamma());
     }
     onscreen_surface_->getCanvas()->drawImage(
         offscreen_surface_->makeImageSnapshot(),  // image
         0,                                        // left
         0,                                        // top
         &paint                                    // paint
     );
   }

   {
     TRACE_EVENT0("flutter", "SkCanvas::Flush");
     onscreen_surface_->getCanvas()->flush();
   }

   delegate_->GLContextPresent();

   return true;
 }

 sk_sp<SkSurface> GPUSurfaceGL::AcquireRenderSurface(const SkISize& size) {
   if (!CreateOrUpdateSurfaces(size)) {
     return nullptr;
   }

   return offscreen_surface_ != nullptr ? offscreen_surface_ : onscreen_surface_;
 }

 GrContext* GPUSurfaceGL::GetContext() {
   return context_.get();
 }

 }  // namespace shell
	// Copyright 2016 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 "gpu_surface_gl.h"

	#include "flutter/glue/trace_event.h"
	#include "lib/fxl/arraysize.h"
	#include "lib/fxl/logging.h"
	#include "third_party/skia/include/core/SkColorFilter.h"
	#include "third_party/skia/include/core/SkSurface.h"
	#include "third_party/skia/include/gpu/GrBackendSurface.h"
	#include "third_party/skia/include/gpu/GrContextOptions.h"
	#include "third_party/skia/include/gpu/gl/GrGLInterface.h"

	namespace shell {

	// Default maximum number of budgeted resources in the cache.
	static const int kGrCacheMaxCount = 8192;

	// Default maximum number of bytes of GPU memory of budgeted resources in the
	// cache.
	static const size_t kGrCacheMaxByteSize = 512 * (1 << 20);

	GPUSurfaceGL::GPUSurfaceGL(GPUSurfaceGLDelegate* delegate)
	: delegate_(delegate), weak_factory_(this) {
	if (!delegate_->GLContextMakeCurrent()) {
	FXL_LOG(ERROR)
	<< "Could not make the context current to setup the gr context.";
	return;
	}

	auto backend_context =
	reinterpret_cast<GrBackendContext>(GrGLCreateNativeInterface());

	GrContextOptions options;
	options.fRequireDecodeDisableForSRGB = false;

	auto context = sk_sp<GrContext>(
	GrContext::Create(kOpenGL_GrBackend, backend_context, options));

	if (context == nullptr) {
	FXL_LOG(ERROR) << "Failed to setup Skia Gr context.";
	return;
	}

	context_ = std::move(context);

	context_->setResourceCacheLimits(kGrCacheMaxCount, kGrCacheMaxByteSize);

	delegate_->GLContextClearCurrent();

	valid_ = true;
	}

	GPUSurfaceGL::~GPUSurfaceGL() {
	if (!valid_) {
	return;
	}

	if (!delegate_->GLContextMakeCurrent()) {
	FXL_LOG(ERROR) << "Could not make the context current to destroy the "
	"GrContext resources.";
	return;
	}

	onscreen_surface_ = nullptr;
	offscreen_surface_ = nullptr;
	context_->releaseResourcesAndAbandonContext();
	context_ = nullptr;

	delegate_->GLContextClearCurrent();
	}

	bool GPUSurfaceGL::IsValid() {
	return valid_;
	}

	static GrPixelConfig FirstSupportedNonSRGBConfig(GrContext* context) {
	#define RETURN_IF_RENDERABLE(x) \
	if (context->caps()->isConfigRenderable((x), false)) { \
	return (x); \
	}

	RETURN_IF_RENDERABLE(kRGBA_8888_GrPixelConfig);
	RETURN_IF_RENDERABLE(kRGBA_4444_GrPixelConfig);
	RETURN_IF_RENDERABLE(kRGB_565_GrPixelConfig);
	return kUnknown_GrPixelConfig;
	}

	static sk_sp<SkSurface> WrapOnscreenSurface(GrContext* context,
	const SkISize& size,
	intptr_t fbo,
	bool supports_srgb) {
	const GrGLFramebufferInfo framebuffer_info = {
	.fFBOID = static_cast<GrGLuint>(fbo),
	};

	const GrPixelConfig pixel_config = supports_srgb
	? kSRGBA_8888_GrPixelConfig
	: FirstSupportedNonSRGBConfig(context);

	GrBackendRenderTarget render_target(size.fWidth, // width
	size.fHeight, // height
	0, // sample count
	0, // stencil bits (TODO)
	pixel_config, // pixel config
	framebuffer_info // framebuffer info
	);

	sk_sp<SkColorSpace> colorspace =
	supports_srgb ? SkColorSpace::MakeSRGB() : nullptr;

	SkSurfaceProps surface_props(
	SkSurfaceProps::InitType::kLegacyFontHost_InitType);

	return SkSurface::MakeFromBackendRenderTarget(
	context, // gr context
	render_target, // render target
	GrSurfaceOrigin::kBottomLeft_GrSurfaceOrigin, // origin
	colorspace, // colorspace
	&surface_props // surface properties
	);
	}

	static sk_sp<SkSurface> CreateOffscreenSurface(GrContext* context,
	const SkISize& size) {
	const SkImageInfo image_info =
	SkImageInfo::MakeS32(size.fWidth, size.fHeight, kOpaque_SkAlphaType);

	const SkSurfaceProps surface_props(
	SkSurfaceProps::InitType::kLegacyFontHost_InitType);

	return SkSurface::MakeRenderTarget(
	context, // context
	SkBudgeted::kNo, // budgeted
	image_info, // image info
	0, // sample count
	kBottomLeft_GrSurfaceOrigin, // surface origin
	&surface_props // surface props
	);
	}

	bool GPUSurfaceGL::CreateOrUpdateSurfaces(const SkISize& size) {
	if (onscreen_surface_ != nullptr &&
	size == SkISize::Make(onscreen_surface_->width(),
	onscreen_surface_->height())) {
	// We know that if there is an offscreen surface, it will be sized to be
	// equal to the size of the onscreen surface. And the onscreen surface size
	// appears unchanged. So bail.
	return true;
	}

	// We need to do some updates.
	TRACE_EVENT0("flutter", "UpdateSurfacesSize");

	// Either way, we need to get rid of previous surfaces.
	onscreen_surface_ = nullptr;
	offscreen_surface_ = nullptr;

	if (size.isEmpty()) {
	FXL_LOG(ERROR) << "Cannot create surfaces of empty size.";
	return false;
	}

	sk_sp<SkSurface> onscreen_surface, offscreen_surface;

	const bool surface_supports_srgb = delegate_->SurfaceSupportsSRGB();

	onscreen_surface = WrapOnscreenSurface(
	context_.get(), size, delegate_->GLContextFBO(), surface_supports_srgb);

	if (onscreen_surface == nullptr) {
	// If the onscreen surface could not be wrapped. There is absolutely no
	// point in moving forward.
	FXL_LOG(ERROR) << "Could not wrap onscreen surface.";
	return false;
	}

	if (!surface_supports_srgb) {
	offscreen_surface = CreateOffscreenSurface(context_.get(), size);
	if (offscreen_surface == nullptr) {
	// If the offscreen surface was needed but could not be wrapped. Render to
	// the onscreen surface directly but warn the user that color correctness
	// is not available.
	static bool warned_once = false;
	if (!warned_once) {
	warned_once = true;
	FXL_LOG(ERROR) << "WARNING: Could not create offscreen surface. This "
	"device or emulator does not support "
	"color correct rendering. Fallbacks are in effect. "
	"Colors on this device will differ from those "
	"displayed on most other devices. This warning will "
	"only be logged once.";
	}
	}
	}

	onscreen_surface_ = std::move(onscreen_surface);
	offscreen_surface_ = std::move(offscreen_surface);

	return true;
	}

	std::unique_ptr<SurfaceFrame> GPUSurfaceGL::AcquireFrame(const SkISize& size) {
	if (delegate_ == nullptr) {
	return nullptr;
	}

	if (!delegate_->GLContextMakeCurrent()) {
	FXL_LOG(ERROR)
	<< "Could not make the context current to acquire the frame.";
	return nullptr;
	}

	sk_sp<SkSurface> surface = AcquireRenderSurface(size);

	if (surface == nullptr) {
	return nullptr;
	}

	auto weak_this = weak_factory_.GetWeakPtr();

	SurfaceFrame::SubmitCallback submit_callback =
	[weak_this](const SurfaceFrame& surface_frame, SkCanvas* canvas) {
	return weak_this ? weak_this->PresentSurface(canvas) : false;
	};

	return std::make_unique<SurfaceFrame>(surface, submit_callback);
	}

	bool GPUSurfaceGL::PresentSurface(SkCanvas* canvas) {
	if (delegate_ == nullptr \|\| canvas == nullptr \|\| context_ == nullptr) {
	return false;
	}

	if (offscreen_surface_ != nullptr) {
	// Because the surface did not support sRGB, we rendered to an offscreen
	// surface. Now we must ensure that the texture is copied onscreen.
	TRACE_EVENT0("flutter", "CopyTextureOnscreen");
	SkPaint paint;
	const GrCaps* caps = context_->caps();
	if (caps->srgbSupport() && !caps->srgbDecodeDisableSupport()) {
	paint.setColorFilter(SkColorFilter::MakeLinearToSRGBGamma());
	}
	onscreen_surface_->getCanvas()->drawImage(
	offscreen_surface_->makeImageSnapshot(), // image
	0, // left
	0, // top
	&paint // paint
	);
	}

	{
	TRACE_EVENT0("flutter", "SkCanvas::Flush");
	onscreen_surface_->getCanvas()->flush();
	}

	delegate_->GLContextPresent();

	return true;
	}

	sk_sp<SkSurface> GPUSurfaceGL::AcquireRenderSurface(const SkISize& size) {
	if (!CreateOrUpdateSurfaces(size)) {
	return nullptr;
	}

	return offscreen_surface_ != nullptr ? offscreen_surface_ : onscreen_surface_;
	}

	GrContext* GPUSurfaceGL::GetContext() {
	return context_.get();
	}

	} // namespace shell