flutter::ImageEncodingImpeller Class Reference

#include <image_encoding_impeller.h>

Static Public Member Functions
static int	GetColorSpace (const std::shared_ptr< impeller::Texture > &texture)
static void	ConvertDlImageToSkImage (const sk_sp< DlImage > &dl_image, std::function< void(fml::StatusOr< sk_sp< SkImage > >)> encode_task, const fml::TaskRunnerAffineWeakPtr< SnapshotDelegate > &snapshot_delegate, const std::shared_ptr< impeller::Context > &impeller_context)
static void	ConvertImageToRaster (const sk_sp< DlImage > &dl_image, std::function< void(fml::StatusOr< sk_sp< SkImage > >)> encode_task, const fml::RefPtr< fml::TaskRunner > &raster_task_runner, const fml::RefPtr< fml::TaskRunner > &io_task_runner, const fml::TaskRunnerAffineWeakPtr< SnapshotDelegate > &snapshot_delegate, const std::shared_ptr< const fml::SyncSwitch > &is_gpu_disabled_sync_switch, const std::shared_ptr< impeller::Context > &impeller_context)

Detailed Description

Definition at line 21 of file image_encoding_impeller.h.

Member Function Documentation

ConvertDlImageToSkImage()

void flutter::ImageEncodingImpeller::ConvertDlImageToSkImage ( const sk_sp< DlImage > &  dl_image, std::function< void(fml::StatusOr< sk_sp< SkImage > >)>  encode_task, const fml::TaskRunnerAffineWeakPtr< SnapshotDelegate > &  snapshot_delegate, const std::shared_ptr< impeller::Context > &  impeller_context  )

static

Converts a DlImage to a SkImage. This should be called from the thread that corresponds to dl_image->owning_context() when gpu access is guaranteed. See also: ConvertImageToRaster. Visible for testing.

Definition at line 138 of file image_encoding_impeller.cc.

                                                            {
  auto impeller_image = dl_image->asImpellerImage();
  if (!impeller_image) {
    encode_task(fml::Status(fml::StatusCode::kFailedPrecondition,
                            "Image is not an Impeller image."));
    return;
  }
  auto texture = impeller_image->GetImpellerTexture(impeller_context);
 
  if (impeller_context == nullptr) {
    encode_task(fml::Status(fml::StatusCode::kFailedPrecondition,
                            "Impeller context was null."));
    return;
  }
 
  if (texture == nullptr) {
    encode_task(
        fml::Status(fml::StatusCode::kFailedPrecondition, "Image was null."));
    return;
  }
 
  auto dimensions = dl_image->GetSize();
  auto color_type = ToSkColorType(texture->GetTextureDescriptor().format);
 
  if (dimensions.IsEmpty()) {
    encode_task(fml::Status(fml::StatusCode::kFailedPrecondition,
                            "Image dimensions were empty."));
    return;
  }
 
  if (!color_type.has_value()) {
    encode_task(fml::Status(fml::StatusCode::kUnimplemented,
                            "Failed to get color type from pixel format."));
    return;
  }
 
  // Ensure that this thread has a context that can execute rendering
  // commands.  The thread may not already have a context if the raster
  // task runner was assigned to a new thread and no previous rendering
  // task has run on that thread.
  if (snapshot_delegate) {
    if (!snapshot_delegate->MakeRenderContextCurrent()) {
      encode_task(fml::Status(fml::StatusCode::kFailedPrecondition,
                              "Failed to bind the render context."));
      return;
    }
  }
 
  impeller::DeviceBufferDescriptor buffer_desc;
  buffer_desc.storage_mode = impeller::StorageMode::kHostVisible;
  buffer_desc.readback = true;  // set to false for testing.
  buffer_desc.size =
      texture->GetTextureDescriptor().GetByteSizeOfBaseMipLevel();
  auto buffer =
      impeller_context->GetResourceAllocator()->CreateBuffer(buffer_desc);
  if (!buffer) {
    encode_task(fml::Status(fml::StatusCode::kUnimplemented,
                            "Failed to allocate destination buffer."));
    return;
  }
 
  auto command_buffer = impeller_context->CreateCommandBuffer();
  command_buffer->SetLabel("BlitTextureToBuffer Command Buffer");
  auto pass = command_buffer->CreateBlitPass();
  pass->SetLabel("BlitTextureToBuffer Blit Pass");
  pass->AddCopy(texture, buffer);
  pass->EncodeCommands();
  auto completion = [buffer, color_type = color_type.value(), dimensions,
                     encode_task = std::move(encode_task)](
                        impeller::CommandBuffer::Status status) {
    if (status != impeller::CommandBuffer::Status::kCompleted) {
      encode_task(fml::Status(fml::StatusCode::kUnknown, ""));
      return;
    }
    buffer->Invalidate();
    auto sk_image =
        ConvertBufferToSkImage(buffer, color_type, ToSkISize(dimensions));
    encode_task(sk_image);
  };
 
  if (!impeller_context->GetCommandQueue()
           ->Submit({command_buffer}, completion)
           .ok()) {
    FML_LOG(ERROR) << "Failed to submit commands.";
  }
 
  impeller_context->DisposeThreadLocalCachedResources();
}

