media/libheif/HeifDecoderImpl.cpp - third_party/android/platform/frameworks/av - Git at Google

 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 //#define LOG_NDEBUG 0
 #define LOG_TAG "HeifDecoderImpl"

 #include "HeifDecoderImpl.h"

 #include <stdio.h>

 #include <binder/IMemory.h>
 #include <binder/MemoryDealer.h>
 #include <drm/drm_framework_common.h>
 #include <media/IDataSource.h>
 #include <media/mediametadataretriever.h>
 #include <media/MediaSource.h>
 #include <media/stagefright/foundation/ADebug.h>
 #include <private/media/VideoFrame.h>
 #include <utils/Log.h>
 #include <utils/RefBase.h>

 HeifDecoder* createHeifDecoder() {
     return new android::HeifDecoderImpl();
 }

 namespace android {

 /*
  * HeifDataSource
  *
  * Proxies data requests over IDataSource interface from MediaMetadataRetriever
  * to the HeifStream interface we received from the heif decoder client.
  */
 class HeifDataSource : public BnDataSource {
 public:
     /*
      * Constructs HeifDataSource; will take ownership of |stream|.
      */
     HeifDataSource(HeifStream* stream)
         : mStream(stream), mEOS(false),
           mCachedOffset(0), mCachedSize(0), mCacheBufferSize(0) {}

     ~HeifDataSource() override {}

     /*
      * Initializes internal resources.
      */
     bool init();

     sp<IMemory> getIMemory() override { return mMemory; }
     ssize_t readAt(off64_t offset, size_t size) override;
     status_t getSize(off64_t* size) override ;
     void close() {}
     uint32_t getFlags() override { return 0; }
     String8 toString() override { return String8("HeifDataSource"); }
     sp<DecryptHandle> DrmInitialization(const char*) override {
         return nullptr;
     }

 private:
     enum {
         /*
          * Buffer size for passing the read data to mediaserver. Set to 64K
          * (which is what MediaDataSource Java API's jni implementation uses).
          */
         kBufferSize = 64 * 1024,
         /*
          * Initial and max cache buffer size.
          */
         kInitialCacheBufferSize = 4 * 1024 * 1024,
         kMaxCacheBufferSize = 64 * 1024 * 1024,
     };
     sp<IMemory> mMemory;
     std::unique_ptr<HeifStream> mStream;
     bool mEOS;
     std::unique_ptr<uint8_t[]> mCache;
     off64_t mCachedOffset;
     size_t mCachedSize;
     size_t mCacheBufferSize;
 };

 bool HeifDataSource::init() {
     sp<MemoryDealer> memoryDealer =
             new MemoryDealer(kBufferSize, "HeifDataSource");
     mMemory = memoryDealer->allocate(kBufferSize);
     if (mMemory == nullptr) {
         ALOGE("Failed to allocate shared memory!");
         return false;
     }
     mCache.reset(new uint8_t[kInitialCacheBufferSize]);
     if (mCache.get() == nullptr) {
         ALOGE("mFailed to allocate cache!");
         return false;
     }
     mCacheBufferSize = kInitialCacheBufferSize;
     return true;
 }

 ssize_t HeifDataSource::readAt(off64_t offset, size_t size) {
     ALOGV("readAt: offset=%lld, size=%zu", (long long)offset, size);

     if (offset < mCachedOffset) {
         // try seek, then rewind/skip, fail if none worked
         if (mStream->seek(offset)) {
             ALOGV("readAt: seek to offset=%lld", (long long)offset);
             mCachedOffset = offset;
             mCachedSize = 0;
             mEOS = false;
         } else if (mStream->rewind()) {
             ALOGV("readAt: rewind to offset=0");
             mCachedOffset = 0;
             mCachedSize = 0;
             mEOS = false;
         } else {
             ALOGE("readAt: couldn't seek or rewind!");
             mEOS = true;
         }
     }

     if (mEOS && (offset < mCachedOffset ||
                  offset >= (off64_t)(mCachedOffset + mCachedSize))) {
         ALOGV("readAt: EOS");
         return ERROR_END_OF_STREAM;
     }

     // at this point, offset must be >= mCachedOffset, other cases should
     // have been caught above.
     CHECK(offset >= mCachedOffset);

     off64_t resultOffset;
     if (__builtin_add_overflow(offset, size, &resultOffset)) {
         return ERROR_IO;
     }

     if (size == 0) {
         return 0;
     }

     // Can only read max of kBufferSize
     if (size > kBufferSize) {
         size = kBufferSize;
     }

     // copy from cache if the request falls entirely in cache
     if (offset + size <= mCachedOffset + mCachedSize) {
         memcpy(mMemory->pointer(), mCache.get() + offset - mCachedOffset, size);
         return size;
     }

     // need to fetch more, check if we need to expand the cache buffer.
     if ((off64_t)(offset + size) > mCachedOffset + kMaxCacheBufferSize) {
         // it's reaching max cache buffer size, need to roll window, and possibly
         // expand the cache buffer.
         size_t newCacheBufferSize = mCacheBufferSize;
         std::unique_ptr<uint8_t[]> newCache;
         uint8_t* dst = mCache.get();
         if (newCacheBufferSize < kMaxCacheBufferSize) {
             newCacheBufferSize = kMaxCacheBufferSize;
             newCache.reset(new uint8_t[newCacheBufferSize]);
             dst = newCache.get();
         }

         // when rolling the cache window, try to keep about half the old bytes
         // in case that the client goes back.
         off64_t newCachedOffset = offset - (off64_t)(newCacheBufferSize / 2);
         if (newCachedOffset < mCachedOffset) {
             newCachedOffset = mCachedOffset;
         }

         int64_t newCachedSize = (int64_t)(mCachedOffset + mCachedSize) - newCachedOffset;
         if (newCachedSize > 0) {
             // in this case, the new cache region partially overlop the old cache,
             // move the portion of the cache we want to save to the beginning of
             // the cache buffer.
             memcpy(dst, mCache.get() + newCachedOffset - mCachedOffset, newCachedSize);
         } else if (newCachedSize < 0){
             // in this case, the new cache region is entirely out of the old cache,
             // in order to guarantee sequential read, we need to skip a number of
             // bytes before reading.
             size_t bytesToSkip = -newCachedSize;
             size_t bytesSkipped = mStream->read(nullptr, bytesToSkip);
             if (bytesSkipped != bytesToSkip) {
                 // bytesSkipped is invalid, there is not enough bytes to reach
                 // the requested offset.
                 ALOGE("readAt: skip failed, EOS");

                 mEOS = true;
                 mCachedOffset = newCachedOffset;
                 mCachedSize = 0;
                 return ERROR_END_OF_STREAM;
             }
             // set cache size to 0, since we're not keeping any old cache
             newCachedSize = 0;
         }

         if (newCache.get() != nullptr) {
             mCache.reset(newCache.release());
             mCacheBufferSize = newCacheBufferSize;
         }
         mCachedOffset = newCachedOffset;
         mCachedSize = newCachedSize;

         ALOGV("readAt: rolling cache window to (%lld, %zu), cache buffer size %zu",
                 (long long)mCachedOffset, mCachedSize, mCacheBufferSize);
     } else {
         // expand cache buffer, but no need to roll the window
         size_t newCacheBufferSize = mCacheBufferSize;
         while (offset + size > mCachedOffset + newCacheBufferSize) {
             newCacheBufferSize *= 2;
         }
         CHECK(newCacheBufferSize <= kMaxCacheBufferSize);
         if (mCacheBufferSize < newCacheBufferSize) {
             uint8_t* newCache = new uint8_t[newCacheBufferSize];
             memcpy(newCache, mCache.get(), mCachedSize);
             mCache.reset(newCache);
             mCacheBufferSize = newCacheBufferSize;

             ALOGV("readAt: current cache window (%lld, %zu), new cache buffer size %zu",
                     (long long) mCachedOffset, mCachedSize, mCacheBufferSize);
         }
     }
     size_t bytesToRead = offset + size - mCachedOffset - mCachedSize;
     size_t bytesRead = mStream->read(mCache.get() + mCachedSize, bytesToRead);
     if (bytesRead > bytesToRead || bytesRead == 0) {
         // bytesRead is invalid
         mEOS = true;
         bytesRead = 0;
     } else if (bytesRead < bytesToRead) {
         // read some bytes but not all, set EOS
         mEOS = true;
     }
     mCachedSize += bytesRead;
     ALOGV("readAt: current cache window (%lld, %zu)",
             (long long) mCachedOffset, mCachedSize);

     // here bytesAvailable could be negative if offset jumped past EOS.
     int64_t bytesAvailable = mCachedOffset + mCachedSize - offset;
     if (bytesAvailable <= 0) {
         return ERROR_END_OF_STREAM;
     }
     if (bytesAvailable < (int64_t)size) {
         size = bytesAvailable;
     }
     memcpy(mMemory->pointer(), mCache.get() + offset - mCachedOffset, size);
     return size;
 }

 status_t HeifDataSource::getSize(off64_t* size) {
     if (!mStream->hasLength()) {
         *size = -1;
         ALOGE("getSize: not supported!");
         return ERROR_UNSUPPORTED;
     }
     *size = mStream->getLength();
     ALOGV("getSize: size=%lld", (long long)*size);
     return OK;
 }

 /////////////////////////////////////////////////////////////////////////

 struct HeifDecoderImpl::DecodeThread : public Thread {
     explicit DecodeThread(HeifDecoderImpl *decoder) : mDecoder(decoder) {}

 private:
     HeifDecoderImpl* mDecoder;

     bool threadLoop();

     DISALLOW_EVIL_CONSTRUCTORS(DecodeThread);
 };

 bool HeifDecoderImpl::DecodeThread::threadLoop() {
     return mDecoder->decodeAsync();
 }

 /////////////////////////////////////////////////////////////////////////

 HeifDecoderImpl::HeifDecoderImpl() :
     // output color format should always be set via setOutputColor(), in case
     // it's not, default to HAL_PIXEL_FORMAT_RGB_565.
     mOutputColor(HAL_PIXEL_FORMAT_RGB_565),
     mCurScanline(0),
     mWidth(0),
     mHeight(0),
     mFrameDecoded(false),
     mHasImage(false),
     mHasVideo(false),
     mAvailableLines(0),
     mNumSlices(1),
     mSliceHeight(0),
     mAsyncDecodeDone(false) {
 }

 HeifDecoderImpl::~HeifDecoderImpl() {
     if (mThread != nullptr) {
         mThread->join();
     }
 }

 bool HeifDecoderImpl::init(HeifStream* stream, HeifFrameInfo* frameInfo) {
     mFrameDecoded = false;
     mFrameMemory.clear();

     sp<HeifDataSource> dataSource = new HeifDataSource(stream);
     if (!dataSource->init()) {
         return false;
     }
     mDataSource = dataSource;

     mRetriever = new MediaMetadataRetriever();
     status_t err = mRetriever->setDataSource(mDataSource, "image/heif");
     if (err != OK) {
         ALOGE("failed to set data source!");

         mRetriever.clear();
         mDataSource.clear();
         return false;
     }
     ALOGV("successfully set data source.");

     const char* hasImage = mRetriever->extractMetadata(METADATA_KEY_HAS_IMAGE);
     const char* hasVideo = mRetriever->extractMetadata(METADATA_KEY_HAS_VIDEO);

     mHasImage = hasImage && !strcasecmp(hasImage, "yes");
     mHasVideo = hasVideo && !strcasecmp(hasVideo, "yes");
     sp<IMemory> sharedMem;
     if (mHasImage) {
         // image index < 0 to retrieve primary image
         sharedMem = mRetriever->getImageAtIndex(
                 -1, mOutputColor, true /*metaOnly*/);
     } else if (mHasVideo) {
         sharedMem = mRetriever->getFrameAtTime(0,
                 MediaSource::ReadOptions::SEEK_PREVIOUS_SYNC,
                 mOutputColor, true /*metaOnly*/);
     }

     if (sharedMem == nullptr || sharedMem->pointer() == nullptr) {
         ALOGE("getFrameAtTime: videoFrame is a nullptr");
         return false;
     }

     VideoFrame* videoFrame = static_cast<VideoFrame*>(sharedMem->pointer());

     ALOGV("Meta dimension %dx%d, display %dx%d, angle %d, iccSize %d",
             videoFrame->mWidth,
             videoFrame->mHeight,
             videoFrame->mDisplayWidth,
             videoFrame->mDisplayHeight,
             videoFrame->mRotationAngle,
             videoFrame->mIccSize);

     if (frameInfo != nullptr) {
         frameInfo->set(
                 videoFrame->mWidth,
                 videoFrame->mHeight,
                 videoFrame->mRotationAngle,
                 videoFrame->mBytesPerPixel,
                 videoFrame->mIccSize,
                 videoFrame->getFlattenedIccData());
     }
     mWidth = videoFrame->mWidth;
     mHeight = videoFrame->mHeight;
     if (mHasImage && videoFrame->mTileHeight >= 512 && mWidth >= 3000 && mHeight >= 2000 ) {
         // Try decoding in slices only if the image has tiles and is big enough.
         mSliceHeight = videoFrame->mTileHeight;
         mNumSlices = (videoFrame->mHeight + mSliceHeight - 1) / mSliceHeight;
         ALOGV("mSliceHeight %u, mNumSlices %zu", mSliceHeight, mNumSlices);
     }
     return true;
 }

 bool HeifDecoderImpl::getEncodedColor(HeifEncodedColor* /*outColor*/) const {
     ALOGW("getEncodedColor: not implemented!");
     return false;
 }

 bool HeifDecoderImpl::setOutputColor(HeifColorFormat heifColor) {
     switch(heifColor) {
         case kHeifColorFormat_RGB565:
         {
             mOutputColor = HAL_PIXEL_FORMAT_RGB_565;
             return true;
         }
         case kHeifColorFormat_RGBA_8888:
         {
             mOutputColor = HAL_PIXEL_FORMAT_RGBA_8888;
             return true;
         }
         case kHeifColorFormat_BGRA_8888:
         {
             mOutputColor = HAL_PIXEL_FORMAT_BGRA_8888;
             return true;
         }
         default:
             break;
     }
     ALOGE("Unsupported output color format %d", heifColor);
     return false;
 }

 bool HeifDecoderImpl::decodeAsync() {
     for (size_t i = 1; i < mNumSlices; i++) {
         ALOGV("decodeAsync(): decoding slice %zu", i);
         size_t top = i * mSliceHeight;
         size_t bottom = (i + 1) * mSliceHeight;
         if (bottom > mHeight) {
             bottom = mHeight;
         }
         sp<IMemory> frameMemory = mRetriever->getImageRectAtIndex(
                 -1, mOutputColor, 0, top, mWidth, bottom);
         {
             Mutex::Autolock autolock(mLock);

             if (frameMemory == nullptr || frameMemory->pointer() == nullptr) {
                 mAsyncDecodeDone = true;
                 mScanlineReady.signal();
                 break;
             }
             mFrameMemory = frameMemory;
             mAvailableLines = bottom;
             ALOGV("decodeAsync(): available lines %zu", mAvailableLines);
             mScanlineReady.signal();
         }
     }
     // Aggressive clear to avoid holding on to resources
     mRetriever.clear();
     mDataSource.clear();
     return false;
 }

 bool HeifDecoderImpl::decode(HeifFrameInfo* frameInfo) {
     // reset scanline pointer
     mCurScanline = 0;

     if (mFrameDecoded) {
         return true;
     }

     // See if we want to decode in slices to allow client to start
     // scanline processing in parallel with decode. If this fails
     // we fallback to decoding the full frame.
     if (mHasImage && mNumSlices > 1) {
         // get first slice and metadata
         sp<IMemory> frameMemory = mRetriever->getImageRectAtIndex(
                 -1, mOutputColor, 0, 0, mWidth, mSliceHeight);

         if (frameMemory == nullptr || frameMemory->pointer() == nullptr) {
             ALOGE("decode: metadata is a nullptr");
             return false;
         }

         VideoFrame* videoFrame = static_cast<VideoFrame*>(frameMemory->pointer());

         if (frameInfo != nullptr) {
             frameInfo->set(
                     videoFrame->mWidth,
                     videoFrame->mHeight,
                     videoFrame->mRotationAngle,
                     videoFrame->mBytesPerPixel,
                     videoFrame->mIccSize,
                     videoFrame->getFlattenedIccData());
         }

         mFrameMemory = frameMemory;
         mAvailableLines = mSliceHeight;
         mThread = new DecodeThread(this);
         if (mThread->run("HeifDecode", ANDROID_PRIORITY_FOREGROUND) == OK) {
             mFrameDecoded = true;
             return true;
         }

         // Fallback to decode without slicing
         mThread.clear();
         mNumSlices = 1;
         mSliceHeight = 0;
         mAvailableLines = 0;
         mFrameMemory.clear();
     }

     if (mHasImage) {
         // image index < 0 to retrieve primary image
         mFrameMemory = mRetriever->getImageAtIndex(-1, mOutputColor);
     } else if (mHasVideo) {
         mFrameMemory = mRetriever->getFrameAtTime(0,
                 MediaSource::ReadOptions::SEEK_PREVIOUS_SYNC, mOutputColor);
     }

     if (mFrameMemory == nullptr || mFrameMemory->pointer() == nullptr) {
         ALOGE("decode: videoFrame is a nullptr");
         return false;
     }

     VideoFrame* videoFrame = static_cast<VideoFrame*>(mFrameMemory->pointer());
     if (videoFrame->mSize == 0 ||
             mFrameMemory->size() < videoFrame->getFlattenedSize()) {
         ALOGE("decode: videoFrame size is invalid");
         return false;
     }

     ALOGV("Decoded dimension %dx%d, display %dx%d, angle %d, rowbytes %d, size %d",
             videoFrame->mWidth,
             videoFrame->mHeight,
             videoFrame->mDisplayWidth,
             videoFrame->mDisplayHeight,
             videoFrame->mRotationAngle,
             videoFrame->mRowBytes,
             videoFrame->mSize);

     if (frameInfo != nullptr) {
         frameInfo->set(
                 videoFrame->mWidth,
                 videoFrame->mHeight,
                 videoFrame->mRotationAngle,
                 videoFrame->mBytesPerPixel,
                 videoFrame->mIccSize,
                 videoFrame->getFlattenedIccData());
     }
     mFrameDecoded = true;

     // Aggressively clear to avoid holding on to resources
     mRetriever.clear();
     mDataSource.clear();
     return true;
 }

 bool HeifDecoderImpl::getScanlineInner(uint8_t* dst) {
     if (mFrameMemory == nullptr || mFrameMemory->pointer() == nullptr) {
         return false;
     }
     VideoFrame* videoFrame = static_cast<VideoFrame*>(mFrameMemory->pointer());
     uint8_t* src = videoFrame->getFlattenedData() + videoFrame->mRowBytes * mCurScanline++;
     memcpy(dst, src, videoFrame->mBytesPerPixel * videoFrame->mWidth);
     return true;
 }

 bool HeifDecoderImpl::getScanline(uint8_t* dst) {
     if (mCurScanline >= mHeight) {
         ALOGE("no more scanline available");
         return false;
     }

     if (mNumSlices > 1) {
         Mutex::Autolock autolock(mLock);

         while (!mAsyncDecodeDone && mCurScanline >= mAvailableLines) {
             mScanlineReady.wait(mLock);
         }
         return (mCurScanline < mAvailableLines) ? getScanlineInner(dst) : false;
     }

     return getScanlineInner(dst);
 }

 size_t HeifDecoderImpl::skipScanlines(size_t count) {
     uint32_t oldScanline = mCurScanline;
     mCurScanline += count;
     if (mCurScanline > mHeight) {
         mCurScanline = mHeight;
     }
     return (mCurScanline > oldScanline) ? (mCurScanline - oldScanline) : 0;
 }

 } // namespace android
	/*
	* Copyright (C) 2017 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	//#define LOG_NDEBUG 0
	#define LOG_TAG "HeifDecoderImpl"

	#include "HeifDecoderImpl.h"

	#include <stdio.h>

	#include <binder/IMemory.h>
	#include <binder/MemoryDealer.h>
	#include <drm/drm_framework_common.h>
	#include <media/IDataSource.h>
	#include <media/mediametadataretriever.h>
	#include <media/MediaSource.h>
	#include <media/stagefright/foundation/ADebug.h>
	#include <private/media/VideoFrame.h>
	#include <utils/Log.h>
	#include <utils/RefBase.h>

	HeifDecoder* createHeifDecoder() {
	return new android::HeifDecoderImpl();
	}

	namespace android {

	/*
	* HeifDataSource
	*
	* Proxies data requests over IDataSource interface from MediaMetadataRetriever
	* to the HeifStream interface we received from the heif decoder client.
	*/
	class HeifDataSource : public BnDataSource {
	public:
	/*
	* Constructs HeifDataSource; will take ownership of \|stream\|.
	*/
	HeifDataSource(HeifStream* stream)
	: mStream(stream), mEOS(false),
	mCachedOffset(0), mCachedSize(0), mCacheBufferSize(0) {}

	~HeifDataSource() override {}

	/*
	* Initializes internal resources.
	*/
	bool init();

	sp<IMemory> getIMemory() override { return mMemory; }
	ssize_t readAt(off64_t offset, size_t size) override;
	status_t getSize(off64_t* size) override ;
	void close() {}
	uint32_t getFlags() override { return 0; }
	String8 toString() override { return String8("HeifDataSource"); }
	sp<DecryptHandle> DrmInitialization(const char*) override {
	return nullptr;
	}

	private:
	enum {
	/*
	* Buffer size for passing the read data to mediaserver. Set to 64K
	* (which is what MediaDataSource Java API's jni implementation uses).
	*/
	kBufferSize = 64 * 1024,
	/*
	* Initial and max cache buffer size.
	*/
	kInitialCacheBufferSize = 4 * 1024 * 1024,
	kMaxCacheBufferSize = 64 * 1024 * 1024,
	};
	sp<IMemory> mMemory;
	std::unique_ptr<HeifStream> mStream;
	bool mEOS;
	std::unique_ptr<uint8_t[]> mCache;
	off64_t mCachedOffset;
	size_t mCachedSize;
	size_t mCacheBufferSize;
	};

	bool HeifDataSource::init() {
	sp<MemoryDealer> memoryDealer =
	new MemoryDealer(kBufferSize, "HeifDataSource");
	mMemory = memoryDealer->allocate(kBufferSize);
	if (mMemory == nullptr) {
	ALOGE("Failed to allocate shared memory!");
	return false;
	}
	mCache.reset(new uint8_t[kInitialCacheBufferSize]);
	if (mCache.get() == nullptr) {
	ALOGE("mFailed to allocate cache!");
	return false;
	}
	mCacheBufferSize = kInitialCacheBufferSize;
	return true;
	}

	ssize_t HeifDataSource::readAt(off64_t offset, size_t size) {
	ALOGV("readAt: offset=%lld, size=%zu", (long long)offset, size);

	if (offset < mCachedOffset) {
	// try seek, then rewind/skip, fail if none worked
	if (mStream->seek(offset)) {
	ALOGV("readAt: seek to offset=%lld", (long long)offset);
	mCachedOffset = offset;
	mCachedSize = 0;
	mEOS = false;
	} else if (mStream->rewind()) {
	ALOGV("readAt: rewind to offset=0");
	mCachedOffset = 0;
	mCachedSize = 0;
	mEOS = false;
	} else {
	ALOGE("readAt: couldn't seek or rewind!");
	mEOS = true;
	}
	}

	if (mEOS && (offset < mCachedOffset \|\|
	offset >= (off64_t)(mCachedOffset + mCachedSize))) {
	ALOGV("readAt: EOS");
	return ERROR_END_OF_STREAM;
	}

	// at this point, offset must be >= mCachedOffset, other cases should
	// have been caught above.
	CHECK(offset >= mCachedOffset);

	off64_t resultOffset;
	if (__builtin_add_overflow(offset, size, &resultOffset)) {
	return ERROR_IO;
	}

	if (size == 0) {
	return 0;
	}

	// Can only read max of kBufferSize
	if (size > kBufferSize) {
	size = kBufferSize;
	}

	// copy from cache if the request falls entirely in cache
	if (offset + size <= mCachedOffset + mCachedSize) {
	memcpy(mMemory->pointer(), mCache.get() + offset - mCachedOffset, size);
	return size;
	}

	// need to fetch more, check if we need to expand the cache buffer.
	if ((off64_t)(offset + size) > mCachedOffset + kMaxCacheBufferSize) {
	// it's reaching max cache buffer size, need to roll window, and possibly
	// expand the cache buffer.
	size_t newCacheBufferSize = mCacheBufferSize;
	std::unique_ptr<uint8_t[]> newCache;
	uint8_t* dst = mCache.get();
	if (newCacheBufferSize < kMaxCacheBufferSize) {
	newCacheBufferSize = kMaxCacheBufferSize;
	newCache.reset(new uint8_t[newCacheBufferSize]);
	dst = newCache.get();
	}

	// when rolling the cache window, try to keep about half the old bytes
	// in case that the client goes back.
	off64_t newCachedOffset = offset - (off64_t)(newCacheBufferSize / 2);
	if (newCachedOffset < mCachedOffset) {
	newCachedOffset = mCachedOffset;
	}

	int64_t newCachedSize = (int64_t)(mCachedOffset + mCachedSize) - newCachedOffset;
	if (newCachedSize > 0) {
	// in this case, the new cache region partially overlop the old cache,
	// move the portion of the cache we want to save to the beginning of
	// the cache buffer.
	memcpy(dst, mCache.get() + newCachedOffset - mCachedOffset, newCachedSize);
	} else if (newCachedSize < 0){
	// in this case, the new cache region is entirely out of the old cache,
	// in order to guarantee sequential read, we need to skip a number of
	// bytes before reading.
	size_t bytesToSkip = -newCachedSize;
	size_t bytesSkipped = mStream->read(nullptr, bytesToSkip);
	if (bytesSkipped != bytesToSkip) {
	// bytesSkipped is invalid, there is not enough bytes to reach
	// the requested offset.
	ALOGE("readAt: skip failed, EOS");

	mEOS = true;
	mCachedOffset = newCachedOffset;
	mCachedSize = 0;
	return ERROR_END_OF_STREAM;
	}
	// set cache size to 0, since we're not keeping any old cache
	newCachedSize = 0;
	}

	if (newCache.get() != nullptr) {
	mCache.reset(newCache.release());
	mCacheBufferSize = newCacheBufferSize;
	}
	mCachedOffset = newCachedOffset;
	mCachedSize = newCachedSize;

	ALOGV("readAt: rolling cache window to (%lld, %zu), cache buffer size %zu",
	(long long)mCachedOffset, mCachedSize, mCacheBufferSize);
	} else {
	// expand cache buffer, but no need to roll the window
	size_t newCacheBufferSize = mCacheBufferSize;
	while (offset + size > mCachedOffset + newCacheBufferSize) {
	newCacheBufferSize *= 2;
	}
	CHECK(newCacheBufferSize <= kMaxCacheBufferSize);
	if (mCacheBufferSize < newCacheBufferSize) {
	uint8_t* newCache = new uint8_t[newCacheBufferSize];
	memcpy(newCache, mCache.get(), mCachedSize);
	mCache.reset(newCache);
	mCacheBufferSize = newCacheBufferSize;

	ALOGV("readAt: current cache window (%lld, %zu), new cache buffer size %zu",
	(long long) mCachedOffset, mCachedSize, mCacheBufferSize);
	}
	}
	size_t bytesToRead = offset + size - mCachedOffset - mCachedSize;
	size_t bytesRead = mStream->read(mCache.get() + mCachedSize, bytesToRead);
	if (bytesRead > bytesToRead \|\| bytesRead == 0) {
	// bytesRead is invalid
	mEOS = true;
	bytesRead = 0;
	} else if (bytesRead < bytesToRead) {
	// read some bytes but not all, set EOS
	mEOS = true;
	}
	mCachedSize += bytesRead;
	ALOGV("readAt: current cache window (%lld, %zu)",
	(long long) mCachedOffset, mCachedSize);

	// here bytesAvailable could be negative if offset jumped past EOS.
	int64_t bytesAvailable = mCachedOffset + mCachedSize - offset;
	if (bytesAvailable <= 0) {
	return ERROR_END_OF_STREAM;
	}
	if (bytesAvailable < (int64_t)size) {
	size = bytesAvailable;
	}
	memcpy(mMemory->pointer(), mCache.get() + offset - mCachedOffset, size);
	return size;
	}

	status_t HeifDataSource::getSize(off64_t* size) {
	if (!mStream->hasLength()) {
	*size = -1;
	ALOGE("getSize: not supported!");
	return ERROR_UNSUPPORTED;
	}
	*size = mStream->getLength();
	ALOGV("getSize: size=%lld", (long long)*size);
	return OK;
	}

	/////////////////////////////////////////////////////////////////////////

	struct HeifDecoderImpl::DecodeThread : public Thread {
	explicit DecodeThread(HeifDecoderImpl *decoder) : mDecoder(decoder) {}

	private:
	HeifDecoderImpl* mDecoder;

	bool threadLoop();

	DISALLOW_EVIL_CONSTRUCTORS(DecodeThread);
	};

	bool HeifDecoderImpl::DecodeThread::threadLoop() {
	return mDecoder->decodeAsync();
	}

	/////////////////////////////////////////////////////////////////////////

	HeifDecoderImpl::HeifDecoderImpl() :
	// output color format should always be set via setOutputColor(), in case
	// it's not, default to HAL_PIXEL_FORMAT_RGB_565.
	mOutputColor(HAL_PIXEL_FORMAT_RGB_565),
	mCurScanline(0),
	mWidth(0),
	mHeight(0),
	mFrameDecoded(false),
	mHasImage(false),
	mHasVideo(false),
	mAvailableLines(0),
	mNumSlices(1),
	mSliceHeight(0),
	mAsyncDecodeDone(false) {
	}

	HeifDecoderImpl::~HeifDecoderImpl() {
	if (mThread != nullptr) {
	mThread->join();
	}
	}

	bool HeifDecoderImpl::init(HeifStream* stream, HeifFrameInfo* frameInfo) {
	mFrameDecoded = false;
	mFrameMemory.clear();

	sp<HeifDataSource> dataSource = new HeifDataSource(stream);
	if (!dataSource->init()) {
	return false;
	}
	mDataSource = dataSource;

	mRetriever = new MediaMetadataRetriever();
	status_t err = mRetriever->setDataSource(mDataSource, "image/heif");
	if (err != OK) {
	ALOGE("failed to set data source!");

	mRetriever.clear();
	mDataSource.clear();
	return false;
	}
	ALOGV("successfully set data source.");

	const char* hasImage = mRetriever->extractMetadata(METADATA_KEY_HAS_IMAGE);
	const char* hasVideo = mRetriever->extractMetadata(METADATA_KEY_HAS_VIDEO);

	mHasImage = hasImage && !strcasecmp(hasImage, "yes");
	mHasVideo = hasVideo && !strcasecmp(hasVideo, "yes");
	sp<IMemory> sharedMem;
	if (mHasImage) {
	// image index < 0 to retrieve primary image
	sharedMem = mRetriever->getImageAtIndex(
	-1, mOutputColor, true /metaOnly/);
	} else if (mHasVideo) {
	sharedMem = mRetriever->getFrameAtTime(0,
	MediaSource::ReadOptions::SEEK_PREVIOUS_SYNC,
	mOutputColor, true /metaOnly/);
	}

	if (sharedMem == nullptr \|\| sharedMem->pointer() == nullptr) {
	ALOGE("getFrameAtTime: videoFrame is a nullptr");
	return false;
	}

	VideoFrame* videoFrame = static_cast<VideoFrame*>(sharedMem->pointer());

	ALOGV("Meta dimension %dx%d, display %dx%d, angle %d, iccSize %d",
	videoFrame->mWidth,
	videoFrame->mHeight,
	videoFrame->mDisplayWidth,
	videoFrame->mDisplayHeight,
	videoFrame->mRotationAngle,
	videoFrame->mIccSize);

	if (frameInfo != nullptr) {
	frameInfo->set(
	videoFrame->mWidth,
	videoFrame->mHeight,
	videoFrame->mRotationAngle,
	videoFrame->mBytesPerPixel,
	videoFrame->mIccSize,
	videoFrame->getFlattenedIccData());
	}
	mWidth = videoFrame->mWidth;
	mHeight = videoFrame->mHeight;
	if (mHasImage && videoFrame->mTileHeight >= 512 && mWidth >= 3000 && mHeight >= 2000 ) {
	// Try decoding in slices only if the image has tiles and is big enough.
	mSliceHeight = videoFrame->mTileHeight;
	mNumSlices = (videoFrame->mHeight + mSliceHeight - 1) / mSliceHeight;
	ALOGV("mSliceHeight %u, mNumSlices %zu", mSliceHeight, mNumSlices);
	}
	return true;
	}

	bool HeifDecoderImpl::getEncodedColor(HeifEncodedColor* /outColor/) const {
	ALOGW("getEncodedColor: not implemented!");
	return false;
	}

	bool HeifDecoderImpl::setOutputColor(HeifColorFormat heifColor) {
	switch(heifColor) {
	case kHeifColorFormat_RGB565:
	{
	mOutputColor = HAL_PIXEL_FORMAT_RGB_565;
	return true;
	}
	case kHeifColorFormat_RGBA_8888:
	{
	mOutputColor = HAL_PIXEL_FORMAT_RGBA_8888;
	return true;
	}
	case kHeifColorFormat_BGRA_8888:
	{
	mOutputColor = HAL_PIXEL_FORMAT_BGRA_8888;
	return true;
	}
	default:
	break;
	}
	ALOGE("Unsupported output color format %d", heifColor);
	return false;
	}

	bool HeifDecoderImpl::decodeAsync() {
	for (size_t i = 1; i < mNumSlices; i++) {
	ALOGV("decodeAsync(): decoding slice %zu", i);
	size_t top = i * mSliceHeight;
	size_t bottom = (i + 1) * mSliceHeight;
	if (bottom > mHeight) {
	bottom = mHeight;
	}
	sp<IMemory> frameMemory = mRetriever->getImageRectAtIndex(
	-1, mOutputColor, 0, top, mWidth, bottom);
	{
	Mutex::Autolock autolock(mLock);

	if (frameMemory == nullptr \|\| frameMemory->pointer() == nullptr) {
	mAsyncDecodeDone = true;
	mScanlineReady.signal();
	break;
	}
	mFrameMemory = frameMemory;
	mAvailableLines = bottom;
	ALOGV("decodeAsync(): available lines %zu", mAvailableLines);
	mScanlineReady.signal();
	}
	}
	// Aggressive clear to avoid holding on to resources
	mRetriever.clear();
	mDataSource.clear();
	return false;
	}

	bool HeifDecoderImpl::decode(HeifFrameInfo* frameInfo) {
	// reset scanline pointer
	mCurScanline = 0;

	if (mFrameDecoded) {
	return true;
	}

	// See if we want to decode in slices to allow client to start
	// scanline processing in parallel with decode. If this fails
	// we fallback to decoding the full frame.
	if (mHasImage && mNumSlices > 1) {
	// get first slice and metadata
	sp<IMemory> frameMemory = mRetriever->getImageRectAtIndex(
	-1, mOutputColor, 0, 0, mWidth, mSliceHeight);

	if (frameMemory == nullptr \|\| frameMemory->pointer() == nullptr) {
	ALOGE("decode: metadata is a nullptr");
	return false;
	}

	VideoFrame* videoFrame = static_cast<VideoFrame*>(frameMemory->pointer());

	if (frameInfo != nullptr) {
	frameInfo->set(
	videoFrame->mWidth,
	videoFrame->mHeight,
	videoFrame->mRotationAngle,
	videoFrame->mBytesPerPixel,
	videoFrame->mIccSize,
	videoFrame->getFlattenedIccData());
	}

	mFrameMemory = frameMemory;
	mAvailableLines = mSliceHeight;
	mThread = new DecodeThread(this);
	if (mThread->run("HeifDecode", ANDROID_PRIORITY_FOREGROUND) == OK) {
	mFrameDecoded = true;
	return true;
	}

	// Fallback to decode without slicing
	mThread.clear();
	mNumSlices = 1;
	mSliceHeight = 0;
	mAvailableLines = 0;
	mFrameMemory.clear();
	}

	if (mHasImage) {
	// image index < 0 to retrieve primary image
	mFrameMemory = mRetriever->getImageAtIndex(-1, mOutputColor);
	} else if (mHasVideo) {
	mFrameMemory = mRetriever->getFrameAtTime(0,
	MediaSource::ReadOptions::SEEK_PREVIOUS_SYNC, mOutputColor);
	}

	if (mFrameMemory == nullptr \|\| mFrameMemory->pointer() == nullptr) {
	ALOGE("decode: videoFrame is a nullptr");
	return false;
	}

	VideoFrame* videoFrame = static_cast<VideoFrame*>(mFrameMemory->pointer());
	if (videoFrame->mSize == 0 \|\|
	mFrameMemory->size() < videoFrame->getFlattenedSize()) {
	ALOGE("decode: videoFrame size is invalid");
	return false;
	}

	ALOGV("Decoded dimension %dx%d, display %dx%d, angle %d, rowbytes %d, size %d",
	videoFrame->mWidth,
	videoFrame->mHeight,
	videoFrame->mDisplayWidth,
	videoFrame->mDisplayHeight,
	videoFrame->mRotationAngle,
	videoFrame->mRowBytes,
	videoFrame->mSize);

	if (frameInfo != nullptr) {
	frameInfo->set(
	videoFrame->mWidth,
	videoFrame->mHeight,
	videoFrame->mRotationAngle,
	videoFrame->mBytesPerPixel,
	videoFrame->mIccSize,
	videoFrame->getFlattenedIccData());
	}
	mFrameDecoded = true;

	// Aggressively clear to avoid holding on to resources
	mRetriever.clear();
	mDataSource.clear();
	return true;
	}

	bool HeifDecoderImpl::getScanlineInner(uint8_t* dst) {
	if (mFrameMemory == nullptr \|\| mFrameMemory->pointer() == nullptr) {
	return false;
	}
	VideoFrame* videoFrame = static_cast<VideoFrame*>(mFrameMemory->pointer());
	uint8_t* src = videoFrame->getFlattenedData() + videoFrame->mRowBytes * mCurScanline++;
	memcpy(dst, src, videoFrame->mBytesPerPixel * videoFrame->mWidth);
	return true;
	}

	bool HeifDecoderImpl::getScanline(uint8_t* dst) {
	if (mCurScanline >= mHeight) {
	ALOGE("no more scanline available");
	return false;
	}

	if (mNumSlices > 1) {
	Mutex::Autolock autolock(mLock);

	while (!mAsyncDecodeDone && mCurScanline >= mAvailableLines) {
	mScanlineReady.wait(mLock);
	}
	return (mCurScanline < mAvailableLines) ? getScanlineInner(dst) : false;
	}

	return getScanlineInner(dst);
	}

	size_t HeifDecoderImpl::skipScanlines(size_t count) {
	uint32_t oldScanline = mCurScanline;
	mCurScanline += count;
	if (mCurScanline > mHeight) {
	mCurScanline = mHeight;
	}
	return (mCurScanline > oldScanline) ? (mCurScanline - oldScanline) : 0;
	}

	} // namespace android