#include <image_decoder_impeller.h>

Inheritance diagram for flutter::ImageDecoderImpeller:

Classes
struct	DecompressResult

struct	ImageInfo

Public Member Functions
	ImageDecoderImpeller (const TaskRunners &runners, std::shared_ptr< fml::ConcurrentTaskRunner > concurrent_task_runner, const fml::WeakPtr< IOManager > &io_manager, bool supports_wide_gamut, const std::shared_ptr< fml::SyncSwitch > &gpu_disabled_switch)

	~ImageDecoderImpeller () override

void	Decode (fml::RefPtr< ImageDescriptor > descriptor, const Options &options, const ImageResult &result) override

Public Member Functions inherited from flutter::ImageDecoder
virtual	~ImageDecoder ()

fml::TaskRunnerAffineWeakPtr< ImageDecoder >	GetWeakPtr () const

Static Public Member Functions
static std::optional< impeller::PixelFormat >	ToPixelFormat (SkColorType type)

static absl::StatusOr< DecompressResult >	DecompressTexture (ImageDescriptor *descriptor, const ImageDecoder::Options &options, impeller::ISize max_texture_size, bool supports_wide_gamut, const std::shared_ptr< const impeller::Capabilities > &capabilities, const std::shared_ptr< impeller::Allocator > &allocator)

static void	UploadTextureToPrivate (ImageResult result, const std::shared_ptr< impeller::Context > &context, const std::shared_ptr< impeller::DeviceBuffer > &buffer, const ImageInfo &image_info, const std::optional< SkImageInfo > &resize_info, const std::shared_ptr< const fml::SyncSwitch > &gpu_disabled_switch)
	Create a device private texture from the provided host buffer.

static std::pair< sk_sp< DlImage >, std::string >	UploadTextureToStorage (const std::shared_ptr< impeller::Context > &context, std::shared_ptr< SkBitmap > bitmap)
	Create a texture from the provided bitmap.

Static Public Member Functions inherited from flutter::ImageDecoder
static std::unique_ptr< ImageDecoder >	Make (const Settings &settings, const TaskRunners &runners, std::shared_ptr< fml::ConcurrentTaskRunner > concurrent_task_runner, const fml::WeakPtr< IOManager > &io_manager, const std::shared_ptr< fml::SyncSwitch > &gpu_disabled_switch)

Additional Inherited Members
Public Types inherited from flutter::ImageDecoder
enum	TargetPixelFormat { kUnknown , kDontCare , kR32G32B32A32Float , kR32Float }

using	ImageResult = std::function< void(sk_sp< DlImage >, std::string)>

Protected Member Functions inherited from flutter::ImageDecoder
	ImageDecoder (const TaskRunners &runners, std::shared_ptr< fml::ConcurrentTaskRunner > concurrent_task_runner, fml::WeakPtr< IOManager > io_manager)

Protected Attributes inherited from flutter::ImageDecoder
TaskRunners	runners_

std::shared_ptr< fml::ConcurrentTaskRunner >	concurrent_task_runner_

fml::WeakPtr< IOManager >	io_manager_

Detailed Description

Definition at line 43 of file image_decoder_impeller.h.

Constructor & Destructor Documentation

◆ ImageDecoderImpeller()

flutter::ImageDecoderImpeller::ImageDecoderImpeller	(	const TaskRunners &	runners,
		std::shared_ptr< fml::ConcurrentTaskRunner >	concurrent_task_runner,
		const fml::WeakPtr< IOManager > &	io_manager,
		bool	supports_wide_gamut,
		const std::shared_ptr< fml::SyncSwitch > &	gpu_disabled_switch
	)

Definition at line 307 of file image_decoder_impeller.cc.

    : ImageDecoder(runners, std::move(concurrent_task_runner), io_manager),
      wide_gamut_enabled_(wide_gamut_enabled),
      gpu_disabled_switch_(gpu_disabled_switch) {
  std::promise<std::shared_ptr<impeller::Context>> context_promise;
  context_ = context_promise.get_future();
  runners_.GetIOTaskRunner()->PostTask(fml::MakeCopyable(
      [promise = std::move(context_promise), io_manager]() mutable {
        if (io_manager) {
          promise.set_value(io_manager->GetImpellerContext());
        } else {
          promise.set_value(nullptr);
        }
      }));
}

