flutter::ImageDecoderSkia Class Reference

#include <image_decoder_skia.h>

Inheritance diagram for flutter::ImageDecoderSkia:

Public Member Functions
	ImageDecoderSkia (const TaskRunners &runners, std::shared_ptr< fml::ConcurrentTaskRunner > concurrent_task_runner, fml::WeakPtr< IOManager > io_manager)
	~ImageDecoderSkia () 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::WeakPtr< ImageDecoder >	GetWeakPtr () const

Static Public Member Functions
static sk_sp< SkImage >	ImageFromCompressedData (ImageDescriptor *descriptor, uint32_t target_width, uint32_t target_height, const fml::tracing::TraceFlow &flow)
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, 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 13 of file image_decoder_skia.h.

Constructor & Destructor Documentation

ImageDecoderSkia()

flutter::ImageDecoderSkia::ImageDecoderSkia	(	const TaskRunners &	runners,
		std::shared_ptr< fml::ConcurrentTaskRunner >	concurrent_task_runner,
		fml::WeakPtr< IOManager >	io_manager
	)

Definition at line 18 of file image_decoder_skia.cc.

    : ImageDecoder(runners,
                   std::move(concurrent_task_runner),
                   std::move(io_manager)) {}

~ImageDecoderSkia()

flutter::ImageDecoderSkia::~ImageDecoderSkia ( )

overridedefault

Member Function Documentation

Decode()

void flutter::ImageDecoderSkia::Decode ( fml::RefPtr< ImageDescriptor >  descriptor, uint32_t  target_width, uint32_t  target_height, const ImageResult &  result  )

overridevirtual

Implements flutter::ImageDecoder.

Definition at line 220 of file image_decoder_skia.cc.

                                                           {
  TRACE_EVENT0("flutter", __FUNCTION__);
  fml::tracing::TraceFlow flow(__FUNCTION__);
 
  // ImageDescriptors have Dart peers that must be collected on the UI thread.
  // However, closures in MakeCopyable below capture the descriptor. The
  // captures of copyable closures may be collected on any of the thread
  // participating in task execution.
  //
  // To avoid this issue, we resort to manually reference counting the
  // descriptor. Since all task flows invoke the `result` callback, the raw
  // descriptor is retained in the beginning and released in the `result`
  // callback.
  //
  // `ImageDecoder::Decode` itself is invoked on the UI thread, so the
  // collection of the smart pointer from which we obtained the raw descriptor
  // is fine in this scope.
  auto raw_descriptor = descriptor_ref_ptr.get();
  raw_descriptor->AddRef();
 
  FML_DCHECK(callback);
  FML_DCHECK(runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());
 
  // Always service the callback (and cleanup the descriptor) on the UI thread.
  auto result =
      [callback, raw_descriptor, ui_runner = runners_.GetUITaskRunner()](
          SkiaGPUObject<SkImage> image, fml::tracing::TraceFlow flow) {
        ui_runner->PostTask(fml::MakeCopyable(
            [callback, raw_descriptor, image = std::move(image),
             flow = std::move(flow)]() mutable {
              // We are going to terminate the trace flow here. Flows cannot
              // terminate without a base trace. Add one explicitly.
              TRACE_EVENT0("flutter", "ImageDecodeCallback");
              flow.End();
              callback(DlImageGPU::Make(std::move(image)), {});
              raw_descriptor->Release();
            }));
      };
 
  if (!raw_descriptor->data() || raw_descriptor->data()->size() == 0) {
    result({}, std::move(flow));
    return;
  }
 
  concurrent_task_runner_->PostTask(
      fml::MakeCopyable([raw_descriptor,                          //
                         io_manager = io_manager_,                //
                         io_runner = runners_.GetIOTaskRunner(),  //
                         result,                                  //
                         target_width = target_width,             //
                         target_height = target_height,           //
                         flow = std::move(flow)                   //
  ]() mutable {
        // Step 1: Decompress the image.
        // On Worker.
 
        auto decompressed = raw_descriptor->is_compressed()
                                ? ImageFromCompressedData(raw_descriptor,  //
                                                          target_width,    //
                                                          target_height,   //
                                                          flow)
                                : ImageFromDecompressedData(raw_descriptor,  //
                                                            target_width,    //
                                                            target_height,   //
                                                            flow);
 
        if (!decompressed) {
          FML_DLOG(ERROR) << "Could not decompress image.";
          result({}, std::move(flow));
          return;
        }
 
        // Step 2: Update the image to the GPU.
        // On IO Thread.
 
        io_runner->PostTask(fml::MakeCopyable([io_manager, decompressed, result,
                                               flow =
                                                   std::move(flow)]() mutable {
          if (!io_manager) {
            FML_DLOG(ERROR) << "Could not acquire IO manager.";
            result({}, std::move(flow));
            return;
          }
 
          // If the IO manager does not have a resource context, the caller
          // might not have set one or a software backend could be in use.
          // Either way, just return the image as-is.
          if (!io_manager->GetResourceContext()) {
            result({std::move(decompressed), io_manager->GetSkiaUnrefQueue()},
                   std::move(flow));
            return;
          }
 
          auto uploaded =
              UploadRasterImage(std::move(decompressed), io_manager, flow);
 
          if (!uploaded.skia_object()) {
            FML_DLOG(ERROR) << "Could not upload image to the GPU.";
            result({}, std::move(flow));
            return;
          }
 
          // Finally, all done.
          result(std::move(uploaded), std::move(flow));
        }));
      }));
}

