DEV/flutter_flutter
1
0
Fork 0
mirror of https://github.com/flutter/flutter.git synced 2026-02-20 02:29:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

[Impeller] toImageSync for Impeller (flutter/engine#36365)

Browse Source
This commit is contained in:
Dan Field 2022-09-23 13:31:03 -07:00 committed by GitHub
parent 9d1aaf1159
commit 63e8e223aa
15 changed files with 473 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
engine/src/flutter/ci/licenses_golden/licenses_flutter
View File

@ -1023,8 +1023,10 @@ FILE: ../../../flutter/lib/ui/painting/codec.cc
FILE: ../../../flutter/lib/ui/painting/codec.h
FILE: ../../../flutter/lib/ui/painting/color_filter.cc
FILE: ../../../flutter/lib/ui/painting/color_filter.h
FILE: ../../../flutter/lib/ui/painting/display_list_deferred_image_gpu.cc
FILE: ../../../flutter/lib/ui/painting/display_list_deferred_image_gpu.h
FILE: ../../../flutter/lib/ui/painting/display_list_deferred_image_gpu_impeller.cc
FILE: ../../../flutter/lib/ui/painting/display_list_deferred_image_gpu_impeller.h
FILE: ../../../flutter/lib/ui/painting/display_list_deferred_image_gpu_skia.cc
FILE: ../../../flutter/lib/ui/painting/display_list_deferred_image_gpu_skia.h
FILE: ../../../flutter/lib/ui/painting/display_list_image_gpu.cc
FILE: ../../../flutter/lib/ui/painting/display_list_image_gpu.h
FILE: ../../../flutter/lib/ui/painting/engine_layer.cc

6
engine/src/flutter/lib/ui/BUILD.gn
View File

@ -30,8 +30,8 @@ source_set("ui") {
"painting/codec.h",
"painting/color_filter.cc",
"painting/color_filter.h",
"painting/display_list_deferred_image_gpu.cc",
"painting/display_list_deferred_image_gpu.h",
"painting/display_list_deferred_image_gpu_skia.cc",
"painting/display_list_deferred_image_gpu_skia.h",
"painting/display_list_image_gpu.cc",
"painting/display_list_image_gpu.h",
"painting/engine_layer.cc",
@ -163,6 +163,8 @@ source_set("ui") {
if (impeller_supports_rendering) {
sources += [
"painting/display_list_deferred_image_gpu_impeller.cc",
"painting/display_list_deferred_image_gpu_impeller.h",
"painting/image_decoder_impeller.cc",
"painting/image_decoder_impeller.h",
]

37
engine/src/flutter/lib/ui/compositing/scene.cc
View File

@ -5,12 +5,15 @@
#include "flutter/lib/ui/compositing/scene.h"
#include "flutter/fml/trace_event.h"
#include "flutter/lib/ui/painting/display_list_deferred_image_gpu.h"
#include "flutter/lib/ui/painting/display_list_deferred_image_gpu_skia.h"
#include "flutter/lib/ui/painting/image.h"
#include "flutter/lib/ui/painting/picture.h"
#include "flutter/lib/ui/ui_dart_state.h"
#include "flutter/lib/ui/window/platform_configuration.h"
#include "flutter/lib/ui/window/window.h"
#if IMPELLER_SUPPORTS_RENDERING
#include "flutter/lib/ui/painting/display_list_deferred_image_gpu_impeller.h"
#endif // IMPELLER_SUPPORTS_RENDERING
#include "third_party/skia/include/core/SkImageInfo.h"
#include "third_party/skia/include/core/SkSurface.h"
#include "third_party/tonic/converter/dart_converter.h"
@ -87,6 +90,29 @@ Dart_Handle Scene::toImage(uint32_t width,
height, raw_image_callback);
}
static sk_sp<DlImage> CreateDeferredImage(
bool impeller,
std::shared_ptr<LayerTree> layer_tree,
uint32_t width,
uint32_t height,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
fml::RefPtr<fml::TaskRunner> raster_task_runner,
fml::RefPtr<SkiaUnrefQueue> unref_queue) {
#if IMPELLER_SUPPORTS_RENDERING
if (impeller) {
return DlDeferredImageGPUImpeller::Make(
std::move(layer_tree), SkISize::Make(width, height),
std::move(snapshot_delegate), std::move(raster_task_runner));
}
#endif // IMPELLER_SUPPORTS_RENDERING
const SkImageInfo image_info = SkImageInfo::Make(
width, height, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
return DlDeferredImageGPUSkia::MakeFromLayerTree(
image_info, std::move(layer_tree), std::move(snapshot_delegate),
std::move(raster_task_runner), std::move(unref_queue));
}
void Scene::RasterizeToImage(uint32_t width,
uint32_t height,
Dart_Handle raw_image_handle) {
@ -99,11 +125,10 @@ void Scene::RasterizeToImage(uint32_t width,
auto raster_task_runner = dart_state->GetTaskRunners().GetRasterTaskRunner();
auto image = CanvasImage::Create();
const SkImageInfo image_info = SkImageInfo::Make(
width, height, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
auto dl_image = DlDeferredImageGPU::MakeFromLayerTree(
image_info, std::move(layer_tree_), std::move(snapshot_delegate),
std::move(raster_task_runner), std::move(unref_queue));
auto dl_image = CreateDeferredImage(
dart_state->IsImpellerEnabled(), layer_tree_, width, height,
std::move(snapshot_delegate), std::move(raster_task_runner),
std::move(unref_queue));
image->set_image(dl_image);
image->AssociateWithDartWrapper(raw_image_handle);
}

188
engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu_impeller.cc Normal file
View File

@ -0,0 +1,188 @@
// Copyright 2013 The Flutter 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 "flutter/lib/ui/painting/display_list_deferred_image_gpu_impeller.h"
#include "display_list_deferred_image_gpu_impeller.h"
namespace flutter {
sk_sp<DlDeferredImageGPUImpeller> DlDeferredImageGPUImpeller::Make(
std::shared_ptr<LayerTree> layer_tree,
const SkISize& size,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
fml::RefPtr<fml::TaskRunner> raster_task_runner) {
return sk_sp<DlDeferredImageGPUImpeller>(new DlDeferredImageGPUImpeller(
DlDeferredImageGPUImpeller::ImageWrapper::Make(
std::move(layer_tree), size, std::move(snapshot_delegate),
std::move(raster_task_runner))));
}
sk_sp<DlDeferredImageGPUImpeller> DlDeferredImageGPUImpeller::Make(
sk_sp<DisplayList> display_list,
const SkISize& size,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
fml::RefPtr<fml::TaskRunner> raster_task_runner) {
return sk_sp<DlDeferredImageGPUImpeller>(new DlDeferredImageGPUImpeller(
DlDeferredImageGPUImpeller::ImageWrapper::Make(
std::move(display_list), size, std::move(snapshot_delegate),
std::move(raster_task_runner))));
}
DlDeferredImageGPUImpeller::DlDeferredImageGPUImpeller(
std::shared_ptr<ImageWrapper> wrapper)
: wrapper_(wrapper) {}
// |DlImage|
DlDeferredImageGPUImpeller::~DlDeferredImageGPUImpeller() = default;
// |DlImage|
sk_sp<SkImage> DlDeferredImageGPUImpeller::skia_image() const {
return nullptr;
};
// |DlImage|
std::shared_ptr<impeller::Texture>
DlDeferredImageGPUImpeller::impeller_texture() const {
if (!wrapper_) {
return nullptr;
}
return wrapper_->texture();
}
// |DlImage|
bool DlDeferredImageGPUImpeller::isOpaque() const {
// Impeller doesn't currently implement opaque alpha types.
return false;
}
// |DlImage|
bool DlDeferredImageGPUImpeller::isTextureBacked() const {
return wrapper_ && wrapper_->isTextureBacked();
}
// |DlImage|
SkISize DlDeferredImageGPUImpeller::dimensions() const {
if (!wrapper_) {
return SkISize::MakeEmpty();
}
return wrapper_->size();
}
// |DlImage|
size_t DlDeferredImageGPUImpeller::GetApproximateByteSize() const {
auto size = sizeof(DlDeferredImageGPUImpeller);
if (wrapper_) {
if (wrapper_->texture()) {
size += wrapper_->texture()
->GetTextureDescriptor()
.GetByteSizeOfBaseMipLevel();
} else {
size += wrapper_->size().width() * wrapper_->size().height() * 4;
}
}
return size;
}
std::shared_ptr<DlDeferredImageGPUImpeller::ImageWrapper>
DlDeferredImageGPUImpeller::ImageWrapper::Make(
sk_sp<DisplayList> display_list,
const SkISize& size,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
fml::RefPtr<fml::TaskRunner> raster_task_runner) {
auto wrapper = std::shared_ptr<ImageWrapper>(new ImageWrapper(
std::move(display_list), size, std::move(snapshot_delegate),
std::move(raster_task_runner)));
wrapper->SnapshotDisplayList();
return wrapper;
}
std::shared_ptr<DlDeferredImageGPUImpeller::ImageWrapper>
DlDeferredImageGPUImpeller::ImageWrapper::Make(
std::shared_ptr<LayerTree> layer_tree,
const SkISize& size,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
fml::RefPtr<fml::TaskRunner> raster_task_runner) {
auto wrapper = std::shared_ptr<ImageWrapper>(
new ImageWrapper(nullptr, size, std::move(snapshot_delegate),
std::move(raster_task_runner)));
wrapper->SnapshotDisplayList(std::move(layer_tree));
return wrapper;
}
DlDeferredImageGPUImpeller::ImageWrapper::ImageWrapper(
sk_sp<DisplayList> display_list,
const SkISize& size,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
fml::RefPtr<fml::TaskRunner> raster_task_runner)
: size_(size),
display_list_(std::move(display_list)),
snapshot_delegate_(std::move(snapshot_delegate)),
raster_task_runner_(std::move(raster_task_runner)) {}
DlDeferredImageGPUImpeller::ImageWrapper::~ImageWrapper() {
fml::TaskRunner::RunNowOrPostTask(
raster_task_runner_, [id = reinterpret_cast<uintptr_t>(this),
texture_registry = std::move(texture_registry_)]() {
if (texture_registry) {
texture_registry->UnregisterContextListener(id);
}
});
}
void DlDeferredImageGPUImpeller::ImageWrapper::OnGrContextCreated() {
FML_DCHECK(raster_task_runner_->RunsTasksOnCurrentThread());
SnapshotDisplayList();
}
void DlDeferredImageGPUImpeller::ImageWrapper::OnGrContextDestroyed() {
// Impeller textures do not have threading requirements for deletion, and
texture_.reset();
}
bool DlDeferredImageGPUImpeller::ImageWrapper::isTextureBacked() const {
return texture_ && texture_->IsValid();
}
void DlDeferredImageGPUImpeller::ImageWrapper::SnapshotDisplayList(
std::shared_ptr<LayerTree> layer_tree) {
fml::TaskRunner::RunNowOrPostTask(
raster_task_runner_,
[weak_this = weak_from_this(), layer_tree = std::move(layer_tree)] {
TRACE_EVENT0("flutter", "SnapshotDisplayList (impeller)");
auto wrapper = weak_this.lock();
if (!wrapper) {
return;
}
auto snapshot_delegate = wrapper->snapshot_delegate_;
if (!snapshot_delegate) {
return;
}
wrapper->texture_registry_ = snapshot_delegate->GetTextureRegistry();
wrapper->texture_registry_->RegisterContextListener(
reinterpret_cast<uintptr_t>(wrapper.get()), weak_this);
if (layer_tree) {
wrapper->display_list_ = layer_tree->Flatten(
SkRect::MakeWH(wrapper->size_.width(), wrapper->size_.height()),
wrapper->texture_registry_);
}
auto snapshot = snapshot_delegate->MakeRasterSnapshot(
wrapper->display_list_, wrapper->size_);
if (!snapshot) {
std::scoped_lock lock(wrapper->error_mutex_);
wrapper->error_ = "Failed to create snapshot.";
return;
}
wrapper->texture_ = snapshot->impeller_texture();
});
}
std::optional<std::string>
DlDeferredImageGPUImpeller::ImageWrapper::get_error() {
std::scoped_lock lock(error_mutex_);
return error_;
}
} // namespace flutter

119
engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu_impeller.h Normal file
View File

@ -0,0 +1,119 @@
// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#pragma once
#include "flutter/common/graphics/texture.h"
#include "flutter/display_list/display_list_image.h"
#include "flutter/flow/layers/layer_tree.h"
#include "flutter/fml/macros.h"
#include "flutter/fml/memory/weak_ptr.h"
#include "flutter/fml/task_runner.h"
#include "flutter/lib/ui/snapshot_delegate.h"
#include "impeller/renderer/texture.h"
namespace flutter {
class DlDeferredImageGPUImpeller final : public DlImage {
public:
static sk_sp<DlDeferredImageGPUImpeller> Make(
std::shared_ptr<LayerTree> layer_tree,
const SkISize& size,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
fml::RefPtr<fml::TaskRunner> raster_task_runner);
static sk_sp<DlDeferredImageGPUImpeller> Make(
sk_sp<DisplayList> display_list,
const SkISize& size,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
fml::RefPtr<fml::TaskRunner> raster_task_runner);
// |DlImage|
~DlDeferredImageGPUImpeller() override;
// |DlImage|
sk_sp<SkImage> skia_image() const override;
// |DlImage|
std::shared_ptr<impeller::Texture> impeller_texture() const override;
// |DlImage|
bool isOpaque() const override;
// |DlImage|
bool isTextureBacked() const override;
// |DlImage|
SkISize dimensions() const override;
// |DlImage|
size_t GetApproximateByteSize() const override;
private:
class ImageWrapper final : public std::enable_shared_from_this<ImageWrapper>,
public ContextListener {
public:
~ImageWrapper();
static std::shared_ptr<ImageWrapper> Make(
sk_sp<DisplayList> display_list,
const SkISize& size,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
fml::RefPtr<fml::TaskRunner> raster_task_runner);
static std::shared_ptr<ImageWrapper> Make(
std::shared_ptr<LayerTree> layer_tree,
const SkISize& size,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
fml::RefPtr<fml::TaskRunner> raster_task_runner);
bool isTextureBacked() const;
const std::shared_ptr<impeller::Texture> texture() const {
return texture_;
}
const SkISize size() const { return size_; }
std::optional<std::string> get_error();
private:
SkISize size_;
sk_sp<DisplayList> display_list_;
std::shared_ptr<impeller::Texture> texture_;
fml::WeakPtr<SnapshotDelegate> snapshot_delegate_;
fml::RefPtr<fml::TaskRunner> raster_task_runner_;
std::shared_ptr<TextureRegistry> texture_registry_;
mutable std::mutex error_mutex_;
std::optional<std::string> error_;
ImageWrapper(sk_sp<DisplayList> display_list,
const SkISize& size,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
fml::RefPtr<fml::TaskRunner> raster_task_runner);
// If a layer tree is provided, it will be flattened during the raster
// thread task spwaned by this method. After being flattened into a display
// list, the image wrapper will be updated to hold this display list and the
// layer tree can be dropped.
void SnapshotDisplayList(std::shared_ptr<LayerTree> layer_tree = nullptr);
// |ContextListener|
void OnGrContextCreated() override;
// |ContextListener|
void OnGrContextDestroyed() override;
FML_DISALLOW_COPY_AND_ASSIGN(ImageWrapper);
};
const std::shared_ptr<ImageWrapper> wrapper_;
explicit DlDeferredImageGPUImpeller(std::shared_ptr<ImageWrapper> wrapper);
FML_DISALLOW_COPY_AND_ASSIGN(DlDeferredImageGPUImpeller);
};
} // namespace flutter

59
engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu.cc → engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu_skia.cc
View File

@ -2,47 +2,46 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "flutter/lib/ui/painting/display_list_deferred_image_gpu.h"
#include "flutter/lib/ui/painting/display_list_deferred_image_gpu_skia.h"
#include "display_list_deferred_image_gpu.h"
#include "third_party/skia/include/core/SkColorSpace.h"
namespace flutter {
sk_sp<DlDeferredImageGPU> DlDeferredImageGPU::Make(
sk_sp<DlDeferredImageGPUSkia> DlDeferredImageGPUSkia::Make(
const SkImageInfo& image_info,
sk_sp<DisplayList> display_list,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
fml::RefPtr<fml::TaskRunner> raster_task_runner,
fml::RefPtr<SkiaUnrefQueue> unref_queue) {
return sk_sp<DlDeferredImageGPU>(new DlDeferredImageGPU(
return sk_sp<DlDeferredImageGPUSkia>(new DlDeferredImageGPUSkia(
ImageWrapper::Make(image_info, std::move(display_list),
std::move(snapshot_delegate), raster_task_runner,
std::move(unref_queue)),
raster_task_runner));
}
sk_sp<DlDeferredImageGPU> DlDeferredImageGPU::MakeFromLayerTree(
sk_sp<DlDeferredImageGPUSkia> DlDeferredImageGPUSkia::MakeFromLayerTree(
const SkImageInfo& image_info,
std::shared_ptr<LayerTree> layer_tree,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
fml::RefPtr<fml::TaskRunner> raster_task_runner,
fml::RefPtr<SkiaUnrefQueue> unref_queue) {
return sk_sp<DlDeferredImageGPU>(new DlDeferredImageGPU(
return sk_sp<DlDeferredImageGPUSkia>(new DlDeferredImageGPUSkia(
ImageWrapper::MakeFromLayerTree(
image_info, std::move(layer_tree), std::move(snapshot_delegate),
raster_task_runner, std::move(unref_queue)),
raster_task_runner));
}
DlDeferredImageGPU::DlDeferredImageGPU(
DlDeferredImageGPUSkia::DlDeferredImageGPUSkia(
std::shared_ptr<ImageWrapper> image_wrapper,
fml::RefPtr<fml::TaskRunner> raster_task_runner)
: image_wrapper_(std::move(image_wrapper)),
raster_task_runner_(std::move(raster_task_runner)) {}
// |DlImage|
DlDeferredImageGPU::~DlDeferredImageGPU() {
DlDeferredImageGPUSkia::~DlDeferredImageGPUSkia() {
fml::TaskRunner::RunNowOrPostTask(
raster_task_runner_, [image_wrapper = std::move(image_wrapper_)]() {
if (!image_wrapper) {
@ -54,45 +53,45 @@ DlDeferredImageGPU::~DlDeferredImageGPU() {
}
// |DlImage|
sk_sp<SkImage> DlDeferredImageGPU::skia_image() const {
sk_sp<SkImage> DlDeferredImageGPUSkia::skia_image() const {
return image_wrapper_ ? image_wrapper_->CreateSkiaImage() : nullptr;
};
// |DlImage|
std::shared_ptr<impeller::Texture> DlDeferredImageGPU::impeller_texture()
std::shared_ptr<impeller::Texture> DlDeferredImageGPUSkia::impeller_texture()
const {
return nullptr;
}
// |DlImage|
bool DlDeferredImageGPU::isOpaque() const {
bool DlDeferredImageGPUSkia::isOpaque() const {
return image_wrapper_ ? image_wrapper_->image_info().isOpaque() : false;
}
// |DlImage|
bool DlDeferredImageGPU::isTextureBacked() const {
bool DlDeferredImageGPUSkia::isTextureBacked() const {
return image_wrapper_ ? image_wrapper_->isTextureBacked() : false;
}
// |DlImage|
SkISize DlDeferredImageGPU::dimensions() const {
SkISize DlDeferredImageGPUSkia::dimensions() const {
return image_wrapper_ ? image_wrapper_->image_info().dimensions()
: SkISize::MakeEmpty();
}
// |DlImage|
size_t DlDeferredImageGPU::GetApproximateByteSize() const {
size_t DlDeferredImageGPUSkia::GetApproximateByteSize() const {
return sizeof(this) + (image_wrapper_
? image_wrapper_->image_info().computeMinByteSize()
: 0);
}
std::optional<std::string> DlDeferredImageGPU::get_error() const {
std::optional<std::string> DlDeferredImageGPUSkia::get_error() const {
return image_wrapper_ ? image_wrapper_->get_error() : std::nullopt;
}
std::shared_ptr<DlDeferredImageGPU::ImageWrapper>
DlDeferredImageGPU::ImageWrapper::Make(
std::shared_ptr<DlDeferredImageGPUSkia::ImageWrapper>
DlDeferredImageGPUSkia::ImageWrapper::Make(
const SkImageInfo& image_info,
sk_sp<DisplayList> display_list,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
@ -105,8 +104,8 @@ DlDeferredImageGPU::ImageWrapper::Make(
return wrapper;
}
std::shared_ptr<DlDeferredImageGPU::ImageWrapper>
DlDeferredImageGPU::ImageWrapper::MakeFromLayerTree(
std::shared_ptr<DlDeferredImageGPUSkia::ImageWrapper>
DlDeferredImageGPUSkia::ImageWrapper::MakeFromLayerTree(
const SkImageInfo& image_info,
std::shared_ptr<LayerTree> layer_tree,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
@ -119,7 +118,7 @@ DlDeferredImageGPU::ImageWrapper::MakeFromLayerTree(
return wrapper;
}
DlDeferredImageGPU::ImageWrapper::ImageWrapper(
DlDeferredImageGPUSkia::ImageWrapper::ImageWrapper(
const SkImageInfo& image_info,
sk_sp<DisplayList> display_list,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
@ -131,18 +130,18 @@ DlDeferredImageGPU::ImageWrapper::ImageWrapper(
raster_task_runner_(std::move(raster_task_runner)),
unref_queue_(std::move(unref_queue)) {}
void DlDeferredImageGPU::ImageWrapper::OnGrContextCreated() {
void DlDeferredImageGPUSkia::ImageWrapper::OnGrContextCreated() {
FML_DCHECK(raster_task_runner_->RunsTasksOnCurrentThread());
SnapshotDisplayList();
}
void DlDeferredImageGPU::ImageWrapper::OnGrContextDestroyed() {
void DlDeferredImageGPUSkia::ImageWrapper::OnGrContextDestroyed() {
FML_DCHECK(raster_task_runner_->RunsTasksOnCurrentThread());
DeleteTexture();
}
sk_sp<SkImage> DlDeferredImageGPU::ImageWrapper::CreateSkiaImage() const {
sk_sp<SkImage> DlDeferredImageGPUSkia::ImageWrapper::CreateSkiaImage() const {
FML_DCHECK(raster_task_runner_->RunsTasksOnCurrentThread());
if (texture_.isValid() && context_) {
@ -154,11 +153,11 @@ sk_sp<SkImage> DlDeferredImageGPU::ImageWrapper::CreateSkiaImage() const {
return image_;
}
bool DlDeferredImageGPU::ImageWrapper::isTextureBacked() const {
bool DlDeferredImageGPUSkia::ImageWrapper::isTextureBacked() const {
return texture_.isValid();
}
void DlDeferredImageGPU::ImageWrapper::SnapshotDisplayList(
void DlDeferredImageGPUSkia::ImageWrapper::SnapshotDisplayList(
std::shared_ptr<LayerTree> layer_tree) {
fml::TaskRunner::RunNowOrPostTask(
raster_task_runner_,
@ -179,8 +178,8 @@ void DlDeferredImageGPU::ImageWrapper::SnapshotDisplayList(
snapshot_delegate->GetGrContext());
wrapper->display_list_ = std::move(display_list);
}
auto result = snapshot_delegate->MakeGpuImage(wrapper->display_list_,
wrapper->image_info_);
auto result = snapshot_delegate->MakeSkiaGpuImage(
wrapper->display_list_, wrapper->image_info_);
if (result->texture.isValid()) {
wrapper->texture_ = result->texture;
wrapper->context_ = std::move(result->context);
@ -197,19 +196,19 @@ void DlDeferredImageGPU::ImageWrapper::SnapshotDisplayList(
});
}
std::optional<std::string> DlDeferredImageGPU::ImageWrapper::get_error() {
std::optional<std::string> DlDeferredImageGPUSkia::ImageWrapper::get_error() {
std::scoped_lock lock(error_mutex_);
return error_;
}
void DlDeferredImageGPU::ImageWrapper::Unregister() {
void DlDeferredImageGPUSkia::ImageWrapper::Unregister() {
if (texture_registry_) {
texture_registry_->UnregisterContextListener(
reinterpret_cast<uintptr_t>(this));
}
}
void DlDeferredImageGPU::ImageWrapper::DeleteTexture() {
void DlDeferredImageGPUSkia::ImageWrapper::DeleteTexture() {
if (texture_.isValid()) {
unref_queue_->DeleteTexture(std::move(texture_));
texture_ = GrBackendTexture();

20
engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu.h → engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu_skia.h
View File

@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef FLUTTER_LIB_UI_PAINTING_DISPLAY_LIST_DEFERRED_IMAGE_GPU_H_
#define FLUTTER_LIB_UI_PAINTING_DISPLAY_LIST_DEFERRED_IMAGE_GPU_H_
#ifndef FLUTTER_LIB_UI_PAINTING_DISPLAY_LIST_DEFERRED_IMAGE_GPU_SKIA_H_
#define FLUTTER_LIB_UI_PAINTING_DISPLAY_LIST_DEFERRED_IMAGE_GPU_SKIA_H_
#include <memory>
#include <mutex>
@ -20,16 +20,16 @@
namespace flutter {
class DlDeferredImageGPU final : public DlImage {
class DlDeferredImageGPUSkia final : public DlImage {
public:
static sk_sp<DlDeferredImageGPU> Make(
static sk_sp<DlDeferredImageGPUSkia> Make(
const SkImageInfo& image_info,
sk_sp<DisplayList> display_list,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
fml::RefPtr<fml::TaskRunner> raster_task_runner,
fml::RefPtr<SkiaUnrefQueue> unref_queue);
static sk_sp<DlDeferredImageGPU> MakeFromLayerTree(
static sk_sp<DlDeferredImageGPUSkia> MakeFromLayerTree(
const SkImageInfo& image_info,
std::shared_ptr<LayerTree> layer_tree,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
@ -37,7 +37,7 @@ class DlDeferredImageGPU final : public DlImage {
fml::RefPtr<SkiaUnrefQueue> unref_queue);
// |DlImage|
~DlDeferredImageGPU() override;
~DlDeferredImageGPUSkia() override;
// |DlImage|
// This method is only safe to call from the raster thread.
@ -135,12 +135,12 @@ class DlDeferredImageGPU final : public DlImage {
fml::RefPtr<fml::TaskRunner> raster_task_runner_;
DlDeferredImageGPU(std::shared_ptr<ImageWrapper> image_wrapper,
fml::RefPtr<fml::TaskRunner> raster_task_runner);
DlDeferredImageGPUSkia(std::shared_ptr<ImageWrapper> image_wrapper,
fml::RefPtr<fml::TaskRunner> raster_task_runner);
FML_DISALLOW_COPY_AND_ASSIGN(DlDeferredImageGPU);
FML_DISALLOW_COPY_AND_ASSIGN(DlDeferredImageGPUSkia);
};
} // namespace flutter
#endif // FLUTTER_LIB_UI_PAINTING_DISPLAY_LIST_DEFERRED_IMAGE_GPU_H_
#endif // FLUTTER_LIB_UI_PAINTING_DISPLAY_LIST_DEFERRED_IMAGE_GPU_SKIA_H_

37
engine/src/flutter/lib/ui/painting/picture.cc
View File

@ -8,8 +8,11 @@
#include "flutter/fml/make_copyable.h"
#include "flutter/lib/ui/painting/canvas.h"
#include "flutter/lib/ui/painting/display_list_deferred_image_gpu.h"
#include "flutter/lib/ui/painting/display_list_deferred_image_gpu_skia.h"
#include "flutter/lib/ui/ui_dart_state.h"
#if IMPELLER_SUPPORTS_RENDERING
#include "flutter/lib/ui/painting/display_list_deferred_image_gpu_impeller.h"
#endif // IMPELLER_SUPPORTS_RENDERING
#include "third_party/tonic/converter/dart_converter.h"
#include "third_party/tonic/dart_args.h"
#include "third_party/tonic/dart_binding_macros.h"
@ -53,6 +56,29 @@ void Picture::toImageSync(uint32_t width,
raw_image_handle);
}
static sk_sp<DlImage> CreateDeferredImage(
bool impeller,
sk_sp<DisplayList> display_list,
uint32_t width,
uint32_t height,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
fml::RefPtr<fml::TaskRunner> raster_task_runner,
fml::RefPtr<SkiaUnrefQueue> unref_queue) {
#if IMPELLER_SUPPORTS_RENDERING
if (impeller) {
return DlDeferredImageGPUImpeller::Make(
std::move(display_list), SkISize::Make(width, height),
std::move(snapshot_delegate), std::move(raster_task_runner));
}
#endif // IMPELLER_SUPPORTS_RENDERING
const SkImageInfo image_info = SkImageInfo::Make(
width, height, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
return DlDeferredImageGPUSkia::Make(
image_info, std::move(display_list), std::move(snapshot_delegate),
std::move(raster_task_runner), std::move(unref_queue));
}
// static
void Picture::RasterizeToImageSync(sk_sp<DisplayList> display_list,
uint32_t width,
@ -67,11 +93,10 @@ void Picture::RasterizeToImageSync(sk_sp<DisplayList> display_list,
auto raster_task_runner = dart_state->GetTaskRunners().GetRasterTaskRunner();
auto image = CanvasImage::Create();
const SkImageInfo image_info = SkImageInfo::Make(
width, height, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
auto dl_image = DlDeferredImageGPU::Make(
image_info, std::move(display_list), std::move(snapshot_delegate),
std::move(raster_task_runner), std::move(unref_queue));
auto dl_image = CreateDeferredImage(
dart_state->IsImpellerEnabled(), display_list, width, height,
std::move(snapshot_delegate), std::move(raster_task_runner),
std::move(unref_queue));
image->set_image(dl_image);
image->AssociateWithDartWrapper(raw_image_handle);
}

16
engine/src/flutter/lib/ui/snapshot_delegate.h
View File

@ -9,6 +9,7 @@
#include "flutter/common/graphics/texture.h"
#include "flutter/display_list/display_list.h"
#include "flutter/flow/skia_gpu_object.h"
#include "third_party/skia/include/core/SkImage.h"
#include "third_party/skia/include/core/SkPicture.h"
#include "third_party/skia/include/core/SkPromiseImageTexture.h"
@ -21,6 +22,9 @@ class DlImage;
class SnapshotDelegate {
public:
//----------------------------------------------------------------------------
/// @brief A data structure used by the Skia implementation of deferred
/// GPU based images.
struct GpuImageResult {
GpuImageResult(const GrBackendTexture& p_texture,
sk_sp<GrDirectContext> p_context,
@ -44,6 +48,14 @@ class SnapshotDelegate {
const std::string error;
};
//----------------------------------------------------------------------------
/// @brief Attempts to create a GrBackendTexture for the specified
/// DisplayList. May result in a raster bitmap if no GPU context
/// is available.
virtual std::unique_ptr<GpuImageResult> MakeSkiaGpuImage(
sk_sp<DisplayList> display_list,
const SkImageInfo& image_info) = 0;
//----------------------------------------------------------------------------
/// @brief Gets the registry of external textures currently in use by the
/// rasterizer. These textures may be updated at a cadence
@ -57,10 +69,6 @@ class SnapshotDelegate {
virtual GrDirectContext* GetGrContext() = 0;
virtual std::unique_ptr<GpuImageResult> MakeGpuImage(
sk_sp<DisplayList> display_list,
const SkImageInfo& image_info) = 0;
virtual sk_sp<DlImage> MakeRasterSnapshot(sk_sp<DisplayList> display_list,
SkISize picture_size) = 0;

10
engine/src/flutter/lib/ui/ui_dart_state.cc
View File

@ -36,7 +36,8 @@ UIDartState::Context::Context(
fml::WeakPtr<ImageGeneratorRegistry> image_generator_registry,
std::string advisory_script_uri,
std::string advisory_script_entrypoint,
std::shared_ptr<VolatilePathTracker> volatile_path_tracker)
std::shared_ptr<VolatilePathTracker> volatile_path_tracker,
bool enable_impeller)
: task_runners(task_runners),
snapshot_delegate(snapshot_delegate),
io_manager(io_manager),
@ -45,7 +46,8 @@ UIDartState::Context::Context(
image_generator_registry(image_generator_registry),
advisory_script_uri(advisory_script_uri),
advisory_script_entrypoint(advisory_script_entrypoint),
volatile_path_tracker(volatile_path_tracker) {}
volatile_path_tracker(volatile_path_tracker),
enable_impeller(enable_impeller) {}
UIDartState::UIDartState(
TaskObserverAdd add_callback,
@ -77,6 +79,10 @@ const std::string& UIDartState::GetAdvisoryScriptURI() const {
return context_.advisory_script_uri;
}
bool UIDartState::IsImpellerEnabled() const {
return context_.enable_impeller;
}
void UIDartState::DidSetIsolate() {
main_port_ = Dart_GetMainPortId();
std::ostringstream debug_name;

9
engine/src/flutter/lib/ui/ui_dart_state.h
View File

@ -53,7 +53,8 @@ class UIDartState : public tonic::DartState {
fml::WeakPtr<ImageGeneratorRegistry> image_generator_registry,
std::string advisory_script_uri,
std::string advisory_script_entrypoint,
std::shared_ptr<VolatilePathTracker> volatile_path_tracker);
std::shared_ptr<VolatilePathTracker> volatile_path_tracker,
bool enable_impeller);
/// The task runners used by the shell hosting this runtime controller. This
/// may be used by the isolate to scheduled asynchronous texture uploads or
@ -91,6 +92,9 @@ class UIDartState : public tonic::DartState {
/// Cache for tracking path volatility.
std::shared_ptr<VolatilePathTracker> volatile_path_tracker;
/// Whether Impeller is enabled or not.
bool enable_impeller = false;
};
Dart_Port main_port() const { return main_port_; }
@ -163,6 +167,9 @@ class UIDartState : public tonic::DartState {
/// Returns `0` if called from a non-root isolate.
int64_t GetRootIsolateToken() const;
/// Whether Impeller is enabled for this application.
bool IsImpellerEnabled() const;
protected:
UIDartState(TaskObserverAdd add_callback,
TaskObserverRemove remove_callback,

16
engine/src/flutter/runtime/runtime_controller.cc
View File

@ -54,12 +54,16 @@ std::unique_ptr<RuntimeController> RuntimeController::Spawn(
fml::WeakPtr<ImageDecoder> image_decoder,
fml::WeakPtr<ImageGeneratorRegistry> image_generator_registry,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate) const {
UIDartState::Context spawned_context{
context_.task_runners, std::move(snapshot_delegate),
std::move(io_manager), context_.unref_queue,
std::move(image_decoder), std::move(image_generator_registry),
advisory_script_uri, advisory_script_entrypoint,
context_.volatile_path_tracker};
UIDartState::Context spawned_context{context_.task_runners,
std::move(snapshot_delegate),
std::move(io_manager),
context_.unref_queue,
std::move(image_decoder),
std::move(image_generator_registry),
advisory_script_uri,
advisory_script_entrypoint,
context_.volatile_path_tracker,
context_.enable_impeller};
auto result =
std::make_unique<RuntimeController>(p_client, //
vm_, //

1
engine/src/flutter/shell/common/engine.cc
View File

@ -100,6 +100,7 @@ Engine::Engine(Delegate& delegate,
settings_.advisory_script_uri, // advisory script uri
settings_.advisory_script_entrypoint, // advisory script entrypoint
std::move(volatile_path_tracker), // volatile path tracker
settings_.enable_impeller, // enable impeller
});
}

26
engine/src/flutter/shell/common/rasterizer.cc
View File

@ -281,7 +281,7 @@ std::unique_ptr<SnapshotDelegate::GpuImageResult> MakeBitmapImage(
}
} // namespace
std::unique_ptr<SnapshotDelegate::GpuImageResult> Rasterizer::MakeGpuImage(
std::unique_ptr<Rasterizer::GpuImageResult> Rasterizer::MakeSkiaGpuImage(
sk_sp<DisplayList> display_list,
const SkImageInfo& image_info) {
TRACE_EVENT0("flutter", "Rasterizer::MakeGpuImage");
@ -536,8 +536,8 @@ RasterStatus Rasterizer::DrawToSurfaceUnsafe(
frame_timings_recorder.RecordRasterStart(fml::TimePoint::Now());
std::unique_ptr<FrameDamage> damage;
// when leaf layer tracing is enabled we wish to repaint the whole frame for
// accurate performance metrics.
// when leaf layer tracing is enabled we wish to repaint the whole frame
// for accurate performance metrics.
if (frame->framebuffer_info().supports_partial_repaint &&
!layer_tree.is_leaf_layer_tracing_enabled()) {
// Disable partial repaint if external_view_embedder_ SubmitFrame is
@ -576,9 +576,9 @@ RasterStatus Rasterizer::DrawToSurfaceUnsafe(
SurfaceFrame::SubmitInfo submit_info;
// TODO (https://github.com/flutter/flutter/issues/105596): this can be in
// the past and might need to get snapped to future as this frame could have
// been resubmitted. `presentation_time` on `submit_info` is not set in this
// case.
// the past and might need to get snapped to future as this frame could
// have been resubmitted. `presentation_time` on `submit_info` is not set
// in this case.
const auto presentation_time = frame_timings_recorder.GetVsyncTargetTime();
if (presentation_time > fml::TimePoint::Now()) {
submit_info.presentation_time = presentation_time;
@ -649,8 +649,8 @@ sk_sp<SkData> Rasterizer::ScreenshotLayerTreeAsImage(
flutter::CompositorContext& compositor_context,
GrDirectContext* surface_context,
bool compressed) {
// Attempt to create a snapshot surface depending on whether we have access to
// a valid GPU rendering context.
// Attempt to create a snapshot surface depending on whether we have access
// to a valid GPU rendering context.
std::unique_ptr<OffscreenSurface> snapshot_surface =
std::make_unique<OffscreenSurface>(surface_context, tree->frame_size());
@ -662,15 +662,15 @@ sk_sp<SkData> Rasterizer::ScreenshotLayerTreeAsImage(
// Draw the current layer tree into the snapshot surface.
auto* canvas = snapshot_surface->GetCanvas();
// There is no root surface transformation for the screenshot layer. Reset the
// matrix to identity.
// There is no root surface transformation for the screenshot layer. Reset
// the matrix to identity.
SkMatrix root_surface_transformation;
root_surface_transformation.reset();
// snapshot_surface->makeImageSnapshot needs the GL context to be set if the
// render context is GL. frame->Raster() pops the gl context in platforms that
// gl context switching are used. (For example, older iOS that uses GL) We
// reset the GL context using the context switch.
// render context is GL. frame->Raster() pops the gl context in platforms
// that gl context switching are used. (For example, older iOS that uses GL)
// We reset the GL context using the context switch.
auto context_switch = surface_->MakeRenderContextCurrent();
if (!context_switch->GetResult()) {
FML_LOG(ERROR) << "Screenshot: unable to make image screenshot";

10
engine/src/flutter/shell/common/rasterizer.h
View File

@ -106,11 +106,11 @@ class Rasterizer final : public SnapshotDelegate,
};
//----------------------------------------------------------------------------
/// @brief How to handle calls to MakeGpuImage.
/// @brief How to handle calls to MakeSkiaGpuImage.
enum class MakeGpuImageBehavior {
/// MakeGpuImage returns a GPU resident image, if possible.
/// MakeSkiaGpuImage returns a GPU resident image, if possible.
kGpu,
/// MakeGpuImage returns a checkerboard bitmap. This is useful in test
/// MakeSkiaGpuImage returns a checkerboard bitmap. This is useful in test
/// contexts where no GPU surface is available.
kBitmap,
};
@ -123,7 +123,7 @@ class Rasterizer final : public SnapshotDelegate,
///
/// @param[in] delegate The rasterizer delegate.
/// @param[in] gpu_image_behavior How to handle calls to
/// MakeGpuImage.
/// MakeSkiaGpuImage.
///
explicit Rasterizer(
Delegate& delegate,
@ -470,7 +470,7 @@ class Rasterizer final : public SnapshotDelegate,
private:
// |SnapshotDelegate|
std::unique_ptr<SnapshotDelegate::GpuImageResult> MakeGpuImage(
std::unique_ptr<GpuImageResult> MakeSkiaGpuImage(
sk_sp<DisplayList> display_list,
const SkImageInfo& image_info) override;