References flutter::TaskRunners::GetIOTaskRunner(), fml::MakeCopyable(), fml::TaskRunner::PostTask(), and flutter::ImageDecoder::runners_.

◆ ~ImageDecoderImpeller()

flutter::ImageDecoderImpeller::~ImageDecoderImpeller ( )

overridedefault

Member Function Documentation

◆ Decode()

void flutter::ImageDecoderImpeller::Decode	(	fml::RefPtr< ImageDescriptor >	descriptor,
		const Options &	options,
		const ImageResult &	result
	)

overridevirtual

Implements flutter::ImageDecoder.

Definition at line 668 of file image_decoder_impeller.cc.

                                                               {
  FML_DCHECK(descriptor);
  FML_DCHECK(p_result);
 
  // Wrap the result callback so that it can be invoked from any thread.
  auto raw_descriptor = descriptor.get();
  raw_descriptor->AddRef();
  ImageResult result = [p_result,                               //
                        raw_descriptor,                         //
                        ui_runner = runners_.GetUITaskRunner()  //
  ](const auto& image, const auto& decode_error) {
    ui_runner->PostTask([raw_descriptor, p_result, image, decode_error]() {
      raw_descriptor->Release();
      p_result(std::move(image), decode_error);
    });
  };
 
  concurrent_task_runner_->PostTask(
      [raw_descriptor,            //
       context = context_.get(),  //
       options,
       io_runner = runners_.GetIOTaskRunner(),  //
       result,
       wide_gamut_enabled = wide_gamut_enabled_,  //
       gpu_disabled_switch = gpu_disabled_switch_]() {
#if FML_OS_IOS_SIMULATOR
        // No-op backend.
        if (!context) {
          return;
        }
#endif  // FML_OS_IOS_SIMULATOR
 
        if (!context) {
          result(nullptr, "No Impeller context is available");
          return;
        }
        auto max_size_supported =
            context->GetResourceAllocator()->GetMaxTextureSizeSupported();
 
        // Always decompress on the concurrent runner.
        auto bitmap_result = DecompressTexture(
            raw_descriptor, options, max_size_supported,
            /*supports_wide_gamut=*/wide_gamut_enabled &&
                context->GetCapabilities()->SupportsExtendedRangeFormats(),
            context->GetCapabilities(), context->GetResourceAllocator());
        if (!bitmap_result.ok()) {
          result(nullptr, std::string(bitmap_result.status().message()));
          return;
        }
 
        auto upload_texture_and_invoke_result = [result, context, bitmap_result,
                                                 gpu_disabled_switch]() {
          UploadTextureToPrivate(result, context,               //
                                 bitmap_result->device_buffer,  //
                                 bitmap_result->image_info,     //
                                 bitmap_result->resize_info,    //
                                 gpu_disabled_switch            //
          );
        };
        // The I/O image uploads are not threadsafe on GLES.
        if (context->GetBackendType() ==
            impeller::Context::BackendType::kOpenGLES) {
          io_runner->PostTask(upload_texture_and_invoke_result);
        } else {
          upload_texture_and_invoke_result();
        }
      });
}

References FML_DCHECK, fml::RefPtr< T >::get(), image, and impeller::Context::kOpenGLES.

◆ DecompressTexture()

absl::StatusOr< ImageDecoderImpeller::DecompressResult > flutter::ImageDecoderImpeller::DecompressTexture	(	ImageDescriptor *	descriptor,
		const ImageDecoder::Options &	options,
		impeller::ISize	max_texture_size,
		bool	supports_wide_gamut,
		const std::shared_ptr< const impeller::Capabilities > &	capabilities,
		const std::shared_ptr< impeller::Allocator > &	allocator
	)

static

