engine/src/flutter/skwasm/surface.cc - mirrors/flutter.git - Git at Google

 // 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/skwasm/surface.h"

 #include <algorithm>

 #include <emscripten/wasm_worker.h>

 #include "flutter/display_list/display_list.h"
 #include "flutter/display_list/image/dl_image.h"
 #include "flutter/skwasm/live_objects.h"
 #include "flutter/skwasm/skwasm_support.h"
 #include "third_party/skia/include/core/SkColorSpace.h"

 Skwasm::Surface::Surface() {
   if (skwasm_isSingleThreaded()) {
     skwasm_connectThread(0);
   } else {
     assert(emscripten_is_main_browser_thread());

     thread_ = emscripten_malloc_wasm_worker(65536);
     emscripten_wasm_worker_post_function_v(thread_, []() {
       // Listen to the main thread from the worker
       skwasm_connectThread(0);
     });

     // Listen to messages from the worker
     skwasm_connectThread(thread_);
   }
 }

 // Worker thread only
 void Skwasm::Surface::Dispose() {
   delete this;
 }

 // Main thread only
 void Skwasm::Surface::SetResourceCacheLimit(int bytes) {
   render_context_->SetResourceCacheLimit(bytes);
 }

 // Main thread only
 uint32_t Skwasm::Surface::RenderPictures(flutter::DisplayList** pictures,
                                          int width,
                                          int height,
                                          int count) {
   assert(emscripten_is_main_browser_thread());
   uint32_t callback_id = ++current_callback_id_;
   std::unique_ptr<sk_sp<flutter::DisplayList>[]> picture_pointers =
       std::make_unique<sk_sp<flutter::DisplayList>[]>(count);
   for (int i = 0; i < count; i++) {
     picture_pointers[i] = sk_ref_sp(pictures[i]);
   }

   // Releasing picturePointers here and will recreate the unique_ptr on the
   // other thread See surface_renderPicturesOnWorker
   skwasm_dispatchRenderPictures(thread_, this, picture_pointers.release(),
                                 width, height, count, callback_id);
   return callback_id;
 }

 // Main thread only
 uint32_t Skwasm::Surface::RasterizeImage(flutter::DlImage* image,
                                          Skwasm::ImageByteFormat format) {
   assert(emscripten_is_main_browser_thread());
   uint32_t callback_id = ++current_callback_id_;
   image->ref();

   skwasm_dispatchRasterizeImage(thread_, this, image, format, callback_id);
   return callback_id;
 }

 std::unique_ptr<Skwasm::TextureSourceWrapper>
 Skwasm::Surface::CreateTextureSourceWrapper(
     Skwasm::SkwasmObject texture_source) {
   return std::unique_ptr<Skwasm::TextureSourceWrapper>(
       new Skwasm::TextureSourceWrapper(thread_, texture_source));
 }

 // Main thread only
 void Skwasm::Surface::SetCallbackHandler(
     Skwasm::Surface::CallbackHandler* callback_handler) {
   assert(emscripten_is_main_browser_thread());
   callback_handler_ = callback_handler;
 }

 // Worker thread only
 void Skwasm::Surface::Init() {
   // 256x256 is just an arbitrary size for the initial canvas, so that we can
   // get a gl context off of it.
   gl_context_ = skwasm_createOffscreenCanvas(256, 256);
   if (!gl_context_) {
     printf("Failed to create context!\n");
     return;
   }

   Skwasm::makeCurrent(gl_context_);
   emscripten_webgl_enable_extension(gl_context_, "WEBGL_debug_renderer_info");

   // WebGL should already be clearing the color and stencil buffers, but do it
   // again here to ensure Skia receives them in the expected state.
   emscripten_glBindFramebuffer(GL_FRAMEBUFFER, 0);
   emscripten_glClearColor(0, 0, 0, 0);
   emscripten_glClearStencil(0);
   emscripten_glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

   int sample_count;
   int stencil;
   emscripten_glGetIntegerv(GL_SAMPLES, &sample_count);
   emscripten_glGetIntegerv(GL_STENCIL_BITS, &stencil);

   render_context_ = Skwasm::RenderContext::Make(sample_count, stencil);
   render_context_->Resize(256, 256);

   is_initialized_ = true;
 }

 // Worker thread only
 void Skwasm::Surface::ResizeSurface(int width, int height) {
   if (width != canvas_width_ || height != canvas_height_) {
     canvas_width_ = width;
     canvas_height_ = height;
     RecreateSurface();
   }
 }

 // Worker thread only
 void Skwasm::Surface::RecreateSurface() {
   Skwasm::makeCurrent(gl_context_);
   skwasm_resizeCanvas(gl_context_, canvas_width_, canvas_height_);
   render_context_->Resize(canvas_width_, canvas_height_);
 }

 // Worker thread only
 void Skwasm::Surface::RenderPicturesOnWorker(
     sk_sp<flutter::DisplayList>* pictures,
     int width,
     int height,
     int picture_count,
     uint32_t callback_id,
     double raster_start) {
   if (!is_initialized_) {
     Init();
   }

   // This is initialized on the first call to `skwasm_captureImageBitmap` and
   // then populated with more bitmaps on subsequent calls.
   Skwasm::SkwasmObject image_bitmap_array = __builtin_wasm_ref_null_extern();
   for (int i = 0; i < picture_count; i++) {
     sk_sp<flutter::DisplayList> picture = pictures[i];
     ResizeSurface(width, height);
     Skwasm::makeCurrent(gl_context_);

     render_context_->RenderPicture(picture);

     image_bitmap_array =
         skwasm_captureImageBitmap(gl_context_, image_bitmap_array);
   }
   skwasm_resolveAndPostImages(this, image_bitmap_array, raster_start,
                               callback_id);
 }

 // Worker thread only
 void Skwasm::Surface::RasterizeImageOnWorker(flutter::DlImage* image,
                                              Skwasm::ImageByteFormat format,
                                              uint32_t callback_id) {
   if (!is_initialized_) {
     Init();
   }

   // We handle PNG encoding with browser APIs so that we can omit libpng from
   // skia to save binary size.
   assert(format != Skwasm::ImageByteFormat::png);
   SkAlphaType alpha_type = format == Skwasm::ImageByteFormat::rawStraightRgba
                                ? SkAlphaType::kUnpremul_SkAlphaType
                                : SkAlphaType::kPremul_SkAlphaType;
   SkImageInfo info = SkImageInfo::Make(image->width(), image->height(),
                                        SkColorType::kRGBA_8888_SkColorType,
                                        alpha_type, SkColorSpace::MakeSRGB());
   sk_sp<SkData> data;
   size_t bytes_per_row = 4 * image->width();
   size_t byte_size = info.computeByteSize(bytes_per_row);
   data = SkData::MakeUninitialized(byte_size);
   uint8_t* pixels = reinterpret_cast<uint8_t*>(data->writable_data());

   // TODO(jacksongardner):
   // Normally we'd just call `readPixels` on the image. However, this doesn't
   // actually work in some cases due to a skia bug. Instead, we just draw the
   // image to our scratch canvas and grab the pixels out directly with
   // `glReadPixels`. Once the skia bug is fixed, we should switch back to using
   // `SkImage::readPixels` instead.
   // See https://g-issues.skia.org/issues/349201915
   ResizeSurface(image->width(), image->height());

   render_context_->RenderImage(image, format);

   emscripten_glReadPixels(0, 0, image->width(), image->height(), GL_RGBA,
                           GL_UNSIGNED_BYTE, reinterpret_cast<void*>(pixels));

   image->unref();
   skwasm_postRasterizeResult(this, data.release(), callback_id);
 }

 void Skwasm::Surface::OnRasterizeComplete(uint32_t callback_id, SkData* data) {
   callback_handler_(callback_id, data, __builtin_wasm_ref_null_extern());
 }

 // Main thread only
 void Skwasm::Surface::OnRenderComplete(uint32_t callback_id,
                                        Skwasm::SkwasmObject image_bitmap) {
   assert(emscripten_is_main_browser_thread());
   callback_handler_(callback_id, nullptr, image_bitmap);
 }

 Skwasm::TextureSourceWrapper::TextureSourceWrapper(
     unsigned long thread_id,
     Skwasm::SkwasmObject texture_source)
     : raster_thread_id_(thread_id) {
   skwasm_setAssociatedObjectOnThread(raster_thread_id_, this, texture_source);
 }

 Skwasm::TextureSourceWrapper::~TextureSourceWrapper() {
   skwasm_disposeAssociatedObjectOnThread(raster_thread_id_, this);
 }

 Skwasm::SkwasmObject Skwasm::TextureSourceWrapper::GetTextureSource() {
   return skwasm_getAssociatedObject(this);
 }

 SKWASM_EXPORT Skwasm::Surface* surface_create() {
   Skwasm::live_surface_count++;
   return new Skwasm::Surface();
 }

 SKWASM_EXPORT unsigned long surface_getThreadId(Skwasm::Surface* surface) {
   return surface->GetThreadId();
 }

 SKWASM_EXPORT void surface_setCallbackHandler(
     Skwasm::Surface* surface,
     Skwasm::Surface::CallbackHandler* callback_handler) {
   surface->SetCallbackHandler(callback_handler);
 }

 SKWASM_EXPORT void surface_destroy(Skwasm::Surface* surface) {
   Skwasm::live_surface_count--;
   // Dispatch to the worker
   skwasm_dispatchDisposeSurface(surface->GetThreadId(), surface);
 }

 SKWASM_EXPORT void surface_dispose(Skwasm::Surface* surface) {
   // This should be called directly only on the worker
   surface->Dispose();
 }

 SKWASM_EXPORT void surface_setResourceCacheLimitBytes(Skwasm::Surface* surface,
                                                       int bytes) {
   surface->SetResourceCacheLimit(bytes);
 }

 SKWASM_EXPORT uint32_t surface_renderPictures(Skwasm::Surface* surface,
                                               flutter::DisplayList** pictures,
                                               int width,
                                               int height,
                                               int count) {
   return surface->RenderPictures(pictures, width, height, count);
 }

 SKWASM_EXPORT void surface_renderPicturesOnWorker(
     Skwasm::Surface* surface,
     sk_sp<flutter::DisplayList>* pictures,
     int width,
     int height,
     int picture_count,
     uint32_t callback_id,
     double raster_start) {
   // This will release the pictures when they leave scope.
   std::unique_ptr<sk_sp<flutter::DisplayList>[]> pictures_pointer =
       std::unique_ptr<sk_sp<flutter::DisplayList>[]>(pictures);
   surface->RenderPicturesOnWorker(pictures, width, height, picture_count,
                                   callback_id, raster_start);
 }

 SKWASM_EXPORT uint32_t surface_rasterizeImage(Skwasm::Surface* surface,
                                               flutter::DlImage* image,
                                               Skwasm::ImageByteFormat format) {
   return surface->RasterizeImage(image, format);
 }

 SKWASM_EXPORT void surface_rasterizeImageOnWorker(
     Skwasm::Surface* surface,
     flutter::DlImage* image,
     Skwasm::ImageByteFormat format,
     uint32_t callback_id) {
   surface->RasterizeImageOnWorker(image, format, callback_id);
 }

 // This is used by the skwasm JS support code to call back into C++ when the
 // we finish creating the image bitmap, which is an asynchronous operation.
 SKWASM_EXPORT void surface_onRenderComplete(Skwasm::Surface* surface,
                                             uint32_t callback_id,
                                             Skwasm::SkwasmObject image_bitmap) {
   surface->OnRenderComplete(callback_id, image_bitmap);
 }

 SKWASM_EXPORT void surface_onRasterizeComplete(Skwasm::Surface* surface,
                                                SkData* data,
                                                uint32_t callback_id) {
   surface->OnRasterizeComplete(callback_id, data);
 }

 SKWASM_EXPORT bool skwasm_isMultiThreaded() {
   return !skwasm_isSingleThreaded();
 }
	// 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/skwasm/surface.h"

	#include <algorithm>

	#include <emscripten/wasm_worker.h>

	#include "flutter/display_list/display_list.h"
	#include "flutter/display_list/image/dl_image.h"
	#include "flutter/skwasm/live_objects.h"
	#include "flutter/skwasm/skwasm_support.h"
	#include "third_party/skia/include/core/SkColorSpace.h"

	Skwasm::Surface::Surface() {
	if (skwasm_isSingleThreaded()) {
	skwasm_connectThread(0);
	} else {
	assert(emscripten_is_main_browser_thread());

	thread_ = emscripten_malloc_wasm_worker(65536);
	emscripten_wasm_worker_post_function_v(thread_, []() {
	// Listen to the main thread from the worker
	skwasm_connectThread(0);
	});

	// Listen to messages from the worker
	skwasm_connectThread(thread_);
	}
	}

	// Worker thread only
	void Skwasm::Surface::Dispose() {
	delete this;
	}

	// Main thread only
	void Skwasm::Surface::SetResourceCacheLimit(int bytes) {
	render_context_->SetResourceCacheLimit(bytes);
	}

	// Main thread only
	uint32_t Skwasm::Surface::RenderPictures(flutter::DisplayList** pictures,
	int width,
	int height,
	int count) {
	assert(emscripten_is_main_browser_thread());
	uint32_t callback_id = ++current_callback_id_;
	std::unique_ptr<sk_sp<flutter::DisplayList>[]> picture_pointers =
	std::make_unique<sk_sp<flutter::DisplayList>[]>(count);
	for (int i = 0; i < count; i++) {
	picture_pointers[i] = sk_ref_sp(pictures[i]);
	}

	// Releasing picturePointers here and will recreate the unique_ptr on the
	// other thread See surface_renderPicturesOnWorker
	skwasm_dispatchRenderPictures(thread_, this, picture_pointers.release(),
	width, height, count, callback_id);
	return callback_id;
	}

	// Main thread only
	uint32_t Skwasm::Surface::RasterizeImage(flutter::DlImage* image,
	Skwasm::ImageByteFormat format) {
	assert(emscripten_is_main_browser_thread());
	uint32_t callback_id = ++current_callback_id_;
	image->ref();

	skwasm_dispatchRasterizeImage(thread_, this, image, format, callback_id);
	return callback_id;
	}

	std::unique_ptr<Skwasm::TextureSourceWrapper>
	Skwasm::Surface::CreateTextureSourceWrapper(
	Skwasm::SkwasmObject texture_source) {
	return std::unique_ptr<Skwasm::TextureSourceWrapper>(
	new Skwasm::TextureSourceWrapper(thread_, texture_source));
	}

	// Main thread only
	void Skwasm::Surface::SetCallbackHandler(
	Skwasm::Surface::CallbackHandler* callback_handler) {
	assert(emscripten_is_main_browser_thread());
	callback_handler_ = callback_handler;
	}

	// Worker thread only
	void Skwasm::Surface::Init() {
	// 256x256 is just an arbitrary size for the initial canvas, so that we can
	// get a gl context off of it.
	gl_context_ = skwasm_createOffscreenCanvas(256, 256);
	if (!gl_context_) {
	printf("Failed to create context!\n");
	return;
	}

	Skwasm::makeCurrent(gl_context_);
	emscripten_webgl_enable_extension(gl_context_, "WEBGL_debug_renderer_info");

	// WebGL should already be clearing the color and stencil buffers, but do it
	// again here to ensure Skia receives them in the expected state.
	emscripten_glBindFramebuffer(GL_FRAMEBUFFER, 0);
	emscripten_glClearColor(0, 0, 0, 0);
	emscripten_glClearStencil(0);
	emscripten_glClear(GL_COLOR_BUFFER_BIT \| GL_STENCIL_BUFFER_BIT);

	int sample_count;
	int stencil;
	emscripten_glGetIntegerv(GL_SAMPLES, &sample_count);
	emscripten_glGetIntegerv(GL_STENCIL_BITS, &stencil);

	render_context_ = Skwasm::RenderContext::Make(sample_count, stencil);
	render_context_->Resize(256, 256);

	is_initialized_ = true;
	}

	// Worker thread only
	void Skwasm::Surface::ResizeSurface(int width, int height) {
	if (width != canvas_width_ \|\| height != canvas_height_) {
	canvas_width_ = width;
	canvas_height_ = height;
	RecreateSurface();
	}
	}

	// Worker thread only
	void Skwasm::Surface::RecreateSurface() {
	Skwasm::makeCurrent(gl_context_);
	skwasm_resizeCanvas(gl_context_, canvas_width_, canvas_height_);
	render_context_->Resize(canvas_width_, canvas_height_);
	}

	// Worker thread only
	void Skwasm::Surface::RenderPicturesOnWorker(
	sk_sp<flutter::DisplayList>* pictures,
	int width,
	int height,
	int picture_count,
	uint32_t callback_id,
	double raster_start) {
	if (!is_initialized_) {
	Init();
	}

	// This is initialized on the first call to `skwasm_captureImageBitmap` and
	// then populated with more bitmaps on subsequent calls.
	Skwasm::SkwasmObject image_bitmap_array = __builtin_wasm_ref_null_extern();
	for (int i = 0; i < picture_count; i++) {
	sk_sp<flutter::DisplayList> picture = pictures[i];
	ResizeSurface(width, height);
	Skwasm::makeCurrent(gl_context_);

	render_context_->RenderPicture(picture);

	image_bitmap_array =
	skwasm_captureImageBitmap(gl_context_, image_bitmap_array);
	}
	skwasm_resolveAndPostImages(this, image_bitmap_array, raster_start,
	callback_id);
	}

	// Worker thread only
	void Skwasm::Surface::RasterizeImageOnWorker(flutter::DlImage* image,
	Skwasm::ImageByteFormat format,
	uint32_t callback_id) {
	if (!is_initialized_) {
	Init();
	}

	// We handle PNG encoding with browser APIs so that we can omit libpng from
	// skia to save binary size.
	assert(format != Skwasm::ImageByteFormat::png);
	SkAlphaType alpha_type = format == Skwasm::ImageByteFormat::rawStraightRgba
	? SkAlphaType::kUnpremul_SkAlphaType
	: SkAlphaType::kPremul_SkAlphaType;
	SkImageInfo info = SkImageInfo::Make(image->width(), image->height(),
	SkColorType::kRGBA_8888_SkColorType,
	alpha_type, SkColorSpace::MakeSRGB());
	sk_sp<SkData> data;
	size_t bytes_per_row = 4 * image->width();
	size_t byte_size = info.computeByteSize(bytes_per_row);
	data = SkData::MakeUninitialized(byte_size);
	uint8_t* pixels = reinterpret_cast<uint8_t*>(data->writable_data());

	// TODO(jacksongardner):
	// Normally we'd just call `readPixels` on the image. However, this doesn't
	// actually work in some cases due to a skia bug. Instead, we just draw the
	// image to our scratch canvas and grab the pixels out directly with
	// `glReadPixels`. Once the skia bug is fixed, we should switch back to using
	// `SkImage::readPixels` instead.
	// See https://g-issues.skia.org/issues/349201915
	ResizeSurface(image->width(), image->height());

	render_context_->RenderImage(image, format);

	emscripten_glReadPixels(0, 0, image->width(), image->height(), GL_RGBA,
	GL_UNSIGNED_BYTE, reinterpret_cast<void*>(pixels));

	image->unref();
	skwasm_postRasterizeResult(this, data.release(), callback_id);
	}

	void Skwasm::Surface::OnRasterizeComplete(uint32_t callback_id, SkData* data) {
	callback_handler_(callback_id, data, __builtin_wasm_ref_null_extern());
	}

	// Main thread only
	void Skwasm::Surface::OnRenderComplete(uint32_t callback_id,
	Skwasm::SkwasmObject image_bitmap) {
	assert(emscripten_is_main_browser_thread());
	callback_handler_(callback_id, nullptr, image_bitmap);
	}

	Skwasm::TextureSourceWrapper::TextureSourceWrapper(
	unsigned long thread_id,
	Skwasm::SkwasmObject texture_source)
	: raster_thread_id_(thread_id) {
	skwasm_setAssociatedObjectOnThread(raster_thread_id_, this, texture_source);
	}

	Skwasm::TextureSourceWrapper::~TextureSourceWrapper() {
	skwasm_disposeAssociatedObjectOnThread(raster_thread_id_, this);
	}

	Skwasm::SkwasmObject Skwasm::TextureSourceWrapper::GetTextureSource() {
	return skwasm_getAssociatedObject(this);
	}

	SKWASM_EXPORT Skwasm::Surface* surface_create() {
	Skwasm::live_surface_count++;
	return new Skwasm::Surface();
	}

	SKWASM_EXPORT unsigned long surface_getThreadId(Skwasm::Surface* surface) {
	return surface->GetThreadId();
	}

	SKWASM_EXPORT void surface_setCallbackHandler(
	Skwasm::Surface* surface,
	Skwasm::Surface::CallbackHandler* callback_handler) {
	surface->SetCallbackHandler(callback_handler);
	}

	SKWASM_EXPORT void surface_destroy(Skwasm::Surface* surface) {
	Skwasm::live_surface_count--;
	// Dispatch to the worker
	skwasm_dispatchDisposeSurface(surface->GetThreadId(), surface);
	}

	SKWASM_EXPORT void surface_dispose(Skwasm::Surface* surface) {
	// This should be called directly only on the worker
	surface->Dispose();
	}

	SKWASM_EXPORT void surface_setResourceCacheLimitBytes(Skwasm::Surface* surface,
	int bytes) {
	surface->SetResourceCacheLimit(bytes);
	}

	SKWASM_EXPORT uint32_t surface_renderPictures(Skwasm::Surface* surface,
	flutter::DisplayList** pictures,
	int width,
	int height,
	int count) {
	return surface->RenderPictures(pictures, width, height, count);
	}

	SKWASM_EXPORT void surface_renderPicturesOnWorker(
	Skwasm::Surface* surface,
	sk_sp<flutter::DisplayList>* pictures,
	int width,
	int height,
	int picture_count,
	uint32_t callback_id,
	double raster_start) {
	// This will release the pictures when they leave scope.
	std::unique_ptr<sk_sp<flutter::DisplayList>[]> pictures_pointer =
	std::unique_ptr<sk_sp<flutter::DisplayList>[]>(pictures);
	surface->RenderPicturesOnWorker(pictures, width, height, picture_count,
	callback_id, raster_start);
	}

	SKWASM_EXPORT uint32_t surface_rasterizeImage(Skwasm::Surface* surface,
	flutter::DlImage* image,
	Skwasm::ImageByteFormat format) {
	return surface->RasterizeImage(image, format);
	}

	SKWASM_EXPORT void surface_rasterizeImageOnWorker(
	Skwasm::Surface* surface,
	flutter::DlImage* image,
	Skwasm::ImageByteFormat format,
	uint32_t callback_id) {
	surface->RasterizeImageOnWorker(image, format, callback_id);
	}

	// This is used by the skwasm JS support code to call back into C++ when the
	// we finish creating the image bitmap, which is an asynchronous operation.
	SKWASM_EXPORT void surface_onRenderComplete(Skwasm::Surface* surface,
	uint32_t callback_id,
	Skwasm::SkwasmObject image_bitmap) {
	surface->OnRenderComplete(callback_id, image_bitmap);
	}

	SKWASM_EXPORT void surface_onRasterizeComplete(Skwasm::Surface* surface,
	SkData* data,
	uint32_t callback_id) {
	surface->OnRasterizeComplete(callback_id, data);
	}

	SKWASM_EXPORT bool skwasm_isMultiThreaded() {
	return !skwasm_isSingleThreaded();
	}