References flutter::buffer, color_type, FML_LOG, impeller::CommandBuffer::kCompleted, fml::kFailedPrecondition, impeller::kHostVisible, fml::kUnimplemented, fml::kUnknown, impeller::DeviceBufferDescriptor::readback, impeller::DeviceBufferDescriptor::size, impeller::DeviceBufferDescriptor::storage_mode, texture, and flutter::ToSkISize().

ConvertImageToRaster()

void flutter::ImageEncodingImpeller::ConvertImageToRaster ( const sk_sp< DlImage > &  dl_image, std::function< void(fml::StatusOr< sk_sp< SkImage > >)>  encode_task, const fml::RefPtr< fml::TaskRunner > &  raster_task_runner, const fml::RefPtr< fml::TaskRunner > &  io_task_runner, const fml::TaskRunnerAffineWeakPtr< SnapshotDelegate > &  snapshot_delegate, const std::shared_ptr< const fml::SyncSwitch > &  is_gpu_disabled_sync_switch, const std::shared_ptr< impeller::Context > &  impeller_context  )

static

Converts a DlImage to a SkImage. encode_task is executed with the resulting SkImage.

Definition at line 231 of file image_encoding_impeller.cc.

                                                            {
  auto original_encode_task = std::move(encode_task);
  encode_task = [original_encode_task = std::move(original_encode_task),
                 io_task_runner](fml::StatusOr<sk_sp<SkImage>> image) mutable {
    fml::TaskRunner::RunNowOrPostTask(
        io_task_runner,
        [original_encode_task = std::move(original_encode_task),
         image = std::move(image)]() { original_encode_task(image); });
  };
 
  if (dl_image->owning_context() != DlImage::OwningContext::kRaster) {
    DoConvertImageToRasterImpellerWithRetry(
        dl_image, std::move(encode_task),
        /*snapshot_delegate=*/{}, is_gpu_disabled_sync_switch, impeller_context,
        /*retry_runner=*/nullptr);
    return;
  }
 
  raster_task_runner->PostTask([dl_image, encode_task = std::move(encode_task),
                                io_task_runner, snapshot_delegate,
                                is_gpu_disabled_sync_switch, impeller_context,
                                raster_task_runner]() mutable {
    DoConvertImageToRasterImpellerWithRetry(
        dl_image, std::move(encode_task), snapshot_delegate,
        is_gpu_disabled_sync_switch, impeller_context, raster_task_runner);
  });
}

References image, flutter::DlImage::kRaster, and fml::TaskRunner::RunNowOrPostTask().

GetColorSpace()

int flutter::ImageEncodingImpeller::GetColorSpace ( const std::shared_ptr< impeller::Texture > &  texture )

static

Definition at line 266 of file image_encoding_impeller.cc.

                                                   {
  const impeller::TextureDescriptor& desc = texture->GetTextureDescriptor();
  switch (desc.format) {
    case impeller::PixelFormat::kB10G10R10XR:  // intentional_fallthrough
    case impeller::PixelFormat::kR16G16B16A16Float:
      return ColorSpace::kExtendedSRGB;
    default:
      return ColorSpace::kSRGB;
  }
}

References impeller::TextureDescriptor::format, impeller::kB10G10R10XR, flutter::kExtendedSRGB, impeller::kR16G16B16A16Float, flutter::kSRGB, and texture.

---

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

• lib/ui/painting/image_encoding_impeller.h
• lib/ui/painting/image_encoding_impeller.cc