Definition at line 331 of file image_decoder_impeller.cc.

                                                       {
  TRACE_EVENT0("impeller", __FUNCTION__);
  if (!descriptor) {
    std::string decode_error("Invalid descriptor (should never happen)");
    FML_DLOG(ERROR) << decode_error;
    return absl::InvalidArgumentError(decode_error);
  }
 
  const SkISize source_size = SkISize::Make(descriptor->image_info().width,
                                            descriptor->image_info().height);
  const SkISize target_size =
      SkISize::Make(std::min(max_texture_size.width,
                             static_cast<int64_t>(options.target_width)),
                    std::min(max_texture_size.height,
                             static_cast<int64_t>(options.target_height)));
 
  // Fast path for when the input requires no decompressing or conversion.
  if (!descriptor->is_compressed() && source_size == target_size &&
      IsZeroOpConversion(descriptor->image_info().format,
                         options.target_format)) {
    impeller::DeviceBufferDescriptor desc;
    desc.storage_mode = impeller::StorageMode::kHostVisible;
    desc.size = descriptor->data()->size();
    std::shared_ptr<impeller::DeviceBuffer> buffer =
        allocator->CreateBuffer(desc);
    if (!buffer) {
      return absl::ResourceExhaustedError("Could not create buffer for image.");
    }
    sk_sp<SkData> data = descriptor->data();
    memcpy(buffer->OnGetContents(), data->bytes(), data->size());
    buffer->Flush();
 
    return ImageDecoderImpeller::DecompressResult{
        .device_buffer = std::move(buffer),
        .image_info =
            {
                .size =
                    impeller::ISize(source_size.width(), source_size.height()),
                .format = ToImpellerPixelFormat(options.target_format),
            },
    };
  }
 
  SkISize decode_size = source_size;
  if (descriptor->is_compressed()) {
    decode_size = descriptor->get_scaled_dimensions(std::max(
        static_cast<float>(target_size.width()) / source_size.width(),
        static_cast<float>(target_size.height()) / source_size.height()));
  }
 
  const SkImageInfo base_image_info =
      ImageDescriptor::ToSkImageInfo(descriptor->image_info());
  const absl::StatusOr<SkImageInfo> image_info = CreateImageInfo(
      base_image_info, decode_size, supports_wide_gamut, options.target_format);
 
  if (!image_info.ok()) {
    return image_info.status();
  }
 
  if (!ToPixelFormat(image_info.value().colorType()).has_value()) {
    std::string decode_error =
        std::format("Codec pixel format is not supported (SkColorType={})",
                    static_cast<int>(image_info.value().colorType()));
    FML_DLOG(ERROR) << decode_error;
    return absl::InvalidArgumentError(decode_error);
  }
 
  absl::StatusOr<DecodedBitmap> decoded = DecodeToBitmap(
      descriptor, image_info.value(), base_image_info, allocator);
  if (!decoded.ok()) {
    return decoded.status();
  }
 
  absl::StatusOr<DecodedBitmap> premultiplied =
      HandlePremultiplication(decoded->bitmap, decoded->allocator, allocator);
  if (!premultiplied.ok()) {
    return premultiplied.status();
  }
  std::shared_ptr<SkBitmap> bitmap = premultiplied->bitmap;
  std::shared_ptr<ImpellerAllocator> bitmap_allocator =
      premultiplied->allocator;
 
  if (source_size.width() > max_texture_size.width ||
      source_size.height() > max_texture_size.height ||
      !capabilities->SupportsTextureToTextureBlits()) {
    return ResizeOnCpu(bitmap, target_size, allocator);
  }
 
  std::shared_ptr<impeller::DeviceBuffer> buffer =
      bitmap_allocator->GetDeviceBuffer();
  if (!buffer) {
    return absl::InternalError("Unable to get device buffer");
  }
  buffer->Flush();
 
  std::optional<SkImageInfo> resize_info =
      bitmap->dimensions() == target_size
          ? std::nullopt
          : std::optional<SkImageInfo>(
                image_info.value().makeDimensions(target_size));
 
  absl::StatusOr<ImageDecoderImpeller::ImageInfo> decoded_image_info =
      ToImageInfo(bitmap->info());
  if (!decoded_image_info.ok()) {
    return decoded_image_info.status();
  }
 
  return ImageDecoderImpeller::DecompressResult{
      .device_buffer = std::move(buffer),
      .image_info = decoded_image_info.value(),
      .resize_info = resize_info};
}

