diff --git a/flow/compositor_context.h b/flow/compositor_context.h index da0312362c253682417e8bcd9236f01aae540187..c441f11dd357ba3994fd62f8bf96e8fe8d277ecc 100644 --- a/flow/compositor_context.h +++ b/flow/compositor_context.h @@ -21,7 +21,7 @@ class CompositorContext { public: class ScopedFrame { public: - SkCanvas* canvas() { return canvas_; } + SkCanvas& canvas() { return *canvas_; } CompositorContext& context() const { return context_; } diff --git a/flow/layers/layer.h b/flow/layers/layer.h index 699440f37fd4b710624d69b2f9b4d894a0f56d19..8bf787777427caa1057526f530207ea4787ef806 100644 --- a/flow/layers/layer.h +++ b/flow/layers/layer.h @@ -35,7 +35,6 @@ class Layer { struct PrerollContext { RasterCache* raster_cache; GrContext* gr_context; - sk_sp dst_color_space; SkRect child_paint_bounds; }; diff --git a/flow/layers/layer_tree.cc b/flow/layers/layer_tree.cc index 8f3c936e5e06729f23ef25984908d5879e5800ea..0bbbd582235bf839a61da1c21b0dfc1e5d7c04f0 100644 --- a/flow/layers/layer_tree.cc +++ b/flow/layers/layer_tree.cc @@ -27,14 +27,11 @@ void LayerTree::Raster(CompositorContext::ScopedFrame& frame, void LayerTree::Preroll(CompositorContext::ScopedFrame& frame, bool ignore_raster_cache) { TRACE_EVENT0("flutter", "LayerTree::Preroll"); - SkColorSpace* color_space = - frame.canvas() ? frame.canvas()->imageInfo().colorSpace() : nullptr; frame.context().raster_cache().SetCheckboardCacheImages( checkerboard_raster_cache_images_); Layer::PrerollContext context = { ignore_raster_cache ? nullptr : &frame.context().raster_cache(), - frame.gr_context(), sk_ref_sp(color_space), - SkRect::MakeEmpty(), + frame.gr_context(), SkRect::MakeEmpty(), }; root_layer_->Preroll(&context, SkMatrix::I()); } @@ -54,7 +51,7 @@ void LayerTree::UpdateScene(SceneUpdateContext& context, #endif void LayerTree::Paint(CompositorContext::ScopedFrame& frame) { - Layer::PaintContext context = {*frame.canvas(), frame.context().frame_time(), + Layer::PaintContext context = {frame.canvas(), frame.context().frame_time(), frame.context().engine_time(), frame.context().memory_usage(), checkerboard_offscreen_layers_}; diff --git a/flow/layers/picture_layer.cc b/flow/layers/picture_layer.cc index 66bb07f4218971106af98d4b84931bd4af3b6972..cc6a4a86c52dbdaba828bcc4766942ce9cb6096a 100644 --- a/flow/layers/picture_layer.cc +++ b/flow/layers/picture_layer.cc @@ -23,8 +23,7 @@ PictureLayer::~PictureLayer() { void PictureLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) { if (auto cache = context->raster_cache) { raster_cache_result_ = cache->GetPrerolledImage( - context->gr_context, picture_.get(), matrix, context->dst_color_space, - is_complex_, will_change_); + context->gr_context, picture_.get(), matrix, is_complex_, will_change_); } SkRect bounds = picture_->cullRect().makeOffset(offset_.x(), offset_.y()); diff --git a/flow/raster_cache.cc b/flow/raster_cache.cc index d04c7c6b2832f9f766c4901ae5a913bf0a75b116..eb11e1cdb5ecf7302be7a0275421c9856eed8033 100644 --- a/flow/raster_cache.cc +++ b/flow/raster_cache.cc @@ -71,7 +71,6 @@ static bool IsPictureWorthRasterizing(SkPicture* picture, RasterCacheResult RasterizePicture(SkPicture* picture, GrContext* context, const MatrixDecomposition& matrix, - sk_sp dst_color_space, bool checkerboard) { TRACE_EVENT0("flutter", "RasterCachePopulate"); @@ -82,7 +81,7 @@ RasterCacheResult RasterizePicture(SkPicture* picture, std::ceil(logical_rect.width() * std::abs(scale.x())), // physical width std::ceil(logical_rect.height() * std::abs(scale.y())), // physical height - std::move(dst_color_space) // colorspace + nullptr // colorspace ); sk_sp surface = @@ -131,7 +130,6 @@ RasterCacheResult RasterCache::GetPrerolledImage( GrContext* context, SkPicture* picture, const SkMatrix& transformation_matrix, - sk_sp dst_color_space, bool is_complex, bool will_change) { if (!IsPictureWorthRasterizing(picture, will_change, is_complex)) { @@ -161,8 +159,7 @@ RasterCacheResult RasterCache::GetPrerolledImage( if (!entry.image.is_valid()) { entry.image = - RasterizePicture(picture, context, matrix, std::move(dst_color_space), - checkerboard_images_); + RasterizePicture(picture, context, matrix, checkerboard_images_); } // We are not considering unrasterizable images. So if we don't have an image diff --git a/flow/raster_cache.h b/flow/raster_cache.h index 1f6ef798a48604cc1e1513a662ad4404d4964493..9601082cbc7226d3df805337c5aae72914022936 100644 --- a/flow/raster_cache.h +++ b/flow/raster_cache.h @@ -53,10 +53,8 @@ class RasterCache { RasterCacheResult GetPrerolledImage(GrContext* context, SkPicture* picture, const SkMatrix& transformation_matrix, - sk_sp dst_color_space, bool is_complex, bool will_change); - void SweepAfterFrame(); void Clear(); diff --git a/flow/raster_cache_unittests.cc b/flow/raster_cache_unittests.cc index 7e5c7338c52498cbfccb8cf1d43b7a746d5fac12..361a06c34e914af02a4c5c207d2b83b284b57a40 100644 --- a/flow/raster_cache_unittests.cc +++ b/flow/raster_cache_unittests.cc @@ -32,15 +32,14 @@ TEST(RasterCache, ThresholdIsRespected) { sk_sp image; - sk_sp srgb = SkColorSpace::MakeSRGB(); ASSERT_FALSE( - cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb, true, false)); // 1 + cache.GetPrerolledImage(NULL, picture.get(), matrix, true, false)); // 1 cache.SweepAfterFrame(); ASSERT_FALSE( - cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb, true, false)); // 2 + cache.GetPrerolledImage(NULL, picture.get(), matrix, true, false)); // 2 cache.SweepAfterFrame(); ASSERT_TRUE( - cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb, true, false)); // 3 + cache.GetPrerolledImage(NULL, picture.get(), matrix, true, false)); // 3 cache.SweepAfterFrame(); } @@ -54,15 +53,14 @@ TEST(RasterCache, ThresholdIsRespectedWhenZero) { sk_sp image; - sk_sp srgb = SkColorSpace::MakeSRGB(); ASSERT_FALSE( - cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb, true, false)); // 1 + cache.GetPrerolledImage(NULL, picture.get(), matrix, true, false)); // 1 cache.SweepAfterFrame(); ASSERT_FALSE( - cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb, true, false)); // 2 + cache.GetPrerolledImage(NULL, picture.get(), matrix, true, false)); // 2 cache.SweepAfterFrame(); ASSERT_FALSE( - cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb, true, false)); // 3 + cache.GetPrerolledImage(NULL, picture.get(), matrix, true, false)); // 3 cache.SweepAfterFrame(); } @@ -76,20 +74,19 @@ TEST(RasterCache, SweepsRemoveUnusedFrames) { sk_sp image; - sk_sp srgb = SkColorSpace::MakeSRGB(); ASSERT_FALSE( - cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb, true, false)); // 1 + cache.GetPrerolledImage(NULL, picture.get(), matrix, true, false)); // 1 cache.SweepAfterFrame(); ASSERT_FALSE( - cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb, true, false)); // 2 + cache.GetPrerolledImage(NULL, picture.get(), matrix, true, false)); // 2 cache.SweepAfterFrame(); ASSERT_TRUE( - cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb, true, false)); // 3 + cache.GetPrerolledImage(NULL, picture.get(), matrix, true, false)); // 3 cache.SweepAfterFrame(); ASSERT_TRUE( - cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb, true, false)); // 4 + cache.GetPrerolledImage(NULL, picture.get(), matrix, true, false)); // 4 cache.SweepAfterFrame(); cache.SweepAfterFrame(); // Extra frame without a preroll image access. ASSERT_FALSE( - cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb, true, false)); // 5 + cache.GetPrerolledImage(NULL, picture.get(), matrix, true, false)); // 5 } diff --git a/lib/ui/painting/image_decoding.cc b/lib/ui/painting/image_decoding.cc index 9c9a3518675d440d104bf6f8a2b0202c1a2ad5d7..50a4bc8f4610d6a7d7b6ba9e6e0151b0b16dad83 100644 --- a/lib/ui/painting/image_decoding.cc +++ b/lib/ui/painting/image_decoding.cc @@ -32,10 +32,9 @@ sk_sp DecodeImage(sk_sp buffer) { GrContext* context = ResourceContext::Get(); if (context) { - // This acts as a flag to indicate that we want a color space aware decode. - sk_sp dstColorSpace = SkColorSpace::MakeSRGB(); + // TODO: Supply actual destination color space once available return SkImage::MakeCrossContextFromEncoded(context, std::move(buffer), - false, dstColorSpace.get()); + false, nullptr); } else { return SkImage::MakeFromEncoded(std::move(buffer)); } diff --git a/shell/gpu/gpu_surface_gl.cc b/shell/gpu/gpu_surface_gl.cc index 1fe833dd433dd286d4b88f6c6c47687d6dae12d6..8380b6bd2ce6f05ed5cf721c1c2abd39d36e9757 100644 --- a/shell/gpu/gpu_surface_gl.cc +++ b/shell/gpu/gpu_surface_gl.cc @@ -8,7 +8,6 @@ #include "lib/ftl/arraysize.h" #include "lib/ftl/logging.h" #include "third_party/skia/include/core/SkSurface.h" -#include "third_party/skia/include/gpu/GrContextOptions.h" #include "third_party/skia/include/gpu/gl/GrGLInterface.h" namespace shell { @@ -45,12 +44,9 @@ bool GPUSurfaceGL::Setup() { auto backend_context = reinterpret_cast(GrGLCreateNativeInterface()); - GrContextOptions options; - options.fRequireDecodeDisableForSRGB = false; - context_ = - sk_sp(GrContext::Create(kOpenGL_GrBackend, backend_context, - options)); + sk_sp(GrContext::Create(kOpenGL_GrBackend, backend_context)); + if (context_ == nullptr) { FTL_LOG(INFO) << "Failed to setup Skia Gr context."; return false; @@ -108,16 +104,15 @@ bool GPUSurfaceGL::PresentSurface(SkCanvas* canvas) { } bool GPUSurfaceGL::SelectPixelConfig(GrPixelConfig* config) { - if (delegate_->ColorSpace() && delegate_->ColorSpace()->gammaCloseToSRGB()) { - FTL_DCHECK(context_->caps()->isConfigRenderable(kSRGBA_8888_GrPixelConfig, - false)); - *config = kSRGBA_8888_GrPixelConfig; - return true; - } + static const GrPixelConfig kConfigOptions[] = { + kSkia8888_GrPixelConfig, kRGBA_4444_GrPixelConfig, + }; - if (context_->caps()->isConfigRenderable(kRGBA_8888_GrPixelConfig, false)) { - *config = kRGBA_8888_GrPixelConfig; - return true; + for (size_t i = 0; i < arraysize(kConfigOptions); i++) { + if (context_->caps()->isConfigRenderable(kConfigOptions[i], false)) { + *config = kConfigOptions[i]; + return true; + } } return false; @@ -129,6 +124,7 @@ sk_sp GPUSurfaceGL::CreateSurface(const SkISize& size) { } GrBackendRenderTargetDesc desc; + if (!SelectPixelConfig(&desc.fConfig)) { return nullptr; } @@ -139,8 +135,7 @@ sk_sp GPUSurfaceGL::CreateSurface(const SkISize& size) { desc.fOrigin = kBottomLeft_GrSurfaceOrigin; desc.fRenderTargetHandle = delegate_->GLContextFBO(); - return SkSurface::MakeFromBackendRenderTarget(context_.get(), desc, - delegate_->ColorSpace(), nullptr); + return SkSurface::MakeFromBackendRenderTarget(context_.get(), desc, nullptr); } sk_sp GPUSurfaceGL::AcquireSurface(const SkISize& size) { diff --git a/shell/gpu/gpu_surface_gl.h b/shell/gpu/gpu_surface_gl.h index 219d8fdd176ba17837559744898e1517e05f0109..95a6527ba55e98264c1a71a38d0c8500357cd77f 100644 --- a/shell/gpu/gpu_surface_gl.h +++ b/shell/gpu/gpu_surface_gl.h @@ -22,9 +22,6 @@ class GPUSurfaceGLDelegate { virtual bool GLContextPresent() = 0; virtual intptr_t GLContextFBO() const = 0; - - // TODO: Update Mac desktop and make this pure virtual. - virtual sk_sp ColorSpace() const { return nullptr; } }; class GPUSurfaceGL : public Surface { diff --git a/shell/platform/android/android_context_gl.cc b/shell/platform/android/android_context_gl.cc index a8e14c87fc7a6a006c954c1be3a50caccb6f306c..9ae9dfb8e2167a6a37356d410bf69b475b0c1488 100644 --- a/shell/platform/android/android_context_gl.cc +++ b/shell/platform/android/android_context_gl.cc @@ -3,16 +3,8 @@ // found in the LICENSE file. #include "flutter/shell/platform/android/android_context_gl.h" -#include -#include - -#ifndef EGL_GL_COLORSPACE_KHR -#define EGL_GL_COLORSPACE_KHR 0x309D -#endif -#ifndef EGL_GL_COLORSPACE_SRGB_KHR -#define EGL_GL_COLORSPACE_SRGB_KHR 0x3089 -#endif +#include namespace shell { @@ -120,66 +112,43 @@ static bool TeardownSurface(EGLDisplay display, EGLSurface surface) { } // For onscreen rendering. -bool AndroidContextGL::CreateWindowSurface( - ftl::RefPtr window) { +static EGLResult CreateWindowSurface( + EGLDisplay display, + EGLConfig config, + AndroidNativeWindow::Handle window_handle) { // The configurations are only required when dealing with extensions or VG. // We do neither. - - window_ = std::move(window); - EGLDisplay display = environment_->Display(); - - const EGLint srgb_attribs[] = { - EGL_GL_COLORSPACE_KHR, EGL_GL_COLORSPACE_SRGB_KHR, - EGL_NONE - }; - const EGLint default_attribs[] = { - EGL_NONE - }; - - const EGLint* attribs = default_attribs; - if (srgb_support_) { - attribs = srgb_attribs; - } - - surface_ = eglCreateWindowSurface( - display, config_, - reinterpret_cast(window_->handle()), attribs); - return surface_ != EGL_NO_SURFACE; + EGLSurface surface = eglCreateWindowSurface( + display, config, reinterpret_cast(window_handle), + nullptr); + return {surface != EGL_NO_SURFACE, surface}; } // For offscreen rendering. -bool AndroidContextGL::CreatePBufferSurface() { +static EGLResult CreatePBufferSurface(EGLDisplay display, + EGLConfig config) { // We only ever create pbuffer surfaces for background resource loading // contexts. We never bind the pbuffer to anything. + const EGLint attribs[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE}; + EGLSurface surface = eglCreatePbufferSurface(display, config, attribs); + return {surface != EGL_NO_SURFACE, surface}; +} - EGLDisplay display = environment_->Display(); - - const EGLint srgb_attribs[] = { - EGL_WIDTH, 1, - EGL_HEIGHT, 1, - EGL_GL_COLORSPACE_KHR, EGL_GL_COLORSPACE_SRGB_KHR, - EGL_NONE - }; - const EGLint default_attribs[] = { - EGL_WIDTH, 1, - EGL_HEIGHT, 1, - EGL_NONE - }; - - const EGLint* attribs = default_attribs; - if (srgb_support_) { - attribs = srgb_attribs; - } - - surface_ = eglCreatePbufferSurface(display, config_, attribs); - return surface_ != EGL_NO_SURFACE; +static EGLResult CreateSurface( + EGLDisplay display, + EGLConfig config, + ftl::RefPtr window) { + return window && window->IsValid() + ? CreateWindowSurface(display, config, window->handle()) + : CreatePBufferSurface(display, config); } AndroidContextGL::AndroidContextGL(ftl::RefPtr env, + ftl::RefPtr window, PlatformView::SurfaceConfig config, const AndroidContextGL* share_context) : environment_(env), - window_(nullptr), + window_(window), config_(nullptr), surface_(EGL_NO_SURFACE), context_(EGL_NO_CONTEXT), @@ -201,26 +170,25 @@ AndroidContextGL::AndroidContextGL(ftl::RefPtr env, return; } - // Create a context for the configuration. + // Create a surface for the configuration. - std::tie(success, context_) = CreateContext( - environment_->Display(), config_, - share_context != nullptr ? share_context->context_ : EGL_NO_CONTEXT); + std::tie(success, surface_) = + CreateSurface(environment_->Display(), config_, window_); if (!success) { - FTL_LOG(ERROR) << "Could not create an EGL context"; + FTL_LOG(ERROR) << "Could not create the EGL surface."; LogLastEGLError(); return; } - // On its own, this is not enough to guarantee that we will render in - // sRGB mode. We also need to query GL using the GrContext. + // Create a context for the configuration. - const char* exts = eglQueryString(environment_->Display(), EGL_EXTENSIONS); - srgb_support_ = strstr(exts, "EGL_KHR_gl_colorspace"); + std::tie(success, context_) = CreateContext( + environment_->Display(), config_, + share_context != nullptr ? share_context->context_ : EGL_NO_CONTEXT); - if (!this->CreatePBufferSurface()) { - FTL_LOG(ERROR) << "Could not create the EGL surface."; + if (!success) { + FTL_LOG(ERROR) << "Could not create an EGL context"; LogLastEGLError(); return; } @@ -229,6 +197,11 @@ AndroidContextGL::AndroidContextGL(ftl::RefPtr env, valid_ = true; } +AndroidContextGL::AndroidContextGL(ftl::RefPtr env, + PlatformView::SurfaceConfig config, + const AndroidContextGL* share_context) + : AndroidContextGL(env, nullptr, config, share_context) {} + AndroidContextGL::~AndroidContextGL() { if (!TeardownContext(environment_->Display(), context_)) { FTL_LOG(ERROR) << "Could not tear down the EGL context. Possible resource leak."; @@ -297,18 +270,18 @@ bool AndroidContextGL::Resize(const SkISize& size) { TeardownSurface(environment_->Display(), surface_); - if (!this->CreateWindowSurface(window_)) { + bool success = false; + std::tie(success, surface_) = + CreateSurface(environment_->Display(), config_, window_); + + MakeCurrent(); + + if (!success) { FTL_LOG(ERROR) << "Unable to create EGL window surface on resize."; return false; } - MakeCurrent(); - return true; } -bool AndroidContextGL::SupportsSRGB() const { - return srgb_support_; -} - } // namespace shell diff --git a/shell/platform/android/android_context_gl.h b/shell/platform/android/android_context_gl.h index 0cad635a7e145a1c9fdafc00c1e80ffc7ecc1333..aa2a081a51010e42674bd61a2043ff06c32e929c 100644 --- a/shell/platform/android/android_context_gl.h +++ b/shell/platform/android/android_context_gl.h @@ -17,11 +17,6 @@ namespace shell { class AndroidContextGL : public ftl::RefCountedThreadSafe { public: - - bool CreateWindowSurface(ftl::RefPtr window); - - bool CreatePBufferSurface(); - ftl::RefPtr Environment() const; bool IsValid() const; @@ -36,17 +31,22 @@ class AndroidContextGL : public ftl::RefCountedThreadSafe { bool Resize(const SkISize& size); - bool SupportsSRGB() const; - private: ftl::RefPtr environment_; ftl::RefPtr window_; EGLConfig config_; EGLSurface surface_; EGLContext context_; - bool srgb_support_; bool valid_; + /// Creates a window surface context tied to the window handle for on-screen + /// rendering. + AndroidContextGL(ftl::RefPtr env, + ftl::RefPtr window, + PlatformView::SurfaceConfig config, + const AndroidContextGL* share_context = nullptr); + + /// Creates a pbuffer surface context for offscreen rendering. AndroidContextGL(ftl::RefPtr env, PlatformView::SurfaceConfig config, const AndroidContextGL* share_context = nullptr); diff --git a/shell/platform/android/android_surface_gl.cc b/shell/platform/android/android_surface_gl.cc index fbfd03cb0b62615bcdad460715f455292294364e..9e86824f460e6c1056ca46ab076db49dd119b863 100644 --- a/shell/platform/android/android_surface_gl.cc +++ b/shell/platform/android/android_surface_gl.cc @@ -117,7 +117,7 @@ bool AndroidSurfaceGL::SetNativeWindow(ftl::RefPtr window, // Create the onscreen context. onscreen_context_ = ftl::MakeRefCounted( - offscreen_context_->Environment(), config, + offscreen_context_->Environment(), std::move(window), config, offscreen_context_.get() /* sharegroup */); if (!onscreen_context_->IsValid()) { @@ -125,11 +125,6 @@ bool AndroidSurfaceGL::SetNativeWindow(ftl::RefPtr window, return false; } - if (!onscreen_context_->CreateWindowSurface(std::move(window))) { - onscreen_context_ = nullptr; - return false; - } - return true; } diff --git a/shell/platform/android/android_surface_gl.h b/shell/platform/android/android_surface_gl.h index 29ef4e8e7b2c32c419115436d82152d56a6fe3d2..21a5768db74a2b4523a57682cd193faeb4f70b76 100644 --- a/shell/platform/android/android_surface_gl.h +++ b/shell/platform/android/android_surface_gl.h @@ -47,21 +47,12 @@ class AndroidSurfaceGL : public GPUSurfaceGLDelegate, public AndroidSurface { intptr_t GLContextFBO() const override; - sk_sp ColorSpace() const override { - // TODO: - // We can render more consistently across devices when Android makes it - // possible to query for the color space of the display. - return onscreen_context_->SupportsSRGB() ? SkColorSpace::MakeSRGB() - : nullptr; - } - void SetFlutterView( const fml::jni::JavaObjectWeakGlobalRef& flutter_view) override; private: ftl::RefPtr onscreen_context_; ftl::RefPtr offscreen_context_; - sk_sp gr_context_; FTL_DISALLOW_COPY_AND_ASSIGN(AndroidSurfaceGL); }; diff --git a/shell/platform/darwin/ios/ios_gl_context.h b/shell/platform/darwin/ios/ios_gl_context.h index 52506758d5499e92ffbc6d680cb72a897b2f5dc1..51ad00fde79a62727b45f07757bfa8951015551a 100644 --- a/shell/platform/darwin/ios/ios_gl_context.h +++ b/shell/platform/darwin/ios/ios_gl_context.h @@ -34,10 +34,6 @@ class IOSGLContext { bool ResourceMakeCurrent(); - sk_sp ColorSpace() const { - return color_space_; - } - private: fml::scoped_nsobject layer_; fml::scoped_nsobject context_; @@ -49,7 +45,6 @@ class IOSGLContext { GLuint depth_stencil_packed_buffer_; GLint storage_size_width_; GLint storage_size_height_; - sk_sp color_space_; bool valid_; FTL_DISALLOW_COPY_AND_ASSIGN(IOSGLContext); diff --git a/shell/platform/darwin/ios/ios_gl_context.mm b/shell/platform/darwin/ios/ios_gl_context.mm index 082e3a11372c55fb1b94f4b9e5c6da39abddc621..4bb90aed433dcd6603c766028a4ca106099235b8 100644 --- a/shell/platform/darwin/ios/ios_gl_context.mm +++ b/shell/platform/darwin/ios/ios_gl_context.mm @@ -3,10 +3,6 @@ // found in the LICENSE file. #include "flutter/shell/platform/darwin/ios/ios_gl_context.h" -#include "third_party/skia/include/gpu/GrContextOptions.h" -#include "third_party/skia/include/gpu/gl/GrGLInterface.h" - -#include namespace shell { @@ -100,32 +96,14 @@ IOSGLContext::IOSGLContext(PlatformView::SurfaceConfig config, CAEAGLLayer* laye } } - // TODO: - // iOS displays are more variable than just P3 or sRGB. Reading the display - // gamut just tells us what color space it makes sense to render into. We - // should use iOS APIs to perform the final correction step based on the - // device properties. Ex: We can indicate that we have rendered in P3, and - // the framework will do the final adjustment for us. - NSOperatingSystemVersion version = [[NSProcessInfo processInfo] - operatingSystemVersion]; - color_space_ = SkColorSpace::MakeSRGB(); - if (version.majorVersion >= 10) { - UIDisplayGamut displayGamut = - [UIScreen mainScreen].traitCollection.displayGamut; - switch (displayGamut) { - case UIDisplayGamutP3: - // Should we consider using more than 8-bits of precision given that - // P3 specifies a wider range of colors? - color_space_ = SkColorSpace::MakeRGB( - SkColorSpace::kSRGB_RenderTargetGamma, - SkColorSpace::kDCIP3_D65_Gamut); - break; - default: - break; - } + // The default is RGBA + NSString* drawableColorFormat = kEAGLColorFormatRGBA8; + + if (config.red_bits <= 5 && config.green_bits <= 6 && config.blue_bits <= 5 && + config.alpha_bits == 0) { + drawableColorFormat = kEAGLColorFormatRGB565; } - NSString* drawableColorFormat = kEAGLColorFormatSRGBA8; layer_.get().drawableProperties = @{ kEAGLDrawablePropertyColorFormat : drawableColorFormat, kEAGLDrawablePropertyRetainedBacking : @(NO), diff --git a/shell/platform/darwin/ios/ios_surface_gl.h b/shell/platform/darwin/ios/ios_surface_gl.h index c7900480b14e1fc07ebb7dfa593c11ec0d67f990..5f2abb9b3d1890388d90bef0c5a277c7abe0df7f 100644 --- a/shell/platform/darwin/ios/ios_surface_gl.h +++ b/shell/platform/darwin/ios/ios_surface_gl.h @@ -36,10 +36,6 @@ class IOSSurfaceGL : public IOSSurface, public GPUSurfaceGLDelegate { intptr_t GLContextFBO() const override; - sk_sp ColorSpace() const override { - return context_.ColorSpace(); - } - private: IOSGLContext context_; diff --git a/shell/platform/darwin/ios/ios_surface_software.mm b/shell/platform/darwin/ios/ios_surface_software.mm index 759571696c195bbfe82e7ec0c7eac927c2d378c8..7ce5f97b5688813415c57d24827d557e2b4678a2 100644 --- a/shell/platform/darwin/ios/ios_surface_software.mm +++ b/shell/platform/darwin/ios/ios_surface_software.mm @@ -63,9 +63,8 @@ sk_sp IOSSurfaceSoftware::AcquireBackingStore(const SkISize& size) { return sk_surface_; } - SkImageInfo info = SkImageInfo::MakeS32(size.fWidth, size.fHeight, - kPremul_SkAlphaType); - sk_surface_ = SkSurface::MakeRaster(info, nullptr); + sk_surface_ = SkSurface::MakeRasterN32Premul(size.fWidth, size.fHeight, + nullptr /* SkSurfaceProps as out */); return sk_surface_; }