flutter::ImageDecoderImpeller Class Reference

#include <image_decoder_impeller.h>

Inheritance diagram for flutter::ImageDecoderImpeller:

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, uint32_t target_width, uint32_t target_height, const ImageResult &result) override
Public Member Functions inherited from flutter::ImageDecoder
virtual	~ImageDecoder ()
fml::TaskRunnerAffineWeakPtr< ImageDecoder >	GetWeakPtr () const

Static Public Member Functions
static DecompressResult	DecompressTexture (ImageDescriptor *descriptor, SkISize target_size, 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 SkImageInfo &image_info, const std::shared_ptr< SkBitmap > &bitmap, 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
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 50 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 95 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, uint32_t  target_width, uint32_t  target_height, const ImageResult &  result  )

overridevirtual

Implements flutter::ImageDecoder.

Definition at line 532 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(),                                  //
       target_size = SkISize::Make(target_width, target_height),  //
       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, target_size, max_size_supported,
            /*supports_wide_gamut=*/wide_gamut_enabled &&
                context->GetCapabilities()->SupportsExtendedRangeFormats(),
            context->GetCapabilities(), context->GetResourceAllocator());
        if (!bitmap_result.device_buffer) {
          result(nullptr, bitmap_result.decode_error);
          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.sk_bitmap,      //
                                 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()

DecompressResult flutter::ImageDecoderImpeller::DecompressTexture ( ImageDescriptor *  descriptor, SkISize  target_size, 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

1. Decode the image.

1. If the decoded image isn't the requested target size and the src size exceeds the device max texture size, perform a slow CPU resize.

Definition at line 131 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 DecompressResult{.decode_error = decode_error};
  }
 
  target_size.set(std::min(static_cast<int32_t>(max_texture_size.width),
                           target_size.width()),
                  std::min(static_cast<int32_t>(max_texture_size.height),
                           target_size.height()));
 
  const SkISize source_size = descriptor->image_info().dimensions();
  auto 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()));
  }
 
  //----------------------------------------------------------------------------
  /// 1. Decode the image.
  ///
 
  const auto base_image_info = descriptor->image_info();
  const bool is_wide_gamut =
      supports_wide_gamut ? IsWideGamut(base_image_info.colorSpace()) : false;
  SkAlphaType alpha_type =
      ChooseCompatibleAlphaType(base_image_info.alphaType());
  SkImageInfo image_info;
  if (is_wide_gamut) {
    SkColorType color_type = alpha_type == SkAlphaType::kOpaque_SkAlphaType
                                 ? kBGR_101010x_XR_SkColorType
                                 : kRGBA_F16_SkColorType;
    image_info =
        base_image_info.makeWH(decode_size.width(), decode_size.height())
            .makeColorType(color_type)
            .makeAlphaType(alpha_type)
            .makeColorSpace(SkColorSpace::MakeSRGB());
  } else {
    image_info =
        base_image_info.makeWH(decode_size.width(), decode_size.height())
            .makeColorType(
                ChooseCompatibleColorType(base_image_info.colorType()))
            .makeAlphaType(alpha_type)
            .makeColorSpace(SkColorSpace::MakeSRGB());
  }
 
  const auto pixel_format = ToPixelFormat(image_info.colorType());
  if (!pixel_format.has_value()) {
    std::string decode_error(
        std::format("Codec pixel format is not supported (SkColorType={})",
                    static_cast<int>(image_info.colorType())));
    FML_DLOG(ERROR) << decode_error;
    return DecompressResult{.decode_error = decode_error};
  }
 
  auto bitmap = std::make_shared<SkBitmap>();
  bitmap->setInfo(image_info);
  auto bitmap_allocator = std::make_shared<ImpellerAllocator>(allocator);
 
  if (descriptor->is_compressed()) {
    if (!bitmap->tryAllocPixels(bitmap_allocator.get())) {
      std::string decode_error(
          "Could not allocate intermediate for image decompression.");
      FML_DLOG(ERROR) << decode_error;
      return DecompressResult{.decode_error = decode_error};
    }
    // Decode the image into the image generator's closest supported size.
    if (!descriptor->get_pixels(bitmap->pixmap())) {
      std::string decode_error("Could not decompress image.");
      FML_DLOG(ERROR) << decode_error;
      return DecompressResult{.decode_error = decode_error};
    }
  } else {
    auto temp_bitmap = std::make_shared<SkBitmap>();
    temp_bitmap->setInfo(base_image_info);
    auto pixel_ref = SkMallocPixelRef::MakeWithData(
        base_image_info, descriptor->row_bytes(), descriptor->data());
    temp_bitmap->setPixelRef(pixel_ref, 0, 0);
 
    if (!bitmap->tryAllocPixels(bitmap_allocator.get())) {
      std::string decode_error(
          "Could not allocate intermediate for pixel conversion.");
      FML_DLOG(ERROR) << decode_error;
      return DecompressResult{.decode_error = decode_error};
    }
    temp_bitmap->readPixels(bitmap->pixmap());
    bitmap->setImmutable();
  }
 
  // If the image is unpremultiplied, fix it.
  if (alpha_type == SkAlphaType::kUnpremul_SkAlphaType) {
    // Single copy of ImpellerAllocator crashes.
    auto premul_allocator = std::make_shared<ImpellerAllocator>(allocator);
    auto premul_bitmap = std::make_shared<SkBitmap>();
    premul_bitmap->setInfo(bitmap->info().makeAlphaType(kPremul_SkAlphaType));
    if (!premul_bitmap->tryAllocPixels(premul_allocator.get())) {
      std::string decode_error(
          "Could not allocate intermediate for premultiplication conversion.");
      FML_DLOG(ERROR) << decode_error;
      return DecompressResult{.decode_error = decode_error};
    }
    // readPixels() handles converting pixels to premultiplied form.
    bitmap->readPixels(premul_bitmap->pixmap());
    premul_bitmap->setImmutable();
    bitmap_allocator = premul_allocator;
    bitmap = premul_bitmap;
  }
 
  std::shared_ptr<impeller::DeviceBuffer> buffer =
      bitmap_allocator->GetDeviceBuffer();
  if (!buffer) {
    return DecompressResult{.decode_error = "Unable to get device buffer"};
  }
  buffer->Flush();
 
  std::optional<SkImageInfo> resize_info =
      bitmap->dimensions() == target_size
          ? std::nullopt
          : std::optional<SkImageInfo>(image_info.makeDimensions(target_size));
 
  if (source_size.width() > max_texture_size.width ||
      source_size.height() > max_texture_size.height ||
      !capabilities->SupportsTextureToTextureBlits()) {
    //----------------------------------------------------------------------------
    /// 2. If the decoded image isn't the requested target size and the src size
    ///    exceeds the device max texture size, perform a slow CPU resize.
    ///
    TRACE_EVENT0("impeller", "SlowCPUDecodeScale");
    const auto scaled_image_info = image_info.makeDimensions(target_size);
 
    auto scaled_bitmap = std::make_shared<SkBitmap>();
    auto scaled_allocator = std::make_shared<ImpellerAllocator>(allocator);
    scaled_bitmap->setInfo(scaled_image_info);
    if (!scaled_bitmap->tryAllocPixels(scaled_allocator.get())) {
      std::string decode_error(
          "Could not allocate scaled bitmap for image decompression.");
      FML_DLOG(ERROR) << decode_error;
      return DecompressResult{.decode_error = decode_error};
    }
    if (!bitmap->pixmap().scalePixels(
            scaled_bitmap->pixmap(),
            SkSamplingOptions(SkFilterMode::kLinear, SkMipmapMode::kNone))) {
      FML_LOG(ERROR) << "Could not scale decoded bitmap data.";
    }
    scaled_bitmap->setImmutable();
 
    std::shared_ptr<impeller::DeviceBuffer> buffer =
        scaled_allocator->GetDeviceBuffer();
    if (!buffer) {
      return DecompressResult{.decode_error = "Unable to get device buffer"};
    }
    buffer->Flush();
 
    return DecompressResult{.device_buffer = std::move(buffer),
                            .sk_bitmap = scaled_bitmap,
                            .image_info = scaled_bitmap->info()};
  }
 
  return DecompressResult{.device_buffer = std::move(buffer),
                          .sk_bitmap = bitmap,
                          .image_info = bitmap->info(),
                          .resize_info = resize_info};
}

References alpha_type, flutter::buffer, flutter::ChooseCompatibleAlphaType(), flutter::ChooseCompatibleColorType(), color_type, flutter::ImageDescriptor::data(), flutter::DecompressResult::decode_error, flutter::DecompressResult::device_buffer, FML_DLOG, FML_LOG, flutter::ImageDescriptor::get_pixels(), flutter::ImageDescriptor::get_scaled_dimensions(), impeller::TSize< T >::height, flutter::ImageDescriptor::image_info(), flutter::ImageDescriptor::is_compressed(), flutter::ImageDescriptor::row_bytes(), impeller::ToPixelFormat(), TRACE_EVENT0, and impeller::TSize< T >::width.

Referenced by 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().

UploadTextureToPrivate()

void flutter::ImageDecoderImpeller::UploadTextureToPrivate ( ImageResult  result, const std::shared_ptr< impeller::Context > &  context, const std::shared_ptr< impeller::DeviceBuffer > &  buffer, const SkImageInfo &  image_info, const std::shared_ptr< SkBitmap > &  bitmap, 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 428 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 475 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 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(), TRACE_EVENT0, and impeller::TSize< T >::width.

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