References allocator, bitmap, flutter::buffer, flutter::ImageDescriptor::data(), flutter::data, flutter::ImageDecoderImpeller::DecompressResult::device_buffer, FML_DLOG, flutter::ImageDecoderImpeller::ImageInfo::format, flutter::ImageDescriptor::get_scaled_dimensions(), impeller::TSize< T >::height, flutter::ImageDescriptor::image_info(), flutter::ImageDescriptor::is_compressed(), impeller::kHostVisible, impeller::DeviceBufferDescriptor::size, impeller::DeviceBufferDescriptor::storage_mode, flutter::ImageDecoder::Options::target_format, flutter::ImageDecoder::Options::target_height, flutter::ImageDecoder::Options::target_width, ToPixelFormat(), flutter::ImageDescriptor::ToSkImageInfo(), TRACE_EVENT0, and impeller::TSize< T >::width.

Referenced by flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

◆ ToPixelFormat()

std::optional< impeller::PixelFormat > flutter::ImageDecoderImpeller::ToPixelFormat ( SkColorType type )

static

Definition at line 288 of file image_decoder_impeller.cc.

                      {
  switch (type) {
    case kRGBA_8888_SkColorType:
      return impeller::PixelFormat::kR8G8B8A8UNormInt;
    case kBGRA_8888_SkColorType:
      return impeller::PixelFormat::kB8G8R8A8UNormInt;
    case kRGBA_F16_SkColorType:
      return impeller::PixelFormat::kR16G16B16A16Float;
    case kBGR_101010x_XR_SkColorType:
      return impeller::PixelFormat::kB10G10R10XR;
    case kRGBA_F32_SkColorType:
      return impeller::PixelFormat::kR32G32B32A32Float;
    default:
      return std::nullopt;
  }
  return std::nullopt;
}

References impeller::kB10G10R10XR, impeller::kB8G8R8A8UNormInt, impeller::kR16G16B16A16Float, impeller::kR32G32B32A32Float, impeller::kR8G8B8A8UNormInt, and type.

Referenced by DecompressTexture().

◆ UploadTextureToPrivate()

void flutter::ImageDecoderImpeller::UploadTextureToPrivate	(	ImageResult	result,
		const std::shared_ptr< impeller::Context > &	context,
		const std::shared_ptr< impeller::DeviceBuffer > &	buffer,
		const ImageInfo &	image_info,
		const std::optional< SkImageInfo > &	resize_info,
		const std::shared_ptr< const fml::SyncSwitch > &	gpu_disabled_switch
	)

static

Create a device private texture from the provided host buffer.

Parameters

result	The image result closure that accepts the DlImage and any encoding error messages.
context	The Impeller graphics context.
buffer	A host buffer containing the image to be uploaded.
image_info	Format information about the particular image.
bitmap	A bitmap containg the image to be uploaded.
gpu_disabled_switch	Whether the GPU is available command encoding.

Definition at line 565 of file image_decoder_impeller.cc.

                                                                   {
  TRACE_EVENT0("impeller", __FUNCTION__);
  if (!context) {
    result(nullptr, "No Impeller context is available");
    return;
  }
  if (!buffer) {
    result(nullptr, "No Impeller device buffer is available");
    return;
  }
 
  gpu_disabled_switch->Execute(
      fml::SyncSwitch::Handlers()
          .SetIfFalse([&result, context, buffer, image_info, resize_info] {
            sk_sp<DlImage> image;
            std::string decode_error;
            std::tie(image, decode_error) = std::tie(image, decode_error) =
                UnsafeUploadTextureToPrivate(context, buffer, image_info,
                                             resize_info);
            result(image, decode_error);
          })
          .SetIfTrue([&result, context, buffer, image_info, resize_info] {
            auto result_ptr = std::make_shared<ImageResult>(std::move(result));
            context->StoreTaskForGPU(
                [result_ptr, context, buffer, image_info, resize_info]() {
                  sk_sp<DlImage> image;
                  std::string decode_error;
                  std::tie(image, decode_error) = UnsafeUploadTextureToPrivate(
                      context, buffer, image_info, resize_info);
                  (*result_ptr)(image, decode_error);
                },
                [result_ptr]() {
                  (*result_ptr)(
                      nullptr,
                      "Image upload failed due to loss of GPU access.");
                });
          }));
}