ImageFromCompressedData()

sk_sp< SkImage > flutter::ImageDecoderSkia::ImageFromCompressedData ( ImageDescriptor *  descriptor, uint32_t  target_width, uint32_t  target_height, const fml::tracing::TraceFlow &  flow  )

static

Definition at line 100 of file image_decoder_skia.cc.

                                     {
  TRACE_EVENT0("flutter", __FUNCTION__);
  flow.Step(__FUNCTION__);
 
  if (!descriptor->should_resize(target_width, target_height)) {
    // No resizing requested. Just decode & rasterize the image.
    sk_sp<SkImage> image = descriptor->image();
    return image ? image->makeRasterImage() : nullptr;
  }
 
  const SkISize source_dimensions = descriptor->image_info().dimensions();
  const SkISize resized_dimensions = {static_cast<int32_t>(target_width),
                                      static_cast<int32_t>(target_height)};
 
  auto decode_dimensions = descriptor->get_scaled_dimensions(
      std::max(static_cast<float>(resized_dimensions.width()) /
                   source_dimensions.width(),
               static_cast<float>(resized_dimensions.height()) /
                   source_dimensions.height()));
 
  // If the codec supports efficient sub-pixel decoding, decoded at a resolution
  // close to the target resolution before resizing.
  if (decode_dimensions != source_dimensions) {
    auto scaled_image_info =
        descriptor->image_info().makeDimensions(decode_dimensions);
 
    SkBitmap scaled_bitmap;
    if (!scaled_bitmap.tryAllocPixels(scaled_image_info)) {
      FML_LOG(ERROR) << "Failed to allocate memory for bitmap of size "
                     << scaled_image_info.computeMinByteSize() << "B";
      return nullptr;
    }
 
    const auto& pixmap = scaled_bitmap.pixmap();
    if (descriptor->get_pixels(pixmap)) {
      // Marking this as immutable makes the MakeFromBitmap call share
      // the pixels instead of copying.
      scaled_bitmap.setImmutable();
 
      auto decoded_image = SkImages::RasterFromBitmap(scaled_bitmap);
      FML_DCHECK(decoded_image);
      if (!decoded_image) {
        FML_LOG(ERROR)
            << "Could not create a scaled image from a scaled bitmap.";
        return nullptr;
      }
      return ResizeRasterImage(decoded_image, resized_dimensions, flow);
    }
  }
 
  auto image = descriptor->image();
  if (!image) {
    return nullptr;
  }
 
  return ResizeRasterImage(image, resized_dimensions, flow);
}

---

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

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