impeller::CompressedImageSkia Class Reference

#include <compressed_image_skia.h>

Inheritance diagram for impeller::CompressedImageSkia:

Public Member Functions
	CompressedImageSkia (std::shared_ptr< const fml::Mapping > allocation)
	~CompressedImageSkia () override
DecompressedImage	Decode () const override
Public Member Functions inherited from impeller::CompressedImage
virtual	~CompressedImage ()
bool	IsValid () const

Static Public Member Functions
static std::shared_ptr< CompressedImage >	Create (std::shared_ptr< const fml::Mapping > allocation)

Additional Inherited Members
Protected Member Functions inherited from impeller::CompressedImage
	CompressedImage (std::shared_ptr< const fml::Mapping > allocation)
Protected Attributes inherited from impeller::CompressedImage
const std::shared_ptr< const fml::Mapping >	source_

Detailed Description

Definition at line 13 of file compressed_image_skia.h.

Constructor & Destructor Documentation

CompressedImageSkia()

impeller::CompressedImageSkia::CompressedImageSkia ( std::shared_ptr< const fml::Mapping >  allocation )

explicit

Definition at line 27 of file compressed_image_skia.cc.

    : CompressedImage(std::move(allocation)) {}

~CompressedImageSkia()

impeller::CompressedImageSkia::~CompressedImageSkia ( )

overridedefault

Member Function Documentation

Create()

std::shared_ptr< CompressedImage > impeller::CompressedImageSkia::Create ( std::shared_ptr< const fml::Mapping >  allocation )

static

Definition at line 18 of file compressed_image_skia.cc.

                                                {
  // There is only one backend today.
  if (!allocation) {
    return nullptr;
  }
  return std::make_shared<CompressedImageSkia>(std::move(allocation));
}

Decode()

DecompressedImage impeller::CompressedImageSkia::Decode ( ) const

overridevirtual

Implements impeller::CompressedImage.

Definition at line 34 of file compressed_image_skia.cc.

                                                    {
  if (!IsValid()) {
    return {};
  }
  if (source_->GetSize() == 0u) {
    return {};
  }
 
  auto src = new std::shared_ptr<const fml::Mapping>(source_);
  auto sk_data = SkData::MakeWithProc(
      source_->GetMapping(), source_->GetSize(),
      [](const void* ptr, void* context) {
        delete reinterpret_cast<decltype(src)>(context);
      },
      src);
 
  auto image = SkImages::DeferredFromEncodedData(sk_data);
  if (!image) {
    return {};
  }
 
  const auto dims = image->imageInfo().dimensions();
  auto info = SkImageInfo::Make(dims.width(), dims.height(),
                                kRGBA_8888_SkColorType, kPremul_SkAlphaType);
 
  auto bitmap = std::make_shared<SkBitmap>();
  if (!bitmap->tryAllocPixels(info)) {
    VALIDATION_LOG << "Could not allocate arena for decompressing image.";
    return {};
  }
 
  if (!image->readPixels(nullptr, bitmap->pixmap(), 0, 0)) {
    VALIDATION_LOG << "Could not decompress image into arena.";
    return {};
  }
 
  auto mapping = std::make_shared<fml::NonOwnedMapping>(
      reinterpret_cast<const uint8_t*>(bitmap->pixmap().addr()),  // data
      bitmap->pixmap().rowBytes() * bitmap->pixmap().height(),    // size
      [bitmap](const uint8_t* data, size_t size) mutable {
        bitmap.reset();
      }  // proc
  );
 
  return {
      {bitmap->pixmap().dimensions().fWidth,
       bitmap->pixmap().dimensions().fHeight},  // size
      DecompressedImage::Format::kRGBA,         // format
      mapping                                   // allocation
  };
}

---

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

• impeller/playground/image/backends/skia/compressed_image_skia.h
• impeller/playground/image/backends/skia/compressed_image_skia.cc