References flutter::buffer, image, and TRACE_EVENT0.

Referenced by flutter::testing::TEST_F(), and flutter::testing::TEST_F().

◆ UploadTextureToStorage()

std::pair< sk_sp< DlImage >, std::string > flutter::ImageDecoderImpeller::UploadTextureToStorage	(	const std::shared_ptr< impeller::Context > &	context,
		std::shared_ptr< SkBitmap >	bitmap
	)

static

Create a texture from the provided bitmap.

Parameters

context	The Impeller graphics context.
bitmap	A bitmap containg the image to be uploaded.

Returns: A DlImage.

Definition at line 611 of file image_decoder_impeller.cc.

                                    {
  TRACE_EVENT0("impeller", __FUNCTION__);
  if (!context) {
    return std::make_pair(nullptr, "No Impeller context is available");
  }
  if (!bitmap) {
    return std::make_pair(nullptr, "No texture bitmap is available");
  }
  const auto image_info = bitmap->info();
  const auto pixel_format = ToPixelFormat(image_info.colorType());
  if (!pixel_format) {
    std::string decode_error(
        std::format("Unsupported pixel format (SkColorType={})",
                    static_cast<int>(image_info.colorType())));
    FML_DLOG(ERROR) << decode_error;
    return std::make_pair(nullptr, decode_error);
  }
 
  impeller::TextureDescriptor texture_descriptor;
  texture_descriptor.storage_mode = impeller::StorageMode::kHostVisible;
  texture_descriptor.format = pixel_format.value();
  texture_descriptor.size = {image_info.width(), image_info.height()};
  texture_descriptor.mip_count = 1;
 
  auto texture =
      context->GetResourceAllocator()->CreateTexture(texture_descriptor);
  if (!texture) {
    std::string decode_error("Could not create Impeller texture.");
    FML_DLOG(ERROR) << decode_error;
    return std::make_pair(nullptr, decode_error);
  }
 
  auto mapping = std::make_shared<fml::NonOwnedMapping>(
      reinterpret_cast<const uint8_t*>(bitmap->getAddr(0, 0)),  // data
      texture_descriptor.GetByteSizeOfBaseMipLevel(),           // size
      [bitmap](auto, auto) mutable { bitmap.reset(); }          // proc
  );
 
  if (!texture->SetContents(mapping)) {
    std::string decode_error("Could not copy contents into Impeller texture.");
    FML_DLOG(ERROR) << decode_error;
    return std::make_pair(nullptr, decode_error);
  }
 
  texture->SetLabel(
      std::format("ui.Image({})", static_cast<const void*>(texture.get()))
          .c_str());
 
  context->DisposeThreadLocalCachedResources();
 
  return std::make_pair(impeller::DlImageImpeller::Make(std::move(texture)),
                        std::string());
}

References bitmap, FML_DLOG, impeller::TextureDescriptor::format, impeller::TextureDescriptor::GetByteSizeOfBaseMipLevel(), impeller::kHostVisible, impeller::DlImageImpeller::Make(), impeller::TextureDescriptor::mip_count, impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, texture, impeller::ToPixelFormat(), and TRACE_EVENT0.

Referenced by flutter::testing::TEST_F().

The documentation for this class was generated from the following files:

lib/ui/painting/image_decoder_impeller.h
lib/ui/painting/image_decoder_impeller.cc

Classes

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ImageDecoderImpeller()

◆ ~ImageDecoderImpeller()

Member Function Documentation

◆ Decode()

◆ DecompressTexture()

◆ ToPixelFormat()

◆ UploadTextureToPrivate()

◆ UploadTextureToStorage()