src/codec/SkHeifCodec.cpp - skia - Git at Google

 /*
  * Copyright 2017 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include "include/core/SkTypes.h"

 #ifdef SK_HAS_HEIF_LIBRARY
 #include "include/codec/SkCodec.h"
 #include "include/core/SkStream.h"
 #include "include/private/SkColorData.h"
 #include "src/codec/SkCodecPriv.h"
 #include "src/codec/SkHeifCodec.h"
 #include "src/core/SkEndian.h"

 #define FOURCC(c1, c2, c3, c4) \
     ((c1) << 24 | (c2) << 16 | (c3) << 8 | (c4))

 bool SkHeifCodec::IsSupported(const void* buffer, size_t bytesRead,
                               SkEncodedImageFormat* format) {
     // Parse the ftyp box up to bytesRead to determine if this is HEIF or AVIF.
     // Any valid ftyp box should have at least 8 bytes.
     if (bytesRead < 8) {
         return false;
     }

     uint32_t* ptr = (uint32_t*)buffer;
     uint64_t chunkSize = SkEndian_SwapBE32(ptr[0]);
     uint32_t chunkType = SkEndian_SwapBE32(ptr[1]);

     if (chunkType != FOURCC('f', 't', 'y', 'p')) {
         return false;
     }

     int64_t offset = 8;
     if (chunkSize == 1) {
         // This indicates that the next 8 bytes represent the chunk size,
         // and chunk data comes after that.
         if (bytesRead < 16) {
             return false;
         }
         auto* chunkSizePtr = SkTAddOffset<const uint64_t>(buffer, offset);
         chunkSize = SkEndian_SwapBE64(*chunkSizePtr);
         if (chunkSize < 16) {
             // The smallest valid chunk is 16 bytes long in this case.
             return false;
         }
         offset += 8;
     } else if (chunkSize < 8) {
         // The smallest valid chunk is 8 bytes long.
         return false;
     }

     if (chunkSize > bytesRead) {
         chunkSize = bytesRead;
     }
     int64_t chunkDataSize = chunkSize - offset;
     // It should at least have major brand (4-byte) and minor version (4-bytes).
     // The rest of the chunk (if any) is a list of (4-byte) compatible brands.
     if (chunkDataSize < 8) {
         return false;
     }

     uint32_t numCompatibleBrands = (chunkDataSize - 8) / 4;
     bool isHeif = false;
     for (size_t i = 0; i < numCompatibleBrands + 2; ++i) {
         if (i == 1) {
             // Skip this index, it refers to the minorVersion,
             // not a brand.
             continue;
         }
         auto* brandPtr = SkTAddOffset<const uint32_t>(buffer, offset + 4 * i);
         uint32_t brand = SkEndian_SwapBE32(*brandPtr);
         if (brand == FOURCC('m', 'i', 'f', '1') || brand == FOURCC('h', 'e', 'i', 'c')
          || brand == FOURCC('m', 's', 'f', '1') || brand == FOURCC('h', 'e', 'v', 'c')
          || brand == FOURCC('a', 'v', 'i', 'f') || brand == FOURCC('a', 'v', 'i', 's')) {
             // AVIF files could have "mif1" as the major brand. So we cannot
             // distinguish whether the image is AVIF or HEIC just based on the
             // "mif1" brand. So wait until we see a specific avif brand to
             // determine whether it is AVIF or HEIC.
             isHeif = true;
             if (brand == FOURCC('a', 'v', 'i', 'f')
               || brand == FOURCC('a', 'v', 'i', 's')) {
                 if (format != nullptr) {
                     *format = SkEncodedImageFormat::kAVIF;
                 }
                 return true;
             }
         }
     }
     if (isHeif) {
         if (format != nullptr) {
             *format = SkEncodedImageFormat::kHEIF;
         }
         return true;
     }
     return false;
 }

 static SkEncodedOrigin get_orientation(const HeifFrameInfo& frameInfo) {
     switch (frameInfo.mRotationAngle) {
         case 0:   return kTopLeft_SkEncodedOrigin;
         case 90:  return kRightTop_SkEncodedOrigin;
         case 180: return kBottomRight_SkEncodedOrigin;
         case 270: return kLeftBottom_SkEncodedOrigin;
     }
     return kDefault_SkEncodedOrigin;
 }

 struct SkHeifStreamWrapper : public HeifStream {
     SkHeifStreamWrapper(SkStream* stream) : fStream(stream) {}

     ~SkHeifStreamWrapper() override {}

     size_t read(void* buffer, size_t size) override {
         return fStream->read(buffer, size);
     }

     bool rewind() override {
         return fStream->rewind();
     }

     bool seek(size_t position) override {
         return fStream->seek(position);
     }

     bool hasLength() const override {
         return fStream->hasLength();
     }

     size_t getLength() const override {
         return fStream->getLength();
     }

 private:
     std::unique_ptr<SkStream> fStream;
 };

 static void releaseProc(const void* ptr, void* context) {
     delete reinterpret_cast<std::vector<uint8_t>*>(context);
 }

 std::unique_ptr<SkCodec> SkHeifCodec::MakeFromStream(std::unique_ptr<SkStream> stream,
         SkCodec::SelectionPolicy selectionPolicy, SkEncodedImageFormat format, Result* result) {
     std::unique_ptr<HeifDecoder> heifDecoder(createHeifDecoder());
     if (heifDecoder == nullptr) {
         *result = kInternalError;
         return nullptr;
     }

     HeifFrameInfo heifInfo;
     if (!heifDecoder->init(new SkHeifStreamWrapper(stream.release()), &heifInfo)) {
         *result = kInvalidInput;
         return nullptr;
     }

     size_t frameCount = 1;
     if (selectionPolicy == SkCodec::SelectionPolicy::kPreferAnimation) {
         HeifFrameInfo sequenceInfo;
         if (heifDecoder->getSequenceInfo(&sequenceInfo, &frameCount) &&
                 frameCount > 1) {
             heifInfo = std::move(sequenceInfo);
         }
     }

     std::unique_ptr<SkEncodedInfo::ICCProfile> profile = nullptr;
     if (heifInfo.mIccData.size() > 0) {
         auto iccData = new std::vector<uint8_t>(std::move(heifInfo.mIccData));
         auto icc = SkData::MakeWithProc(iccData->data(), iccData->size(), releaseProc, iccData);
         profile = SkEncodedInfo::ICCProfile::Make(std::move(icc));
     }
     if (profile && profile->profile()->data_color_space != skcms_Signature_RGB) {
         // This will result in sRGB.
         profile = nullptr;
     }

     SkEncodedInfo info = SkEncodedInfo::Make(heifInfo.mWidth, heifInfo.mHeight,
             SkEncodedInfo::kYUV_Color, SkEncodedInfo::kOpaque_Alpha, 8, std::move(profile));
     SkEncodedOrigin orientation = get_orientation(heifInfo);

     *result = kSuccess;
     return std::unique_ptr<SkCodec>(new SkHeifCodec(
             std::move(info), heifDecoder.release(), orientation, frameCount > 1, format));
 }

 SkHeifCodec::SkHeifCodec(
         SkEncodedInfo&& info,
         HeifDecoder* heifDecoder,
         SkEncodedOrigin origin,
         bool useAnimation,
         SkEncodedImageFormat format)
     : INHERITED(std::move(info), skcms_PixelFormat_RGBA_8888, nullptr, origin)
     , fHeifDecoder(heifDecoder)
     , fSwizzleSrcRow(nullptr)
     , fColorXformSrcRow(nullptr)
     , fUseAnimation(useAnimation)
     , fFormat(format)
 {}

 bool SkHeifCodec::conversionSupported(const SkImageInfo& dstInfo, bool srcIsOpaque,
                                       bool needsColorXform) {
     SkASSERT(srcIsOpaque);

     if (kUnknown_SkAlphaType == dstInfo.alphaType()) {
         return false;
     }

     if (kOpaque_SkAlphaType != dstInfo.alphaType()) {
         SkCodecPrintf("Warning: an opaque image should be decoded as opaque "
                 "- it is being decoded as non-opaque, which will draw slower\n");
     }

     switch (dstInfo.colorType()) {
         case kRGBA_8888_SkColorType:
             return fHeifDecoder->setOutputColor(kHeifColorFormat_RGBA_8888);

         case kBGRA_8888_SkColorType:
             return fHeifDecoder->setOutputColor(kHeifColorFormat_BGRA_8888);

         case kRGB_565_SkColorType:
             if (needsColorXform) {
                 return fHeifDecoder->setOutputColor(kHeifColorFormat_RGBA_8888);
             } else {
                 return fHeifDecoder->setOutputColor(kHeifColorFormat_RGB565);
             }

         case kRGBA_F16_SkColorType:
             SkASSERT(needsColorXform);
             return fHeifDecoder->setOutputColor(kHeifColorFormat_RGBA_8888);

         default:
             return false;
     }
 }

 int SkHeifCodec::readRows(const SkImageInfo& dstInfo, void* dst, size_t rowBytes, int count,
                           const Options& opts) {
     // When fSwizzleSrcRow is non-null, it means that we need to swizzle.  In this case,
     // we will always decode into fSwizzlerSrcRow before swizzling into the next buffer.
     // We can never swizzle "in place" because the swizzler may perform sampling and/or
     // subsetting.
     // When fColorXformSrcRow is non-null, it means that we need to color xform and that
     // we cannot color xform "in place" (many times we can, but not when the dst is F16).
     // In this case, we will color xform from fColorXformSrcRow into the dst.
     uint8_t* decodeDst = (uint8_t*) dst;
     uint32_t* swizzleDst = (uint32_t*) dst;
     size_t decodeDstRowBytes = rowBytes;
     size_t swizzleDstRowBytes = rowBytes;
     int dstWidth = opts.fSubset ? opts.fSubset->width() : dstInfo.width();
     if (fSwizzleSrcRow && fColorXformSrcRow) {
         decodeDst = fSwizzleSrcRow;
         swizzleDst = fColorXformSrcRow;
         decodeDstRowBytes = 0;
         swizzleDstRowBytes = 0;
         dstWidth = fSwizzler->swizzleWidth();
     } else if (fColorXformSrcRow) {
         decodeDst = (uint8_t*) fColorXformSrcRow;
         swizzleDst = fColorXformSrcRow;
         decodeDstRowBytes = 0;
         swizzleDstRowBytes = 0;
     } else if (fSwizzleSrcRow) {
         decodeDst = fSwizzleSrcRow;
         decodeDstRowBytes = 0;
         dstWidth = fSwizzler->swizzleWidth();
     }

     for (int y = 0; y < count; y++) {
         if (!fHeifDecoder->getScanline(decodeDst)) {
             return y;
         }

         if (fSwizzler) {
             fSwizzler->swizzle(swizzleDst, decodeDst);
         }

         if (this->colorXform()) {
             this->applyColorXform(dst, swizzleDst, dstWidth);
             dst = SkTAddOffset<void>(dst, rowBytes);
         }

         decodeDst = SkTAddOffset<uint8_t>(decodeDst, decodeDstRowBytes);
         swizzleDst = SkTAddOffset<uint32_t>(swizzleDst, swizzleDstRowBytes);
     }

     return count;
 }

 int SkHeifCodec::onGetFrameCount() {
     if (!fUseAnimation) {
         return 1;
     }

     if (fFrameHolder.size() == 0) {
         size_t frameCount;
         HeifFrameInfo frameInfo;
         if (!fHeifDecoder->getSequenceInfo(&frameInfo, &frameCount)
                 || frameCount <= 1) {
             fUseAnimation = false;
             return 1;
         }
         fFrameHolder.reserve(frameCount);
         for (size_t i = 0; i < frameCount; i++) {
             Frame* frame = fFrameHolder.appendNewFrame();
             frame->setXYWH(0, 0, frameInfo.mWidth, frameInfo.mHeight);
             frame->setDisposalMethod(SkCodecAnimation::DisposalMethod::kKeep);
             // Currently we don't know the duration until the frame is actually
             // decoded (onGetFrameInfo is also called before frame is decoded).
             // For now, fill it base on the value reported for the sequence.
             frame->setDuration(frameInfo.mDurationUs / 1000);
             frame->setRequiredFrame(SkCodec::kNoFrame);
             frame->setHasAlpha(false);
         }
     }

     return fFrameHolder.size();
 }

 const SkFrame* SkHeifCodec::FrameHolder::onGetFrame(int i) const {
     return static_cast<const SkFrame*>(this->frame(i));
 }

 SkHeifCodec::Frame* SkHeifCodec::FrameHolder::appendNewFrame() {
     const int i = this->size();
     fFrames.emplace_back(i); // TODO: need to handle frame duration here
     return &fFrames[i];
 }

 const SkHeifCodec::Frame* SkHeifCodec::FrameHolder::frame(int i) const {
     SkASSERT(i >= 0 && i < this->size());
     return &fFrames[i];
 }

 SkHeifCodec::Frame* SkHeifCodec::FrameHolder::editFrameAt(int i) {
     SkASSERT(i >= 0 && i < this->size());
     return &fFrames[i];
 }

 bool SkHeifCodec::onGetFrameInfo(int i, FrameInfo* frameInfo) const {
     if (i >= fFrameHolder.size()) {
         return false;
     }

     const Frame* frame = fFrameHolder.frame(i);
     if (!frame) {
         return false;
     }

     if (frameInfo) {
         frame->fillIn(frameInfo, true);
     }

     return true;
 }

 int SkHeifCodec::onGetRepetitionCount() {
     return kRepetitionCountInfinite;
 }

 /*
  * Performs the heif decode
  */
 SkCodec::Result SkHeifCodec::onGetPixels(const SkImageInfo& dstInfo,
                                          void* dst, size_t dstRowBytes,
                                          const Options& options,
                                          int* rowsDecoded) {
     if (options.fSubset) {
         // Not supporting subsets on this path for now.
         // TODO: if the heif has tiles, we can support subset here, but
         // need to retrieve tile config from metadata retriever first.
         return kUnimplemented;
     }

     bool success;
     if (fUseAnimation) {
         success = fHeifDecoder->decodeSequence(options.fFrameIndex, &fFrameInfo);
         fFrameHolder.editFrameAt(options.fFrameIndex)->setDuration(
                 fFrameInfo.mDurationUs / 1000);
     } else {
         success = fHeifDecoder->decode(&fFrameInfo);
     }

     if (!success) {
         return kInvalidInput;
     }

     fSwizzler.reset(nullptr);
     this->allocateStorage(dstInfo);

     int rows = this->readRows(dstInfo, dst, dstRowBytes, dstInfo.height(), options);
     if (rows < dstInfo.height()) {
         *rowsDecoded = rows;
         return kIncompleteInput;
     }

     return kSuccess;
 }

 void SkHeifCodec::allocateStorage(const SkImageInfo& dstInfo) {
     int dstWidth = dstInfo.width();

     size_t swizzleBytes = 0;
     if (fSwizzler) {
         swizzleBytes = fFrameInfo.mBytesPerPixel * fFrameInfo.mWidth;
         dstWidth = fSwizzler->swizzleWidth();
         SkASSERT(!this->colorXform() || SkIsAlign4(swizzleBytes));
     }

     size_t xformBytes = 0;
     if (this->colorXform() && (kRGBA_F16_SkColorType == dstInfo.colorType() ||
                                kRGB_565_SkColorType == dstInfo.colorType())) {
         xformBytes = dstWidth * sizeof(uint32_t);
     }

     size_t totalBytes = swizzleBytes + xformBytes;
     fStorage.reset(totalBytes);
     if (totalBytes > 0) {
         fSwizzleSrcRow = (swizzleBytes > 0) ? fStorage.get() : nullptr;
         fColorXformSrcRow = (xformBytes > 0) ?
                 SkTAddOffset<uint32_t>(fStorage.get(), swizzleBytes) : nullptr;
     }
 }

 void SkHeifCodec::initializeSwizzler(
         const SkImageInfo& dstInfo, const Options& options) {
     SkImageInfo swizzlerDstInfo = dstInfo;
     if (this->colorXform()) {
         // The color xform will be expecting RGBA 8888 input.
         swizzlerDstInfo = swizzlerDstInfo.makeColorType(kRGBA_8888_SkColorType);
     }

     int srcBPP = 4;
     if (dstInfo.colorType() == kRGB_565_SkColorType && !this->colorXform()) {
         srcBPP = 2;
     }

     fSwizzler = SkSwizzler::MakeSimple(srcBPP, swizzlerDstInfo, options);
     SkASSERT(fSwizzler);
 }

 SkSampler* SkHeifCodec::getSampler(bool createIfNecessary) {
     if (!createIfNecessary || fSwizzler) {
         SkASSERT(!fSwizzler || (fSwizzleSrcRow && fStorage.get() == fSwizzleSrcRow));
         return fSwizzler.get();
     }

     this->initializeSwizzler(this->dstInfo(), this->options());
     this->allocateStorage(this->dstInfo());
     return fSwizzler.get();
 }

 bool SkHeifCodec::onRewind() {
     fSwizzler.reset(nullptr);
     fSwizzleSrcRow = nullptr;
     fColorXformSrcRow = nullptr;
     fStorage.reset();

     return true;
 }

 SkCodec::Result SkHeifCodec::onStartScanlineDecode(
         const SkImageInfo& dstInfo, const Options& options) {
     // TODO: For now, just decode the whole thing even when there is a subset.
     // If the heif image has tiles, we could potentially do this much faster,
     // but the tile configuration needs to be retrieved from the metadata.
     if (!fHeifDecoder->decode(&fFrameInfo)) {
         return kInvalidInput;
     }

     if (options.fSubset) {
         this->initializeSwizzler(dstInfo, options);
     } else {
         fSwizzler.reset(nullptr);
     }

     this->allocateStorage(dstInfo);

     return kSuccess;
 }

 int SkHeifCodec::onGetScanlines(void* dst, int count, size_t dstRowBytes) {
     return this->readRows(this->dstInfo(), dst, dstRowBytes, count, this->options());
 }

 bool SkHeifCodec::onSkipScanlines(int count) {
     return count == (int) fHeifDecoder->skipScanlines(count);
 }

 #endif // SK_HAS_HEIF_LIBRARY
	/*
	* Copyright 2017 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "include/core/SkTypes.h"

	#ifdef SK_HAS_HEIF_LIBRARY
	#include "include/codec/SkCodec.h"
	#include "include/core/SkStream.h"
	#include "include/private/SkColorData.h"
	#include "src/codec/SkCodecPriv.h"
	#include "src/codec/SkHeifCodec.h"
	#include "src/core/SkEndian.h"

	#define FOURCC(c1, c2, c3, c4) \
	((c1) << 24 \| (c2) << 16 \| (c3) << 8 \| (c4))

	bool SkHeifCodec::IsSupported(const void* buffer, size_t bytesRead,
	SkEncodedImageFormat* format) {
	// Parse the ftyp box up to bytesRead to determine if this is HEIF or AVIF.
	// Any valid ftyp box should have at least 8 bytes.
	if (bytesRead < 8) {
	return false;
	}

	uint32_t* ptr = (uint32_t*)buffer;
	uint64_t chunkSize = SkEndian_SwapBE32(ptr[0]);
	uint32_t chunkType = SkEndian_SwapBE32(ptr[1]);

	if (chunkType != FOURCC('f', 't', 'y', 'p')) {
	return false;
	}

	int64_t offset = 8;
	if (chunkSize == 1) {
	// This indicates that the next 8 bytes represent the chunk size,
	// and chunk data comes after that.
	if (bytesRead < 16) {
	return false;
	}
	auto* chunkSizePtr = SkTAddOffset<const uint64_t>(buffer, offset);
	chunkSize = SkEndian_SwapBE64(*chunkSizePtr);
	if (chunkSize < 16) {
	// The smallest valid chunk is 16 bytes long in this case.
	return false;
	}
	offset += 8;
	} else if (chunkSize < 8) {
	// The smallest valid chunk is 8 bytes long.
	return false;
	}

	if (chunkSize > bytesRead) {
	chunkSize = bytesRead;
	}
	int64_t chunkDataSize = chunkSize - offset;
	// It should at least have major brand (4-byte) and minor version (4-bytes).
	// The rest of the chunk (if any) is a list of (4-byte) compatible brands.
	if (chunkDataSize < 8) {
	return false;
	}

	uint32_t numCompatibleBrands = (chunkDataSize - 8) / 4;
	bool isHeif = false;
	for (size_t i = 0; i < numCompatibleBrands + 2; ++i) {
	if (i == 1) {
	// Skip this index, it refers to the minorVersion,
	// not a brand.
	continue;
	}
	auto* brandPtr = SkTAddOffset<const uint32_t>(buffer, offset + 4 * i);
	uint32_t brand = SkEndian_SwapBE32(*brandPtr);
	if (brand == FOURCC('m', 'i', 'f', '1') \|\| brand == FOURCC('h', 'e', 'i', 'c')
	\|\| brand == FOURCC('m', 's', 'f', '1') \|\| brand == FOURCC('h', 'e', 'v', 'c')
	\|\| brand == FOURCC('a', 'v', 'i', 'f') \|\| brand == FOURCC('a', 'v', 'i', 's')) {
	// AVIF files could have "mif1" as the major brand. So we cannot
	// distinguish whether the image is AVIF or HEIC just based on the
	// "mif1" brand. So wait until we see a specific avif brand to
	// determine whether it is AVIF or HEIC.
	isHeif = true;
	if (brand == FOURCC('a', 'v', 'i', 'f')
	\|\| brand == FOURCC('a', 'v', 'i', 's')) {
	if (format != nullptr) {
	*format = SkEncodedImageFormat::kAVIF;
	}
	return true;
	}
	}
	}
	if (isHeif) {
	if (format != nullptr) {
	*format = SkEncodedImageFormat::kHEIF;
	}
	return true;
	}
	return false;
	}

	static SkEncodedOrigin get_orientation(const HeifFrameInfo& frameInfo) {
	switch (frameInfo.mRotationAngle) {
	case 0: return kTopLeft_SkEncodedOrigin;
	case 90: return kRightTop_SkEncodedOrigin;
	case 180: return kBottomRight_SkEncodedOrigin;
	case 270: return kLeftBottom_SkEncodedOrigin;
	}
	return kDefault_SkEncodedOrigin;
	}

	struct SkHeifStreamWrapper : public HeifStream {
	SkHeifStreamWrapper(SkStream* stream) : fStream(stream) {}

	~SkHeifStreamWrapper() override {}

	size_t read(void* buffer, size_t size) override {
	return fStream->read(buffer, size);
	}

	bool rewind() override {
	return fStream->rewind();
	}

	bool seek(size_t position) override {
	return fStream->seek(position);
	}

	bool hasLength() const override {
	return fStream->hasLength();
	}

	size_t getLength() const override {
	return fStream->getLength();
	}

	private:
	std::unique_ptr<SkStream> fStream;
	};

	static void releaseProc(const void* ptr, void* context) {
	delete reinterpret_cast<std::vector<uint8_t>*>(context);
	}

	std::unique_ptr<SkCodec> SkHeifCodec::MakeFromStream(std::unique_ptr<SkStream> stream,
	SkCodec::SelectionPolicy selectionPolicy, SkEncodedImageFormat format, Result* result) {
	std::unique_ptr<HeifDecoder> heifDecoder(createHeifDecoder());
	if (heifDecoder == nullptr) {
	*result = kInternalError;
	return nullptr;
	}

	HeifFrameInfo heifInfo;
	if (!heifDecoder->init(new SkHeifStreamWrapper(stream.release()), &heifInfo)) {
	*result = kInvalidInput;
	return nullptr;
	}

	size_t frameCount = 1;
	if (selectionPolicy == SkCodec::SelectionPolicy::kPreferAnimation) {
	HeifFrameInfo sequenceInfo;
	if (heifDecoder->getSequenceInfo(&sequenceInfo, &frameCount) &&
	frameCount > 1) {
	heifInfo = std::move(sequenceInfo);
	}
	}

	std::unique_ptr<SkEncodedInfo::ICCProfile> profile = nullptr;
	if (heifInfo.mIccData.size() > 0) {
	auto iccData = new std::vector<uint8_t>(std::move(heifInfo.mIccData));
	auto icc = SkData::MakeWithProc(iccData->data(), iccData->size(), releaseProc, iccData);
	profile = SkEncodedInfo::ICCProfile::Make(std::move(icc));
	}
	if (profile && profile->profile()->data_color_space != skcms_Signature_RGB) {
	// This will result in sRGB.
	profile = nullptr;
	}

	SkEncodedInfo info = SkEncodedInfo::Make(heifInfo.mWidth, heifInfo.mHeight,
	SkEncodedInfo::kYUV_Color, SkEncodedInfo::kOpaque_Alpha, 8, std::move(profile));
	SkEncodedOrigin orientation = get_orientation(heifInfo);

	*result = kSuccess;
	return std::unique_ptr<SkCodec>(new SkHeifCodec(
	std::move(info), heifDecoder.release(), orientation, frameCount > 1, format));
	}

	SkHeifCodec::SkHeifCodec(
	SkEncodedInfo&& info,
	HeifDecoder* heifDecoder,
	SkEncodedOrigin origin,
	bool useAnimation,
	SkEncodedImageFormat format)
	: INHERITED(std::move(info), skcms_PixelFormat_RGBA_8888, nullptr, origin)
	, fHeifDecoder(heifDecoder)
	, fSwizzleSrcRow(nullptr)
	, fColorXformSrcRow(nullptr)
	, fUseAnimation(useAnimation)
	, fFormat(format)
	{}

	bool SkHeifCodec::conversionSupported(const SkImageInfo& dstInfo, bool srcIsOpaque,
	bool needsColorXform) {
	SkASSERT(srcIsOpaque);

	if (kUnknown_SkAlphaType == dstInfo.alphaType()) {
	return false;
	}

	if (kOpaque_SkAlphaType != dstInfo.alphaType()) {
	SkCodecPrintf("Warning: an opaque image should be decoded as opaque "
	"- it is being decoded as non-opaque, which will draw slower\n");
	}

	switch (dstInfo.colorType()) {
	case kRGBA_8888_SkColorType:
	return fHeifDecoder->setOutputColor(kHeifColorFormat_RGBA_8888);

	case kBGRA_8888_SkColorType:
	return fHeifDecoder->setOutputColor(kHeifColorFormat_BGRA_8888);

	case kRGB_565_SkColorType:
	if (needsColorXform) {
	return fHeifDecoder->setOutputColor(kHeifColorFormat_RGBA_8888);
	} else {
	return fHeifDecoder->setOutputColor(kHeifColorFormat_RGB565);
	}

	case kRGBA_F16_SkColorType:
	SkASSERT(needsColorXform);
	return fHeifDecoder->setOutputColor(kHeifColorFormat_RGBA_8888);

	default:
	return false;
	}
	}

	int SkHeifCodec::readRows(const SkImageInfo& dstInfo, void* dst, size_t rowBytes, int count,
	const Options& opts) {
	// When fSwizzleSrcRow is non-null, it means that we need to swizzle. In this case,
	// we will always decode into fSwizzlerSrcRow before swizzling into the next buffer.
	// We can never swizzle "in place" because the swizzler may perform sampling and/or
	// subsetting.
	// When fColorXformSrcRow is non-null, it means that we need to color xform and that
	// we cannot color xform "in place" (many times we can, but not when the dst is F16).
	// In this case, we will color xform from fColorXformSrcRow into the dst.
	uint8_t* decodeDst = (uint8_t*) dst;
	uint32_t* swizzleDst = (uint32_t*) dst;
	size_t decodeDstRowBytes = rowBytes;
	size_t swizzleDstRowBytes = rowBytes;
	int dstWidth = opts.fSubset ? opts.fSubset->width() : dstInfo.width();
	if (fSwizzleSrcRow && fColorXformSrcRow) {
	decodeDst = fSwizzleSrcRow;
	swizzleDst = fColorXformSrcRow;
	decodeDstRowBytes = 0;
	swizzleDstRowBytes = 0;
	dstWidth = fSwizzler->swizzleWidth();
	} else if (fColorXformSrcRow) {
	decodeDst = (uint8_t*) fColorXformSrcRow;
	swizzleDst = fColorXformSrcRow;
	decodeDstRowBytes = 0;
	swizzleDstRowBytes = 0;
	} else if (fSwizzleSrcRow) {
	decodeDst = fSwizzleSrcRow;
	decodeDstRowBytes = 0;
	dstWidth = fSwizzler->swizzleWidth();
	}

	for (int y = 0; y < count; y++) {
	if (!fHeifDecoder->getScanline(decodeDst)) {
	return y;
	}

	if (fSwizzler) {
	fSwizzler->swizzle(swizzleDst, decodeDst);
	}

	if (this->colorXform()) {
	this->applyColorXform(dst, swizzleDst, dstWidth);
	dst = SkTAddOffset<void>(dst, rowBytes);
	}

	decodeDst = SkTAddOffset<uint8_t>(decodeDst, decodeDstRowBytes);
	swizzleDst = SkTAddOffset<uint32_t>(swizzleDst, swizzleDstRowBytes);
	}

	return count;
	}

	int SkHeifCodec::onGetFrameCount() {
	if (!fUseAnimation) {
	return 1;
	}

	if (fFrameHolder.size() == 0) {
	size_t frameCount;
	HeifFrameInfo frameInfo;
	if (!fHeifDecoder->getSequenceInfo(&frameInfo, &frameCount)
	\|\| frameCount <= 1) {
	fUseAnimation = false;
	return 1;
	}
	fFrameHolder.reserve(frameCount);
	for (size_t i = 0; i < frameCount; i++) {
	Frame* frame = fFrameHolder.appendNewFrame();
	frame->setXYWH(0, 0, frameInfo.mWidth, frameInfo.mHeight);
	frame->setDisposalMethod(SkCodecAnimation::DisposalMethod::kKeep);
	// Currently we don't know the duration until the frame is actually
	// decoded (onGetFrameInfo is also called before frame is decoded).
	// For now, fill it base on the value reported for the sequence.
	frame->setDuration(frameInfo.mDurationUs / 1000);
	frame->setRequiredFrame(SkCodec::kNoFrame);
	frame->setHasAlpha(false);
	}
	}

	return fFrameHolder.size();
	}

	const SkFrame* SkHeifCodec::FrameHolder::onGetFrame(int i) const {
	return static_cast<const SkFrame*>(this->frame(i));
	}

	SkHeifCodec::Frame* SkHeifCodec::FrameHolder::appendNewFrame() {
	const int i = this->size();
	fFrames.emplace_back(i); // TODO: need to handle frame duration here
	return &fFrames[i];
	}

	const SkHeifCodec::Frame* SkHeifCodec::FrameHolder::frame(int i) const {
	SkASSERT(i >= 0 && i < this->size());
	return &fFrames[i];
	}

	SkHeifCodec::Frame* SkHeifCodec::FrameHolder::editFrameAt(int i) {
	SkASSERT(i >= 0 && i < this->size());
	return &fFrames[i];
	}

	bool SkHeifCodec::onGetFrameInfo(int i, FrameInfo* frameInfo) const {
	if (i >= fFrameHolder.size()) {
	return false;
	}

	const Frame* frame = fFrameHolder.frame(i);
	if (!frame) {
	return false;
	}

	if (frameInfo) {
	frame->fillIn(frameInfo, true);
	}

	return true;
	}

	int SkHeifCodec::onGetRepetitionCount() {
	return kRepetitionCountInfinite;
	}

	/*
	* Performs the heif decode
	*/
	SkCodec::Result SkHeifCodec::onGetPixels(const SkImageInfo& dstInfo,
	void* dst, size_t dstRowBytes,
	const Options& options,
	int* rowsDecoded) {
	if (options.fSubset) {
	// Not supporting subsets on this path for now.
	// TODO: if the heif has tiles, we can support subset here, but
	// need to retrieve tile config from metadata retriever first.
	return kUnimplemented;
	}

	bool success;
	if (fUseAnimation) {
	success = fHeifDecoder->decodeSequence(options.fFrameIndex, &fFrameInfo);
	fFrameHolder.editFrameAt(options.fFrameIndex)->setDuration(
	fFrameInfo.mDurationUs / 1000);
	} else {
	success = fHeifDecoder->decode(&fFrameInfo);
	}

	if (!success) {
	return kInvalidInput;
	}

	fSwizzler.reset(nullptr);
	this->allocateStorage(dstInfo);

	int rows = this->readRows(dstInfo, dst, dstRowBytes, dstInfo.height(), options);
	if (rows < dstInfo.height()) {
	*rowsDecoded = rows;
	return kIncompleteInput;
	}

	return kSuccess;
	}

	void SkHeifCodec::allocateStorage(const SkImageInfo& dstInfo) {
	int dstWidth = dstInfo.width();

	size_t swizzleBytes = 0;
	if (fSwizzler) {
	swizzleBytes = fFrameInfo.mBytesPerPixel * fFrameInfo.mWidth;
	dstWidth = fSwizzler->swizzleWidth();
	SkASSERT(!this->colorXform() \|\| SkIsAlign4(swizzleBytes));
	}

	size_t xformBytes = 0;
	if (this->colorXform() && (kRGBA_F16_SkColorType == dstInfo.colorType() \|\|
	kRGB_565_SkColorType == dstInfo.colorType())) {
	xformBytes = dstWidth * sizeof(uint32_t);
	}

	size_t totalBytes = swizzleBytes + xformBytes;
	fStorage.reset(totalBytes);
	if (totalBytes > 0) {
	fSwizzleSrcRow = (swizzleBytes > 0) ? fStorage.get() : nullptr;
	fColorXformSrcRow = (xformBytes > 0) ?
	SkTAddOffset<uint32_t>(fStorage.get(), swizzleBytes) : nullptr;
	}
	}

	void SkHeifCodec::initializeSwizzler(
	const SkImageInfo& dstInfo, const Options& options) {
	SkImageInfo swizzlerDstInfo = dstInfo;
	if (this->colorXform()) {
	// The color xform will be expecting RGBA 8888 input.
	swizzlerDstInfo = swizzlerDstInfo.makeColorType(kRGBA_8888_SkColorType);
	}

	int srcBPP = 4;
	if (dstInfo.colorType() == kRGB_565_SkColorType && !this->colorXform()) {
	srcBPP = 2;
	}

	fSwizzler = SkSwizzler::MakeSimple(srcBPP, swizzlerDstInfo, options);
	SkASSERT(fSwizzler);
	}

	SkSampler* SkHeifCodec::getSampler(bool createIfNecessary) {
	if (!createIfNecessary \|\| fSwizzler) {
	SkASSERT(!fSwizzler \|\| (fSwizzleSrcRow && fStorage.get() == fSwizzleSrcRow));
	return fSwizzler.get();
	}

	this->initializeSwizzler(this->dstInfo(), this->options());
	this->allocateStorage(this->dstInfo());
	return fSwizzler.get();
	}

	bool SkHeifCodec::onRewind() {
	fSwizzler.reset(nullptr);
	fSwizzleSrcRow = nullptr;
	fColorXformSrcRow = nullptr;
	fStorage.reset();

	return true;
	}

	SkCodec::Result SkHeifCodec::onStartScanlineDecode(
	const SkImageInfo& dstInfo, const Options& options) {
	// TODO: For now, just decode the whole thing even when there is a subset.
	// If the heif image has tiles, we could potentially do this much faster,
	// but the tile configuration needs to be retrieved from the metadata.
	if (!fHeifDecoder->decode(&fFrameInfo)) {
	return kInvalidInput;
	}

	if (options.fSubset) {
	this->initializeSwizzler(dstInfo, options);
	} else {
	fSwizzler.reset(nullptr);
	}

	this->allocateStorage(dstInfo);

	return kSuccess;
	}

	int SkHeifCodec::onGetScanlines(void* dst, int count, size_t dstRowBytes) {
	return this->readRows(this->dstInfo(), dst, dstRowBytes, count, this->options());
	}

	bool SkHeifCodec::onSkipScanlines(int count) {
	return count == (int) fHeifDecoder->skipScanlines(count);
	}

	#endif // SK_HAS_HEIF_LIBRARY