xref: /ohos5.0/foundation/multimedia/image_framework/plugins/common/libs/image/libextplugin/src/ext_encoder.cpp

/*
 * Copyright (C) 2023 Huawei Device Co., Ltd.
 * 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.
 */

#include "ext_encoder.h"
#include <algorithm>
#include <map>

#include "include/core/SkImageEncoder.h"
#include "src/images/SkImageEncoderFns.h"
#include "include/core/SkBitmap.h"
#include "pixel_yuv_utils.h"
#ifdef IMAGE_COLORSPACE_FLAG
#include "color_space.h"
#endif
#if !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
#include "astc_codec.h"
#endif

#include "ext_pixel_convert.h"
#include "ext_wstream.h"
#include "image_data_statistics.h"
#include "image_dfx.h"
#include "image_func_timer.h"
#include "image_fwk_ext_manager.h"
#include "image_log.h"
#include "image_system_properties.h"
#include "image_type_converter.h"
#include "image_utils.h"
#include "jpeg_mpf_parser.h"
#include "media_errors.h"
#include "metadata_accessor.h"
#include "metadata_accessor_factory.h"
#include "pixel_convert_adapter.h"
#include "string_ex.h"
#if !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
#include "surface_buffer.h"
#include "v1_0/buffer_handle_meta_key_type.h"
#include "v1_0/cm_color_space.h"
#include "v1_0/hdr_static_metadata.h"
#include "vpe_utils.h"
#include "hdr_helper.h"
#endif
#include "color_utils.h"
#include "tiff_parser.h"
#include "image_mime_type.h"
#include "securec.h"
#include "file_packer_stream.h"
#include "memory_manager.h"
#ifdef HEIF_HW_ENCODE_ENABLE
#include "v2_0/icodec_image.h"
#include "iremote_object.h"
#include "iproxy_broker.h"
#endif

#undef LOG_DOMAIN
#define LOG_DOMAIN LOG_TAG_DOMAIN_ID_PLUGIN

#undef LOG_TAG
#define LOG_TAG "ExtEncoder"

namespace OHOS {
namespace ImagePlugin {
using namespace Media;
#if !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
using namespace HDI::Display::Graphic::Common::V1_0;
const std::map<PixelFormat, GraphicPixelFormat> SURFACE_FORMAT_MAP = {
    { PixelFormat::RGBA_8888, GRAPHIC_PIXEL_FMT_RGBA_8888 },
    { PixelFormat::NV21, GRAPHIC_PIXEL_FMT_YCRCB_420_SP },
    { PixelFormat::NV12, GRAPHIC_PIXEL_FMT_YCBCR_420_SP },
};
#endif

namespace {
    constexpr static uint32_t PRIMARY_IMAGE_ITEM_ID = 1;
    constexpr static uint32_t GAINMAP_IMAGE_ITEM_ID = 2;
    constexpr static uint32_t TMAP_IMAGE_ITEM_ID = 3;
    constexpr static uint32_t EXIF_META_ITEM_ID = 4;
    constexpr static uint32_t DEPTH_MAP_ITEM_ID = 5;
    constexpr static uint32_t UNREFOCUS_MAP_ITEM_ID = 6;
    constexpr static uint32_t LINEAR_MAP_ITEM_ID = 7;
    constexpr static uint32_t FRAGMENT_MAP_ITEM_ID = 8;
    const static std::string COMPRESS_TYPE_TMAP = "tmap";
    const static std::string COMPRESS_TYPE_HEVC = "hevc";
    const static std::string COMPRESS_TYPE_NONE = "none";
    const static std::string DEFAULT_ASHMEM_TAG = "Heif Encoder Default";
    const static std::string ICC_ASHMEM_TAG = "Heif Encoder Property";
    const static std::string IT35_ASHMEM_TAG = "Heif Encoder IT35";
    const static std::string OUTPUT_ASHMEM_TAG = "Heif Encoder Output";
    const static std::string IMAGE_DATA_TAG = "Heif Encoder Image";
    const static std::string HDR_GAINMAP_TAG = "Heif Encoder Gainmap";
    const static std::string EXIF_ASHMEM_TAG = "Heif Encoder Exif";
    const static std::string GAINMAP_IMAGE_ITEM_NAME = "Gain map Image";
    const static std::string DEPTH_MAP_ITEM_NAME =  "Depth Map Image";
    const static std::string UNREFOCUS_MAP_ITEM_NAME = "Unrefocus Map Image";
    const static std::string LINEAR_MAP_ITEM_NAME = "Linear Map Image";
    const static std::string FRAGMENT_MAP_ITEM_NAME = "Fragment Map Image";
    constexpr uint32_t PLACE_HOLDER_LENGTH = 1;
    const static size_t DEFAULT_OUTPUT_SIZE = 35 * 1024 * 1024; // 35M
    const static uint16_t STATIC_METADATA_COLOR_SCALE = 50000;
    const static uint16_t STATIC_METADATA_LUM_SCALE = 10000;
    const static uint8_t INDEX_ZERO = 0;
    const static uint8_t INDEX_ONE = 1;
    const static uint8_t INDEX_TWO = 2;
    constexpr uint32_t DEFAULT_DENOMINATOR = 1000000;
    constexpr uint8_t GAINMAP_CHANNEL_MULTI = 3;
    constexpr uint8_t GAINMAP_CHANNEL_SINGLE = 1;
    constexpr uint8_t EXIF_PRE_SIZE = 6;
    constexpr uint32_t JPEG_MARKER_TAG_SIZE = 2;
    constexpr uint32_t DEPTH_MAP_BYTES = sizeof(float); // float16
    constexpr uint32_t LINEAR_MAP_BYTES = sizeof(short) * 3 / 2; // 16bit yuv420

    // exif/0/0
    constexpr uint8_t EXIF_PRE_TAG[EXIF_PRE_SIZE] = {
        0x45, 0x78, 0x69, 0x66, 0x00, 0x00
    };
}

struct HeifEncodeItemInfo {
    uint32_t itemId = 0;
    std::string itemName = "";
    std::string itemType = "";
};

static const std::map<std::string, SkEncodedImageFormat> FORMAT_NAME = {
    {IMAGE_BMP_FORMAT, SkEncodedImageFormat::kBMP},
    {IMAGE_GIF_FORMAT, SkEncodedImageFormat::kGIF},
    {IMAGE_ICO_FORMAT, SkEncodedImageFormat::kICO},
    {IMAGE_JPEG_FORMAT, SkEncodedImageFormat::kJPEG},
    {IMAGE_PNG_FORMAT, SkEncodedImageFormat::kPNG},
    {IMAGE_WBMP_FORMAT, SkEncodedImageFormat::kWBMP},
    {IMAGE_WEBP_FORMAT, SkEncodedImageFormat::kWEBP},
    {IMAGE_HEIF_FORMAT, SkEncodedImageFormat::kHEIF},
    {IMAGE_HEIC_FORMAT, SkEncodedImageFormat::kHEIF},
};

static const std::map<AuxiliaryPictureType, std::string> DEFAULT_AUXILIARY_TAG_MAP = {
    {AuxiliaryPictureType::GAINMAP, AUXILIARY_TAG_GAINMAP},
    {AuxiliaryPictureType::DEPTH_MAP, AUXILIARY_TAG_DEPTH_MAP_BACK},
    {AuxiliaryPictureType::UNREFOCUS_MAP, AUXILIARY_TAG_UNREFOCUS_MAP},
    {AuxiliaryPictureType::LINEAR_MAP, AUXILIARY_TAG_LINEAR_MAP},
    {AuxiliaryPictureType::FRAGMENT_MAP, AUXILIARY_TAG_FRAGMENT_MAP},
};

static const uint8_t NUM_3 = 3;
static const uint8_t NUM_4 = 4;

#ifdef HEIF_HW_ENCODE_ENABLE
using namespace OHOS::HDI::Codec::Image::V2_0;
static std::mutex g_codecMtx;
static sptr<ICodecImage> g_codecMgr;
class CodecHeifDeathRecipient : public IRemoteObject::DeathRecipient {
public:
    void OnRemoteDied(const wptr<OHOS::IRemoteObject>& object) override
    {
        IMAGE_LOGW("codec_image_service died");
        std::lock_guard<std::mutex> lk(g_codecMtx);
        g_codecMgr = nullptr;
    }
};

static sptr<ICodecImage> GetCodecManager()
{
    std::lock_guard<std::mutex> lk(g_codecMtx);
    if (g_codecMgr) {
        return g_codecMgr;
    }
    IMAGE_LOGI("need to get ICodecImage");
    g_codecMgr = ICodecImage::Get();
    if (g_codecMgr == nullptr) {
        IMAGE_LOGE("ICodecImage get failed");
        return nullptr;
    }
    bool isDeathRecipientAdded = false;
    const sptr<OHOS::IRemoteObject> &remote = OHOS::HDI::hdi_objcast<ICodecImage>(g_codecMgr);
    if (remote) {
        sptr<CodecHeifDeathRecipient> deathCallBack(new CodecHeifDeathRecipient());
        isDeathRecipientAdded = remote->AddDeathRecipient(deathCallBack);
    }
    if (!isDeathRecipientAdded) {
        IMAGE_LOGI("failed to add deathRecipient for ICodecImage!");
    }
    return g_codecMgr;
}
#endif

ExtEncoder::ExtEncoder()
{
}

ExtEncoder::~ExtEncoder()
{
}

uint32_t ExtEncoder::StartEncode(OutputDataStream &outputStream, PlEncodeOptions &option)
{
    output_ = &outputStream;
    opts_ = option;
    return SUCCESS;
}

uint32_t ExtEncoder::AddImage(PixelMap &pixelMap)
{
    pixelmap_ = &pixelMap;
    return SUCCESS;
}

uint32_t ExtEncoder::AddPicture(Media::Picture &picture)
{
    picture_ = &picture;
    return SUCCESS;
}

struct TmpBufferHolder {
    std::unique_ptr<uint8_t[]> buf = nullptr;
};

struct ImageData {
    uint8_t *dst;
    uint8_t *pixels;
    ImageInfo info;
};

static sk_sp<SkColorSpace> ToSkColorSpace(PixelMap *pixelmap)
{
#ifdef IMAGE_COLORSPACE_FLAG
    if (pixelmap->InnerGetGrColorSpacePtr() == nullptr) {
        return nullptr;
    }
    if (pixelmap->InnerGetGrColorSpace().GetColorSpaceName() == ColorManager::ColorSpaceName::NONE) {
        return SkColorSpace::MakeSRGB();
    }
    return pixelmap->InnerGetGrColorSpacePtr()->ToSkColorSpace();
#else
    return nullptr;
#endif
}

static SkImageInfo ToSkInfo(Media::PixelMap *pixelMap)
{
    ImageInfo info;
    pixelMap->GetImageInfo(info);
    SkColorType colorType = ImageTypeConverter::ToSkColorType(info.pixelFormat);
    SkAlphaType alphaType = ImageTypeConverter::ToSkAlphaType(info.alphaType);
    sk_sp<SkColorSpace> colorSpace = SkColorSpace::MakeSRGB();
#ifdef IMAGE_COLORSPACE_FLAG
    if (pixelMap->InnerGetGrColorSpacePtr() != nullptr &&
        pixelMap->InnerGetGrColorSpace().GetColorSpaceName() != ColorManager::ColorSpaceName::NONE) {
        colorSpace = pixelMap->InnerGetGrColorSpacePtr()->ToSkColorSpace();
    }
#endif
    return SkImageInfo::Make(info.size.width, info.size.height, colorType, alphaType, colorSpace);
}

static uint32_t RGBToRGBx(PixelMap *pixelMap, SkImageInfo &skInfo, TmpBufferHolder &holder)
{
    holder.buf = std::make_unique<uint8_t[]>(skInfo.computeMinByteSize());
    ExtPixels src = {
        static_cast<uint8_t*>(pixelMap->GetWritablePixels()),
        pixelMap->GetCapacity(), pixelMap->GetWidth()*pixelMap->GetHeight(),
    };
    ExtPixels dst = {
        holder.buf.get(), skInfo.computeMinByteSize(), skInfo.width()*skInfo.height(),
    };
    return ExtPixelConvert::RGBToRGBx(src, dst);
}

static bool IsYuvImage(PixelFormat format)
{
    return format == PixelFormat::NV21 || format == PixelFormat::NV12;
}

static uint32_t YuvToRgbaSkInfo(ImageInfo info, SkImageInfo &skInfo, uint8_t * dstData, Media::PixelMap *pixelMap)
{
    uint8_t *srcData = static_cast<uint8_t*>(pixelMap->GetWritablePixels());
    YUVDataInfo yuvInfo;
    pixelMap->GetImageYUVInfo(yuvInfo);
    YuvImageInfo srcInfo = {PixelYuvUtils::ConvertFormat(info.pixelFormat),
        info.size.width, info.size.height, info.pixelFormat, yuvInfo};
    YuvImageInfo dstInfo = {PixelYuvUtils::ConvertFormat(PixelFormat::RGBA_8888), info.size.width, info.size.height};
    if (!PixelConvertAdapter::YUV420ToRGB888(srcData, srcInfo, dstData, dstInfo)) {
        IMAGE_LOGE("YuvToSkInfo Support YUV format RGB convert failed ");
        return ERR_IMAGE_ENCODE_FAILED;
    }
    auto alpha = pixelMap->GetAlphaType();
    if (alpha == AlphaType::IMAGE_ALPHA_TYPE_UNKNOWN)
        alpha = AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
    SkAlphaType alphaType = ImageTypeConverter::ToSkAlphaType(alpha);
    auto cs = ToSkColorSpace(pixelMap);
    skInfo = SkImageInfo::Make(info.size.width, info.size.height, SkColorType::kRGBA_8888_SkColorType, alphaType, cs);
    IMAGE_LOGD(" YuvToSkInfo: width:%{public}d, height:%{public}d, alpha:%{public}d \n ",
        info.size.width, info.size.height, (int32_t)alphaType);
    return SUCCESS;
}

static uint32_t pixelToSkInfo(ImageData &image, SkImageInfo &skInfo, Media::PixelMap *pixelMap,
    TmpBufferHolder &holder, SkEncodedImageFormat format)
{
    skInfo = ToSkInfo(pixelMap);
    image.pixels = static_cast<uint8_t*>(pixelMap->GetWritablePixels());
    if (format == SkEncodedImageFormat::kJPEG &&
        skInfo.colorType() == SkColorType::kRGB_888x_SkColorType &&
        pixelMap->GetCapacity() < skInfo.computeMinByteSize()) {
        uint32_t res = RGBToRGBx(pixelMap, skInfo, holder);
        if (res != SUCCESS) {
            IMAGE_LOGE("ExtEncoder::BuildSkBitmap RGB convert failed %{public}d", res);
            return res;
        }
        image.pixels = holder.buf.get();
        skInfo = skInfo.makeColorType(SkColorType::kRGBA_8888_SkColorType);
    }
    return SUCCESS;
}

bool IsAstc(const std::string &format)
{
    return format.find("image/astc") == 0;
}

static uint32_t CreateAndWriteBlob(MetadataWStream &tStream, PixelMap *pixelmap, SkWStream& outStream,
    ImageInfo &imageInfo, PlEncodeOptions &opts)
{
    ImageFuncTimer imageFuncTimer("insert exit data (%d, %d)", imageInfo.size.width, imageInfo.size.height);
    auto metadataAccessor =
        MetadataAccessorFactory::Create(tStream.GetAddr(), tStream.bytesWritten(), BufferMetadataStream::Dynamic);
    if (metadataAccessor != nullptr) {
        auto metadataPtr = pixelmap->GetExifMetadata();
        metadataAccessor->Set(metadataPtr);
        if (metadataAccessor->Write() == SUCCESS) {
            if (metadataAccessor->WriteToOutput(outStream)) {
                return SUCCESS;
            }
        }
    }
    if (!outStream.write(tStream.GetAddr(), tStream.bytesWritten())) {
        ReportEncodeFault(imageInfo.size.width, imageInfo.size.height, opts.format, "Failed to encode image");
        return ERR_IMAGE_ENCODE_FAILED;
    }
    return SUCCESS;
}

uint32_t ExtEncoder::PixelmapEncode(ExtWStream& wStream)
{
    uint32_t error;
#if defined(_WIN32) || defined(_APPLE) || defined(IOS_PLATFORM) || defined(ANDROID_PLATFORM)
    IMAGE_LOGD("pixelmapEncode EncodeImageByPixelMap");
    error = EncodeImageByPixelMap(pixelmap_, opts_.needsPackProperties, wStream);
#else
    switch (opts_.desiredDynamicRange) {
        case EncodeDynamicRange::AUTO:
            if (pixelmap_->IsHdr() &&
                (encodeFormat_ == SkEncodedImageFormat::kJPEG || encodeFormat_ == SkEncodedImageFormat::kHEIF)) {
                error = EncodeDualVivid(wStream);
            } else {
                error = EncodeSdrImage(wStream);
            }
            break;
        case EncodeDynamicRange::SDR:
            error = EncodeSdrImage(wStream);
            break;
        case EncodeDynamicRange::HDR_VIVID_DUAL:
            error = EncodeDualVivid(wStream);
            break;
        case EncodeDynamicRange::HDR_VIVID_SINGLE:
            error = EncodeSingleVivid(wStream);
            break;
        default:
            error = ERR_IMAGE_ENCODE_FAILED;
            break;
    }
#endif
    RecycleResources();
    return error;
}

uint32_t ExtEncoder::FinalizeEncode()
{
    if ((picture_ == nullptr && pixelmap_ == nullptr) || output_ == nullptr) {
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    ImageDataStatistics imageDataStatistics("[ExtEncoder]FinalizeEncode imageFormat = %s, quality = %d",
        opts_.format.c_str(), opts_.quality);
#if !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
    if (IsAstc(opts_.format)) {
        AstcCodec astcEncoder;
        astcEncoder.SetAstcEncode(output_, opts_, pixelmap_);
        return astcEncoder.ASTCEncode();
    }
#endif
    auto iter = FORMAT_NAME.find(LowerStr(opts_.format));
    if (iter == FORMAT_NAME.end()) {
        IMAGE_LOGE("ExtEncoder::FinalizeEncode unsupported format %{public}s", opts_.format.c_str());
        ReportEncodeFault(0, 0, opts_.format, "Unsupported format:" + opts_.format);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
#if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
    if (picture_ != nullptr) {
        encodeFormat_ = iter->second;
        return EncodePicture();
    }
#endif
    ImageInfo imageInfo;
    pixelmap_->GetImageInfo(imageInfo);
    imageDataStatistics.AddTitle(", width = %d, height =%d", imageInfo.size.width, imageInfo.size.height);
    encodeFormat_ = iter->second;
    ExtWStream wStream(output_);
    return PixelmapEncode(wStream);
}

bool ExtEncoder::IsHardwareEncodeSupported(const PlEncodeOptions &opts, Media::PixelMap* pixelMap)
{
    if (pixelMap == nullptr) {
        IMAGE_LOGE("pixelMap is nullptr");
        return false;
    }
    static const int32_t maxImageSize = 8196;
    static const int32_t minImageSize = 128;
    bool isSupport = ImageSystemProperties::GetHardWareEncodeEnabled() && opts.format == "image/jpeg" &&
        (pixelMap->GetWidth() % 2 == 0) && (pixelMap->GetHeight() % 2 == 0) &&
        (pixelMap->GetPixelFormat() == PixelFormat::NV12 || pixelMap->GetPixelFormat() == PixelFormat::NV21) &&
        pixelMap->GetWidth() <= maxImageSize && pixelMap->GetHeight() <= maxImageSize &&
        pixelMap->GetWidth() >= minImageSize && pixelMap->GetHeight() >= minImageSize;
    if (!isSupport) {
        IMAGE_LOGD("hardware encode is not support, dstEncodeFormat:%{public}s, pixelWidth:%{public}d, "
            "pixelHeight:%{public}d, pixelFormat:%{public}d", opts.format.c_str(), pixelMap->GetWidth(),
            pixelMap->GetHeight(), pixelMap->GetPixelFormat());
    }
    return isSupport;
}

uint32_t ExtEncoder::DoHardWareEncode(SkWStream* skStream)
{
    static ImageFwkExtManager imageFwkExtManager;
    if (imageFwkExtManager.doHardWareEncodeFunc_ != nullptr || imageFwkExtManager.LoadImageFwkExtNativeSo()) {
        int32_t retCode = imageFwkExtManager.doHardWareEncodeFunc_(skStream, opts_, pixelmap_);
        if (retCode == SUCCESS) {
            return SUCCESS;
        }
        IMAGE_LOGE("hardware encode failed, retCode is %{public}d", retCode);
        ImageInfo imageInfo;
        pixelmap_->GetImageInfo(imageInfo);
        ReportEncodeFault(imageInfo.size.width, imageInfo.size.height, opts_.format, "hardware encode failed");
    } else {
        IMAGE_LOGE("hardware encode failed because of load native so failed");
    }
    return ERR_IMAGE_ENCODE_FAILED;
}

uint32_t ExtEncoder::DoEncode(SkWStream* skStream, const SkBitmap& src, const SkEncodedImageFormat& skFormat)
{
    ImageFuncTimer imageFuncTimer("%s:(%d, %d)", __func__, pixelmap_->GetWidth(), pixelmap_->GetHeight());
    ImageInfo imageInfo;
    pixelmap_->GetImageInfo(imageInfo);
    if (!SkEncodeImage(skStream, src, skFormat, opts_.quality)) {
        IMAGE_LOGE("Failed to encode image without exif data");
        ReportEncodeFault(imageInfo.size.width, imageInfo.size.height, opts_.format, "Failed to encode image");
        return ERR_IMAGE_ENCODE_FAILED;
    }
    return SUCCESS;
}

bool ExtEncoder::HardwareEncode(SkWStream &skStream, bool needExif)
{
    uint32_t retCode = ERR_IMAGE_ENCODE_FAILED;
    if (IsHardwareEncodeSupported(opts_, pixelmap_)) {
        if (!needExif || pixelmap_->GetExifMetadata() == nullptr ||
            pixelmap_->GetExifMetadata()->GetExifData() == nullptr) {
                retCode = DoHardWareEncode(&skStream);
                IMAGE_LOGD("HardwareEncode retCode:%{public}d", retCode);
                return (retCode == SUCCESS);
        }
        MetadataWStream tStream;
        retCode = DoHardWareEncode(&tStream);
        if (retCode != SUCCESS) {
            IMAGE_LOGD("HardwareEncode failed");
            return false;
        }
        ImageInfo imageInfo;
        pixelmap_->GetImageInfo(imageInfo);
        retCode = CreateAndWriteBlob(tStream, pixelmap_, skStream, imageInfo, opts_);
        IMAGE_LOGD("HardwareEncode retCode :%{public}d", retCode);
        return (retCode == SUCCESS);
    }
    return (retCode == SUCCESS);
}

uint32_t ExtEncoder::EncodeImageByBitmap(SkBitmap& bitmap, bool needExif, SkWStream& outStream)
{
    ImageInfo imageInfo;
    pixelmap_->GetImageInfo(imageInfo);
    if (!needExif || pixelmap_->GetExifMetadata() == nullptr ||
        pixelmap_->GetExifMetadata()->GetExifData() == nullptr) {
            return DoEncode(&outStream, bitmap, encodeFormat_);
    }

    MetadataWStream tStream;
    uint32_t errCode = DoEncode(&tStream, bitmap, encodeFormat_);
    if (errCode != SUCCESS) {
        return errCode;
    }
    return CreateAndWriteBlob(tStream, pixelmap_, outStream, imageInfo, opts_);
}

uint32_t ExtEncoder::EncodeImageByPixelMap(PixelMap* pixelMap, bool needExif, SkWStream& outputStream)
{
    if (encodeFormat_ == SkEncodedImageFormat::kHEIF) {
        return EncodeHeifByPixelmap(pixelMap, opts_);
    }
    SkBitmap bitmap;
    TmpBufferHolder holder;
    SkImageInfo skInfo;
    ImageData imageData;
    pixelMap->GetImageInfo(imageData.info);
    uint32_t width  = static_cast<uint32_t>(imageData.info.size.width);
    uint32_t height = static_cast<uint32_t>(imageData.info.size.height);

    if (HardwareEncode(outputStream, needExif) == true) {
        IMAGE_LOGD("HardwareEncode Success return");
        return SUCCESS;
    }
    IMAGE_LOGD("HardwareEncode failed or not Supported");

    std::unique_ptr<uint8_t[]> dstData;
    uint64_t rowStride = 0;
    if (IsYuvImage(imageData.info.pixelFormat)) {
        IMAGE_LOGD("YUV format, convert to RGB");
        dstData = std::make_unique<uint8_t[]>(width * height * NUM_4);
        if (YuvToRgbaSkInfo(imageData.info, skInfo, dstData.get(), pixelMap) != SUCCESS) {
            IMAGE_LOGD("YUV format, convert to RGB fail");
            return ERR_IMAGE_ENCODE_FAILED;
        }
        imageData.pixels = dstData.get();
        rowStride = skInfo.minRowBytes64();
    } else {
        dstData = std::make_unique<uint8_t[]>(width * height * NUM_3);
        imageData.dst = dstData.get();
        if (pixelToSkInfo(imageData, skInfo, pixelMap, holder, encodeFormat_) != SUCCESS) {
            IMAGE_LOGE("ExtEncoder::EncodeImageByPixelMap pixel convert failed");
            return ERR_IMAGE_ENCODE_FAILED;
        }
        rowStride = skInfo.minRowBytes64();
#if !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
        if (pixelMap->GetAllocatorType() == AllocatorType::DMA_ALLOC) {
            SurfaceBuffer* sbBuffer = reinterpret_cast<SurfaceBuffer*> (pixelMap->GetFd());
            rowStride = static_cast<uint64_t>(sbBuffer->GetStride());
            IMAGE_LOGD("rowStride DMA: %{public}llu", static_cast<unsigned long long>(rowStride));
        }
#endif
    }
    if (!bitmap.installPixels(skInfo, imageData.pixels, rowStride)) {
        IMAGE_LOGE("ExtEncoder::EncodeImageByPixelMap to SkBitmap failed");
        return ERR_IMAGE_ENCODE_FAILED;
    }
    return EncodeImageByBitmap(bitmap, needExif, outputStream);
}

uint32_t ExtEncoder::EncodeHeifByPixelmap(PixelMap* pixelmap, const PlEncodeOptions& opts)
{
    if (output_ == nullptr) {
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    Media::PixelFormat format = pixelmap->GetPixelFormat();
    if (format != PixelFormat::RGBA_8888 && format != PixelFormat::NV12 && format != PixelFormat::NV21) {
        IMAGE_LOGE("EncodeHeifByPixelmap, invalid format:%{public}d", format);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
#if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM) && \
    defined(HEIF_HW_ENCODE_ENABLE)
    sptr<SurfaceBuffer> surfaceBuffer;
    bool needConvertToSurfaceBuffer = pixelmap->GetAllocatorType() != AllocatorType::DMA_ALLOC;
    if (needConvertToSurfaceBuffer) {
        surfaceBuffer = ConvertToSurfaceBuffer(pixelmap);
        if (surfaceBuffer == nullptr) {
            IMAGE_LOGE("EncodeHeifByPixelmap ConvertToSurfaceBuffer failed");
            return ERR_IMAGE_INVALID_PARAMETER;
        }
    } else {
        if (pixelmap->GetFd() == nullptr) {
            IMAGE_LOGE("EncodeHeifByPixelmap pixelmap get fd failed");
            return ERR_IMAGE_INVALID_PARAMETER;
        }
        surfaceBuffer = sptr<SurfaceBuffer>(reinterpret_cast<SurfaceBuffer*>(pixelmap->GetFd()));
    }
    std::vector<ImageItem> inputImgs;
    std::shared_ptr<ImageItem> primaryItem = AssemblePrimaryImageItem(surfaceBuffer, opts);
    if (primaryItem == nullptr) {
        if (needConvertToSurfaceBuffer) {
            ImageUtils::SurfaceBuffer_Unreference(surfaceBuffer.GetRefPtr());
        }
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    inputImgs.push_back(*primaryItem);
    std::vector<MetaItem> inputMetas;
    std::vector<ItemRef> refs;
    if (AssembleExifMetaItem(inputMetas)) {
        AssembleExifRefItem(refs);
    }
    uint32_t result = DoHeifEncode(inputImgs, inputMetas, refs);
    if (needConvertToSurfaceBuffer) {
        ImageUtils::SurfaceBuffer_Unreference(surfaceBuffer.GetRefPtr());
    }
    return result;
#endif
    return ERR_IMAGE_INVALID_PARAMETER;
}

void ExtEncoder::RecycleResources()
{
    for (std::shared_ptr<AbsMemory> &memory: tmpMemoryList_) {
        if (memory == nullptr) {
            continue;
        }
        memory->Release();
    }
    tmpMemoryList_.clear();
}

#if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
static sptr<SurfaceBuffer> AllocSurfaceBuffer(int32_t width, int32_t height,
    uint32_t format = GRAPHIC_PIXEL_FMT_RGBA_8888)
{
    sptr<SurfaceBuffer> sb = SurfaceBuffer::Create();
    BufferRequestConfig requestConfig = {
        .width = width,
        .height = height,
        .strideAlignment = 0x8,
        .format = format,
        .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA | BUFFER_USAGE_MEM_MMZ_CACHE,
        .timeout = 0,
    };
    GSError ret = sb->Alloc(requestConfig);
    if (ret != GSERROR_OK) {
        return nullptr;
    }
    void* nativeBuffer = sb.GetRefPtr();
    int32_t err = ImageUtils::SurfaceBuffer_Reference(nativeBuffer);
    if (err != OHOS::GSERROR_OK) {
        return nullptr;
    }
    return sb;
}

sptr<SurfaceBuffer> ExtEncoder::ConvertToSurfaceBuffer(PixelMap* pixelmap)
{
    if (pixelmap->GetHeight() <= 0 || pixelmap->GetWidth() <= 0) {
        IMAGE_LOGE("pixelmap height:%{public}d or width:%{public}d error", pixelmap->GetHeight(), pixelmap->GetWidth());
        return nullptr;
    }
    uint32_t height = static_cast<uint32_t>(pixelmap->GetHeight());
    uint32_t width = static_cast<uint32_t>(pixelmap->GetWidth());
    PixelFormat format = pixelmap->GetPixelFormat();
    IMAGE_LOGD("ExtEncoder::ConvertToSurfaceBuffer format is %{public}d", format);
    auto formatSearch = SURFACE_FORMAT_MAP.find(format);
    if (formatSearch == SURFACE_FORMAT_MAP.end()) {
        IMAGE_LOGE("format:[%{public}d] is not in SURFACE_FORMAT_MAP", format);
        return nullptr;
    }
    uint32_t graphicFormat = formatSearch->second;
    sptr<SurfaceBuffer> surfaceBuffer = AllocSurfaceBuffer(width, height, graphicFormat);
    if (surfaceBuffer == nullptr || surfaceBuffer->GetStride() < 0) {
        IMAGE_LOGE("ConvertToSurfaceBuffer surfaceBuffer is nullptr failed");
        return nullptr;
    }
    uint32_t dstStride = static_cast<uint32_t>(surfaceBuffer->GetStride());
    uint8_t* src = const_cast<uint8_t*>(pixelmap->GetPixels());
    uint8_t* dst = static_cast<uint8_t*>(surfaceBuffer->GetVirAddr());
    uint32_t dstSize = surfaceBuffer->GetSize();
    uint32_t copyHeight = height;
    uint64_t srcStride = width;
    if (format == PixelFormat::NV12 || format == PixelFormat::NV21) {
        const int32_t NUM_2 = 2;
        copyHeight = height + height / NUM_2;
        srcStride = width;
    } else if (format == PixelFormat::RGBA_8888) {
        copyHeight = height;
        srcStride = static_cast<uint64_t>(width * NUM_4);
    }
    for (uint32_t i = 0; i < copyHeight; i++) {
        if (memcpy_s(dst, dstSize, src, srcStride) != EOK) {
            IMAGE_LOGE("ConvertToSurfaceBuffer memcpy failed");
            ImageUtils::SurfaceBuffer_Unreference(surfaceBuffer.GetRefPtr());
            return nullptr;
        }
        dst += dstStride;
        dstSize -= dstStride;
        src += srcStride;
    }
    return surfaceBuffer;
}

static void FreeBaseAndGainMapSurfaceBuffer(sptr<SurfaceBuffer>& base, sptr<SurfaceBuffer>& gainMap)
{
    ImageUtils::SurfaceBuffer_Unreference(base.GetRefPtr());
    ImageUtils::SurfaceBuffer_Unreference(gainMap.GetRefPtr());
}

static HdrMetadata GetHdrMetadata(sptr<SurfaceBuffer>& hdr, sptr<SurfaceBuffer>& gainmap)
{
    std::vector<uint8_t> dynamicMetadata = {};
    VpeUtils::GetSbDynamicMetadata(hdr, dynamicMetadata);
    std::vector<uint8_t> staticMetadata = {};
    VpeUtils::GetSbStaticMetadata(hdr, staticMetadata);
    HdrMetadata metadata = {
        .staticMetadata = staticMetadata,
        .dynamicMetadata = dynamicMetadata
    };
    std::vector<uint8_t> extendMetadataVec = {};
    VpeUtils::GetSbDynamicMetadata(gainmap, extendMetadataVec);
    if (extendMetadataVec.size() != sizeof(HDRVividExtendMetadata)) {
        metadata.extendMetaFlag = false;
        return metadata;
    }
    if (memcpy_s(&metadata.extendMeta, sizeof(HDRVividExtendMetadata),
        extendMetadataVec.data(), extendMetadataVec.size()) != EOK) {
        metadata.extendMetaFlag = false;
    } else {
        metadata.extendMetaFlag = true;
    }
    return metadata;
}

uint32_t ExtEncoder::EncodeImageBySurfaceBuffer(sptr<SurfaceBuffer>& surfaceBuffer, SkImageInfo info,
    bool needExif, SkWStream& outputStream)
{
    SkBitmap bitmap;
    ImageInfo imageInfo;
    uint64_t rowStride = 0;
    if (surfaceBuffer == nullptr) {
        IMAGE_LOGE("EncodeImageBySurfaceBuffer failed, surfaceBuffer is nullptr");
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    auto pixels = surfaceBuffer->GetVirAddr();
    if (pixels == nullptr) {
        IMAGE_LOGE("EncodeImageBySurfaceBuffer failed, pixels is nullptr");
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    /* do hardwareEncode first, if fail then soft encode*/
    if (HardwareEncode(outputStream, needExif)) {
        IMAGE_LOGD("HardwareEncode Success return");
        return SUCCESS;
    }
    IMAGE_LOGD("HardwareEncode failed or not Supported");

    pixelmap_->GetImageInfo(imageInfo);
    std::unique_ptr<uint8_t[]> dstData;
    if (IsYuvImage(imageInfo.pixelFormat)) {
        IMAGE_LOGD("EncodeImageBySurfaceBuffer: YUV format, convert to RGB first");
        dstData = std::make_unique<uint8_t[]>(imageInfo.size.width * imageInfo.size.height * NUM_4);
        if (dstData == nullptr) {
            IMAGE_LOGE("Memory allocate fail");
            return ERR_IMAGE_ENCODE_FAILED;
        }
        if (YuvToRgbaSkInfo(imageInfo, info, dstData.get(), pixelmap_) != SUCCESS) {
            IMAGE_LOGD("YUV format, convert to RGB fail");
            return ERR_IMAGE_ENCODE_FAILED;
        }
        pixels = dstData.get();
        rowStride = info.minRowBytes64();
    } else {
        rowStride = surfaceBuffer->GetStride();
    }

    if (!bitmap.installPixels(info, pixels, rowStride)) {
        IMAGE_LOGE("ExtEncoder::EncodeImageBySurfaceBuffer to SkBitmap failed");
        return ERR_IMAGE_ENCODE_FAILED;
    }
    return EncodeImageByBitmap(bitmap, needExif, outputStream);
}

sk_sp<SkData> ExtEncoder::GetImageEncodeData(sptr<SurfaceBuffer>& surfaceBuffer, SkImageInfo info, bool needExif)
{
    SkDynamicMemoryWStream stream;
    if (EncodeImageBySurfaceBuffer(surfaceBuffer, info, needExif, stream) != SUCCESS) {
        return nullptr;
    }
    return stream.detachAsData();
}

static bool DecomposeImage(VpeSurfaceBuffers& buffers, HdrMetadata& metadata, bool onlySdr, bool sdrIsSRGB = false)
{
    VpeUtils::SetSbMetadataType(buffers.sdr, CM_IMAGE_HDR_VIVID_DUAL);
    VpeUtils::SetSbColorSpaceType(buffers.sdr, sdrIsSRGB ? CM_SRGB_FULL : CM_P3_FULL);
    std::unique_ptr<VpeUtils> utils = std::make_unique<VpeUtils>();
    int32_t res;
    if (onlySdr) {
        if (buffers.hdr == nullptr || buffers.sdr == nullptr) {
            return false;
        }
        res = utils->ColorSpaceConverterImageProcess(buffers.hdr, buffers.sdr);
    } else {
        VpeUtils::SetSbMetadataType(buffers.gainmap, CM_METADATA_NONE);
        VpeUtils::SetSbColorSpaceType(buffers.gainmap, sdrIsSRGB ? CM_SRGB_FULL : CM_P3_FULL);
        res = utils->ColorSpaceConverterDecomposeImage(buffers);
    }
    if (res != VPE_ERROR_OK) {
        IMAGE_LOGE("DecomposeImage [%{public}d] failed, res = %{public}d", onlySdr, res);
        return false;
    }
    if (!onlySdr) {
        metadata = GetHdrMetadata(buffers.hdr, buffers.gainmap);
    }
    return true;
}

static SkImageInfo GetSkInfo(PixelMap* pixelMap, bool isGainmap, bool isSRGB = false)
{
    ImageInfo info;
    pixelMap->GetImageInfo(info);
    SkColorType colorType = kRGBA_8888_SkColorType;
    SkAlphaType alphaType = ImageTypeConverter::ToSkAlphaType(info.alphaType);
    sk_sp<SkColorSpace> colorSpace =
        SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, isSRGB ? SkNamedGamut::kSRGB : SkNamedGamut::kDisplayP3);
    int32_t width = info.size.width;
    int32_t height = info.size.height;
    if (isGainmap) {
        const int halfSizeDenominator = 2;
        width = width / halfSizeDenominator;
        height = height / halfSizeDenominator;
#ifdef IMAGE_COLORSPACE_FLAG
        if (pixelMap->InnerGetGrColorSpacePtr() != nullptr &&
            pixelMap->InnerGetGrColorSpace().GetColorSpaceName() != ColorManager::ColorSpaceName::NONE) {
            colorSpace = pixelMap->InnerGetGrColorSpacePtr()->ToSkColorSpace();
        }
        skcms_CICP cicp;
        ColorUtils::ColorSpaceGetCicp(pixelMap->InnerGetGrColorSpace().GetColorSpaceName(),
            cicp.colour_primaries, cicp.transfer_characteristics, cicp.matrix_coefficients, cicp.full_range_flag);
        colorSpace->SetIccCicp(cicp);
#endif
    }
    return SkImageInfo::Make(width, height, colorType, alphaType, colorSpace);
}

uint32_t ExtEncoder::EncodeSingleVivid(ExtWStream& outputStream)
{
    return ERR_IMAGE_INVALID_PARAMETER;
}

#ifdef HEIF_HW_ENCODE_ENABLE
// format: enum + struct
static bool FillLitePropertyItem(std::vector<uint8_t>& properties, size_t& offset, PropertyType type,
    const void* payloadData, size_t payloadSize)
{
    uint8_t* memData = properties.data();
    if (memData == nullptr) {
        IMAGE_LOGE("FillLitePropertyItem memData is nullptr");
        return false;
    }
    size_t memSize = properties.size();
    size_t typeSize = sizeof(type);
    size_t endOffset = offset + typeSize + payloadSize;
    if (endOffset > memSize) {
        IMAGE_LOGE("FillLitePropertyItem, endOffset[%{public}ld] over memSize[%{public}ld]", endOffset, memSize);
        return false;
    }
    bool res = memcpy_s(memData + offset, memSize - offset, &type, typeSize) == EOK &&
        memcpy_s(memData + offset + typeSize, memSize - offset - typeSize, payloadData, payloadSize) == EOK;
    if (res) {
        offset = endOffset;
    }
    return res;
}

// format: enum + strlen + str
static bool FillLitePropertyItemByString(std::vector<uint8_t>& properties, size_t& offset, PropertyType type,
    std::string& payloadString)
{
    uint8_t* memData = properties.data();
    if (memData == nullptr) {
        IMAGE_LOGE("%{public}s memData is nullptr", __func__);
        return false;
    }
    size_t memSize = properties.size();
    if (payloadString == "") {
        IMAGE_LOGE("%{public}s failed, payloadString is Null", __func__);
        return false;
    }
    size_t lenSize = UINT32_BYTES_NUM;
    size_t strLen = payloadString.length();
    size_t typeSize = sizeof(type);
    size_t endOffset = offset + typeSize + lenSize + strLen;
    if (endOffset >= memSize) {
        IMAGE_LOGE("%{public}s failed, offset[%{public}ld] over memSize[%{public}ld]", __func__, offset, memSize);
        return false;
    }
    size_t capacitySize = memSize - offset;
    const char* payloadData = payloadString.data();
    if (memcpy_s(memData + offset, capacitySize, &type, typeSize) != EOK || memcpy_s(memData + offset + typeSize,
        capacitySize - typeSize, &strLen, lenSize) != EOK || memcpy_s(memData + offset + typeSize + lenSize,
        capacitySize - typeSize - lenSize, payloadData, strLen) != EOK) {
        IMAGE_LOGE("%{public}s copy failed, offset[%{public}ld] over memSize[%{public}d]", __func__, offset, memSize);
        return false;
    }

    properties[endOffset] = '\0';
    offset = endOffset + PLACE_HOLDER_LENGTH;
    return true;
}

std::shared_ptr<ImageItem> ExtEncoder::AssembleHdrBaseImageItem(sptr<SurfaceBuffer>& surfaceBuffer,
    ColorManager::ColorSpaceName color, HdrMetadata& metadata, const PlEncodeOptions& opts)
{
    if (surfaceBuffer == nullptr) {
        IMAGE_LOGI("AssembleHdrBaseImageItem surfaceBuffer is nullptr");
        return nullptr;
    }
    auto item = std::make_shared<ImageItem>();
    item->id = PRIMARY_IMAGE_ITEM_ID;
    item->isPrimary = true;
    item->isHidden = false;
    item->compressType = COMPRESS_TYPE_HEVC;
    item->quality = opts.quality;
    item->pixelBuffer = sptr<NativeBuffer>::MakeSptr(surfaceBuffer->GetBufferHandle());
    item->sharedProperties.fd = -1;
    item->pixelSharedBuffer.fd = -1;
    ColourInfo colorInfo;
    GetColourInfo(color, colorInfo);
    ContentLightLevel light;
    MasteringDisplayColourVolume colour;
    bool hasLight = GetStaticMetadata(metadata, colour, light);
    uint32_t propertiesSize = 0;
    propertiesSize +=
        (sizeof(PropertyType::COLOR_TYPE) + sizeof(ColorType) + sizeof(PropertyType::COLOR_INFO) + sizeof(ColourInfo));
    if (hasLight) {
        propertiesSize += (sizeof(PropertyType::CONTENT_LIGHT_LEVEL) + sizeof(ContentLightLevel));
    }
    item->liteProperties.resize(propertiesSize);
    size_t offset = 0;
    if (!FillNclxColorProperty(item, offset, colorInfo)) {
        return nullptr;
    }
    if (hasLight && (!FillLitePropertyItem(item->liteProperties, offset,
        PropertyType::CONTENT_LIGHT_LEVEL, &colour, sizeof(ContentLightLevel)))) {
        return nullptr;
    }
    return item;
}

std::shared_ptr<ImageItem> ExtEncoder::AssembleGainmapImageItem(sptr<SurfaceBuffer>& surfaceBuffer,
    ColorManager::ColorSpaceName color, const PlEncodeOptions &opts)
{
    if (surfaceBuffer == nullptr) {
        IMAGE_LOGI("AssembleGainmapImageItem surfacebuffer is nullptr");
        return nullptr;
    }
    auto item = std::make_shared<ImageItem>();
    item->id = GAINMAP_IMAGE_ITEM_ID;
    item->itemName = GAINMAP_IMAGE_ITEM_NAME;
    item->isPrimary = false;
    item->isHidden = true;
    item->compressType = COMPRESS_TYPE_HEVC;
    item->quality = opts.quality;
    item->sharedProperties.fd = -1;
    item->pixelSharedBuffer.fd = -1;
    item->pixelBuffer = sptr<NativeBuffer>::MakeSptr(surfaceBuffer->GetBufferHandle());
    ColourInfo colorInfo;
    GetColourInfo(color, colorInfo);
    uint32_t propertiesSize = 0;
    propertiesSize +=
        (sizeof(PropertyType::COLOR_TYPE) + sizeof(ColorType) + sizeof(PropertyType::COLOR_INFO) + sizeof(ColourInfo));
    item->liteProperties.resize(propertiesSize);
    size_t offset = 0;
    if (!FillNclxColorProperty(item, offset, colorInfo)) {
        return nullptr;
    }
    return item;
}

uint32_t ExtEncoder::AssembleHeifHdrPicture(
    sptr<SurfaceBuffer>& mainSptr, bool sdrIsSRGB, std::vector<ImageItem>& inputImgs)
{
    auto gainPixelMap = picture_->GetGainmapPixelMap();
    if (gainPixelMap == nullptr || gainPixelMap->GetAllocatorType() != AllocatorType::DMA_ALLOC) {
        IMAGE_LOGE("%{public}s, the gainPixelMap is nullptr or gainPixelMap is nonDMA", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    sptr<SurfaceBuffer> gainMapSptr(reinterpret_cast<SurfaceBuffer*>(gainPixelMap->GetFd()));
    HdrMetadata metadata = GetHdrMetadata(mainSptr, gainMapSptr);

    ColorManager::ColorSpaceName colorspaceName =
        sdrIsSRGB ? ColorManager::ColorSpaceName::SRGB : ColorManager::ColorSpaceName::DISPLAY_P3;
    std::shared_ptr<ImageItem> primaryItem = AssembleHdrBaseImageItem(mainSptr, colorspaceName, metadata, opts_);
    if (primaryItem == nullptr) {
        IMAGE_LOGE("%{public}s, get primary image failed", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    inputImgs.push_back(*primaryItem);
    std::shared_ptr<ImageItem> gainmapItem = AssembleGainmapImageItem(gainMapSptr, colorspaceName, opts_);
    if (gainmapItem == nullptr) {
        IMAGE_LOGE("%{public}s, get gainmap image item failed", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    inputImgs.push_back(*gainmapItem);
    ColorManager::ColorSpaceName tmapColor = picture_->GetMainPixel()->InnerGetGrColorSpace().GetColorSpaceName();
    std::shared_ptr<ImageItem> tmapItem = AssembleTmapImageItem(tmapColor, metadata, opts_);
    if (tmapItem == nullptr) {
        IMAGE_LOGE("%{public}s, get tmap image item failed", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    inputImgs.push_back(*tmapItem);
    return SUCCESS;
}

uint32_t ExtEncoder::AssembleSdrImageItem(
    sptr<SurfaceBuffer>& surfaceBuffer, SkImageInfo sdrInfo, std::vector<ImageItem>& inputImgs)
{
    if (surfaceBuffer == nullptr) {
        IMAGE_LOGI("%{public}s surfaceBuffer is nullptr", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    ImageItem item;
    sk_sp<SkData> iccProfile = icc_from_color_space(sdrInfo);
    if (!AssembleICCImageProperty(iccProfile, item.sharedProperties)) {
        IMAGE_LOGE("%{public}s AssembleICCImageProperty failed", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    item.id = PRIMARY_IMAGE_ITEM_ID;
    item.pixelBuffer = sptr<NativeBuffer>::MakeSptr(surfaceBuffer->GetBufferHandle());
    item.isPrimary = true;
    item.isHidden = false;
    item.compressType = COMPRESS_TYPE_HEVC;
    item.quality = opts_.quality;
    uint32_t litePropertiesSize = (sizeof(PropertyType::COLOR_TYPE) + sizeof(ColorType));
    item.liteProperties.resize(litePropertiesSize);
    size_t offset = 0;
    ColorType colorType = ColorType::RICC;
    if (!FillLitePropertyItem(item.liteProperties, offset, PropertyType::COLOR_TYPE, &colorType, sizeof(ColorType))) {
        IMAGE_LOGE("%{public}s Fill color type failed", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    inputImgs.push_back(item);
    return SUCCESS;
}

uint32_t ExtEncoder::AssembleHeifAuxiliaryPicture(std::vector<ImageItem>& inputImgs, std::vector<ItemRef>& refs)
{
    if (!picture_) {
        IMAGE_LOGE("picture_ is nullptr");
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    if (picture_->HasAuxiliaryPicture(AuxiliaryPictureType::DEPTH_MAP)) {
        if (AssembleHeifAuxiliaryNoncodingMap(inputImgs, AuxiliaryPictureType::DEPTH_MAP) == SUCCESS) {
            AssembleAuxiliaryRefItem(AuxiliaryPictureType::DEPTH_MAP, refs);
        } else {
            IMAGE_LOGE("%{public}s depthMap assemble fail", __func__);
        }
    }
    if (picture_->HasAuxiliaryPicture(AuxiliaryPictureType::UNREFOCUS_MAP)) {
        if (AssembleHeifUnrefocusMap(inputImgs) == SUCCESS) {
            AssembleAuxiliaryRefItem(AuxiliaryPictureType::UNREFOCUS_MAP, refs);
        } else {
            IMAGE_LOGE("%{public}s unrefocusMap assemble fail", __func__);
        }
    }
    if (picture_->HasAuxiliaryPicture(AuxiliaryPictureType::LINEAR_MAP)) {
        if (AssembleHeifAuxiliaryNoncodingMap(inputImgs, AuxiliaryPictureType::LINEAR_MAP) == SUCCESS) {
            AssembleAuxiliaryRefItem(AuxiliaryPictureType::LINEAR_MAP, refs);
        } else {
            IMAGE_LOGE("%{public}s linearMap assemble fail", __func__);
        }
    }
    if (picture_->HasAuxiliaryPicture(AuxiliaryPictureType::FRAGMENT_MAP)) {
        if (AssembleHeifFragmentMap(inputImgs) == SUCCESS) {
            AssembleAuxiliaryRefItem(AuxiliaryPictureType::FRAGMENT_MAP, refs);
        } else {
            IMAGE_LOGE("%{public}s fragmentMap assemble fail", __func__);
        }
    }
    return SUCCESS;
}

ImageItem ExtEncoder::InitAuxiliaryImageItem(uint32_t id, std::string itemName)
{
    ImageItem item;
    item.id = id;
    item.itemName = itemName;
    item.isPrimary = false;
    item.isHidden = true;
    item.quality = opts_.quality;
    item.sharedProperties.fd = -1;
    item.pixelSharedBuffer.fd = -1;
    if (id == DEPTH_MAP_ITEM_ID || id == LINEAR_MAP_ITEM_ID) {
        item.compressType = COMPRESS_TYPE_NONE;
    } else {
        item.compressType = COMPRESS_TYPE_HEVC;
    }
    return item;
}

HeifEncodeItemInfo GetHeifEncodeItemInfo(AuxiliaryPictureType auxType)
{
    HeifEncodeItemInfo itemInfo;
    switch (auxType) {
        case AuxiliaryPictureType::GAINMAP:
            itemInfo.itemId = GAINMAP_IMAGE_ITEM_ID;
            itemInfo.itemName = GAINMAP_IMAGE_ITEM_NAME;
            itemInfo.itemType = HEIF_AUXTTYPE_ID_GAINMAP;
            break;
        case AuxiliaryPictureType::DEPTH_MAP:
            itemInfo.itemId = DEPTH_MAP_ITEM_ID;
            itemInfo.itemName = DEPTH_MAP_ITEM_NAME;
            itemInfo.itemType = HEIF_AUXTTYPE_ID_DEPTH_MAP;
            break;
        case AuxiliaryPictureType::UNREFOCUS_MAP:
            itemInfo.itemId = UNREFOCUS_MAP_ITEM_ID;
            itemInfo.itemName = UNREFOCUS_MAP_ITEM_NAME;
            itemInfo.itemType = HEIF_AUXTTYPE_ID_UNREFOCUS_MAP;
            break;
        case AuxiliaryPictureType::LINEAR_MAP:
            itemInfo.itemId = LINEAR_MAP_ITEM_ID;
            itemInfo.itemName = LINEAR_MAP_ITEM_NAME;
            itemInfo.itemType = HEIF_AUXTTYPE_ID_LINEAR_MAP;
            break;
        case AuxiliaryPictureType::FRAGMENT_MAP:
            itemInfo.itemId = FRAGMENT_MAP_ITEM_ID;
            itemInfo.itemName = FRAGMENT_MAP_ITEM_NAME;
            itemInfo.itemType = HEIF_AUXTTYPE_ID_FRAGMENT_MAP;
            break;
        default:
            break;
    }
    return itemInfo;
}

uint32_t ExtEncoder::AssembleHeifAuxiliaryNoncodingMap(std::vector<ImageItem>& inputImgs, AuxiliaryPictureType auxType)
{
    auto auxMap = picture_->GetAuxiliaryPicture(auxType);
    if (!auxMap || !auxMap->GetContentPixel() ||
        auxMap->GetContentPixel()->GetAllocatorType() != AllocatorType::DMA_ALLOC) {
        IMAGE_LOGE("%{public}s The auxMap is nullptr or allocator type is not DMA_ALLOC", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    sptr<SurfaceBuffer> auxMapSptr(reinterpret_cast<SurfaceBuffer*>(auxMap->GetContentPixel()->GetFd()));
    if (!auxMapSptr) {
        IMAGE_LOGE("%{public}s auxMapSptr is nullptr", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }

    HeifEncodeItemInfo itemInfo = GetHeifEncodeItemInfo(auxType);
    auto item = InitAuxiliaryImageItem(itemInfo.itemId, itemInfo.itemName);
    std::string auxTypeStr = itemInfo.itemType;
    Resolution resolution = {
        auxMap->GetContentPixel()->GetWidth(),
        auxMap->GetContentPixel()->GetHeight()
    };
    uint32_t litePropertiesSize =
        sizeof(PropertyType::AUX_TYPE) + UINT32_BYTES_NUM + auxTypeStr.length() + PLACE_HOLDER_LENGTH;
    litePropertiesSize += (sizeof(PropertyType::IMG_RESOLUTION) + sizeof(Resolution));
    size_t offset = 0;
    item.liteProperties.resize(litePropertiesSize);
    if (!FillLitePropertyItemByString(item.liteProperties, offset, PropertyType::AUX_TYPE, auxTypeStr)) {
        IMAGE_LOGE("%{public}s Fill auxiliary type failed", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    if (!FillLitePropertyItem(item.liteProperties, offset, PropertyType::IMG_RESOLUTION, &resolution,
        sizeof(Resolution))) {
        IMAGE_LOGE("%{public}s Fill color type failed", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    uint32_t capacity = auxMap->GetContentPixel()->GetCapacity();
    if (!FillPixelSharedBuffer(auxMapSptr, capacity, item.pixelSharedBuffer)) {
        IMAGE_LOGE("%{public}s Fill pixel shared buffer failed", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    inputImgs.push_back(item);
    return SUCCESS;
}

uint32_t ExtEncoder::AssembleHeifUnrefocusMap(std::vector<ImageItem>& inputImgs)
{
    auto unrefocusMap = picture_->GetAuxiliaryPicture(AuxiliaryPictureType::UNREFOCUS_MAP);
    if (!unrefocusMap || !unrefocusMap->GetContentPixel() ||
        unrefocusMap->GetContentPixel()->GetAllocatorType() != AllocatorType::DMA_ALLOC) {
        IMAGE_LOGE("%{public}s The unrefocusMap is nullptr or allocator type is not DMA_ALLOC", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    HeifEncodeItemInfo itemInfo = GetHeifEncodeItemInfo(AuxiliaryPictureType::UNREFOCUS_MAP);
    auto item = InitAuxiliaryImageItem(itemInfo.itemId, itemInfo.itemName);
    bool sdrIsSRGB = unrefocusMap->GetContentPixel()->GetToSdrColorSpaceIsSRGB();
    SkImageInfo unrefocusInfo = GetSkInfo(unrefocusMap->GetContentPixel().get(), false, sdrIsSRGB);
    sk_sp<SkData> iccProfile = icc_from_color_space(unrefocusInfo);
    if (!AssembleICCImageProperty(iccProfile, item.sharedProperties)) {
        IMAGE_LOGE("%{public}s AssembleICCImageProperty failed", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    sptr<SurfaceBuffer> unrefocusMapSptr(reinterpret_cast<SurfaceBuffer*>(unrefocusMap->GetContentPixel()->GetFd()));
    if (!unrefocusMapSptr) {
        IMAGE_LOGE("%{public}s unrefocusMapSptr is nullptr", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    item.pixelBuffer = sptr<NativeBuffer>::MakeSptr(unrefocusMapSptr->GetBufferHandle());
    std::string auxTypeStr = itemInfo.itemType;

    uint32_t litePropertiesSize =
        sizeof(PropertyType::AUX_TYPE) + UINT32_BYTES_NUM + auxTypeStr.length() + PLACE_HOLDER_LENGTH;
    litePropertiesSize += (sizeof(PropertyType::COLOR_TYPE) + sizeof(ColorType));
    item.liteProperties.resize(litePropertiesSize);
    size_t offset = 0;
    if (!FillLitePropertyItemByString(item.liteProperties, offset, PropertyType::AUX_TYPE, auxTypeStr)) {
        IMAGE_LOGE("%{public}s Fill auxiliary type failed", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    ColorType colorType = ColorType::RICC;
    if (!FillLitePropertyItem(item.liteProperties, offset, PropertyType::COLOR_TYPE, &colorType, sizeof(ColorType))) {
        IMAGE_LOGE("%{public}s Fill color type failed", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    inputImgs.push_back(item);
    return SUCCESS;
}

RelativeLocation GetFragmentRelLocation(std::shared_ptr<AuxiliaryPicture> &fragmentMap)
{
    RelativeLocation loc;
    auto fragmentMeta = fragmentMap->GetMetadata(MetadataType::FRAGMENT);
    if (fragmentMeta == nullptr) {
        IMAGE_LOGE("The fragmentMap has not fragmentMap");
        return loc;
    }
    std::string loc_x = "";
    std::string loc_y = "";
    uint32_t horizontalOffset = 0;
    uint32_t verticalOffset = 0;
    fragmentMeta->GetValue(FRAGMENT_METADATA_KEY_X, loc_x);
    fragmentMeta->GetValue(FRAGMENT_METADATA_KEY_Y, loc_y);
    ImageUtils::StrToUint32(loc_x, horizontalOffset);
    ImageUtils::StrToUint32(loc_y, verticalOffset);
    loc.horizontalOffset = horizontalOffset;
    loc.verticalOffset = verticalOffset;
    return loc;
}

uint32_t ExtEncoder::AssembleHeifFragmentMap(std::vector<ImageItem>& inputImgs)
{
    auto fragmentMap = picture_->GetAuxiliaryPicture(AuxiliaryPictureType::FRAGMENT_MAP);
    if (!fragmentMap || !fragmentMap->GetContentPixel() ||
        fragmentMap->GetContentPixel()->GetAllocatorType() != AllocatorType::DMA_ALLOC) {
        IMAGE_LOGE("%{public}s The fragmentMap is nullptr or allocator type is not DMA_ALLOC", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    sptr<SurfaceBuffer> fragmentMapSptr(reinterpret_cast<SurfaceBuffer*>(fragmentMap->GetContentPixel()->GetFd()));
    if (!fragmentMapSptr) {
        IMAGE_LOGE("%{public}s fragmentMapSptr is nullptr", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    HeifEncodeItemInfo itemInfo = GetHeifEncodeItemInfo(AuxiliaryPictureType::FRAGMENT_MAP);
    auto item = InitAuxiliaryImageItem(itemInfo.itemId, itemInfo.itemName);
    bool sdrIsSRGB = fragmentMap->GetContentPixel()->GetToSdrColorSpaceIsSRGB();
    SkImageInfo fragmentInfo = GetSkInfo(fragmentMap->GetContentPixel().get(), false, sdrIsSRGB);
    sk_sp<SkData> iccProfile = icc_from_color_space(fragmentInfo);
    if (!AssembleICCImageProperty(iccProfile, item.sharedProperties)) {
        IMAGE_LOGE("%{public}s AssembleICCImageProperty failed", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    item.pixelBuffer = sptr<NativeBuffer>::MakeSptr(fragmentMapSptr->GetBufferHandle());
    std::string auxTypeStr = itemInfo.itemType;
    uint32_t litePropertiesSize =
        sizeof(PropertyType::AUX_TYPE) + UINT32_BYTES_NUM + auxTypeStr.length() + PLACE_HOLDER_LENGTH;
    litePropertiesSize += (sizeof(PropertyType::COLOR_TYPE) + sizeof(ColorType));
    litePropertiesSize += (sizeof(PropertyType::RLOC_INFO) + sizeof(RelativeLocation));
    item.liteProperties.resize(litePropertiesSize);
    size_t offset = 0;
    ColorType colorType = ColorType::RICC;
    if (!FillLitePropertyItem(item.liteProperties, offset, PropertyType::COLOR_TYPE, &colorType, sizeof(ColorType))) {
        IMAGE_LOGE("%{public}s Fill color type failed", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    if (!FillLitePropertyItemByString(item.liteProperties, offset, PropertyType::AUX_TYPE, auxTypeStr)) {
        IMAGE_LOGE("%{public}s Fill auxiliary type failed", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    RelativeLocation loc = GetFragmentRelLocation(fragmentMap);
    if (!FillLitePropertyItem(item.liteProperties, offset, PropertyType::RLOC_INFO, &loc, sizeof(RelativeLocation))) {
        IMAGE_LOGE("%{public}s Fill auxiliary type failed", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    inputImgs.push_back(item);
    return SUCCESS;
}
#endif

uint32_t ExtEncoder::EncodeDualVivid(ExtWStream& outputStream)
{
    IMAGE_LOGD("ExtEncoder::EncodeDualVivid");
    if (!pixelmap_->IsHdr() ||
        pixelmap_->GetAllocatorType() != AllocatorType::DMA_ALLOC ||
        (encodeFormat_ != SkEncodedImageFormat::kJPEG && encodeFormat_ != SkEncodedImageFormat::kHEIF)) {
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    bool sdrIsSRGB = pixelmap_->GetToSdrColorSpaceIsSRGB();
    SkImageInfo baseInfo = GetSkInfo(pixelmap_, false, sdrIsSRGB);
    SkImageInfo gainmapInfo = GetSkInfo(pixelmap_, true, sdrIsSRGB);
    sptr<SurfaceBuffer> baseSptr = AllocSurfaceBuffer(baseInfo.width(), baseInfo.height());
    sptr<SurfaceBuffer> gainMapSptr = AllocSurfaceBuffer(gainmapInfo.width(), gainmapInfo.height());
    if (baseSptr == nullptr || gainMapSptr == nullptr) {
        return IMAGE_RESULT_CREATE_SURFAC_FAILED;
    }
    HdrMetadata metadata;
    sptr<SurfaceBuffer> hdrSurfaceBuffer(reinterpret_cast<SurfaceBuffer*> (pixelmap_->GetFd()));
    CM_HDR_Metadata_Type hdrMetadataType;
    VpeUtils::GetSbMetadataType(hdrSurfaceBuffer, hdrMetadataType);
    VpeUtils::SetSbMetadataType(hdrSurfaceBuffer, CM_IMAGE_HDR_VIVID_SINGLE);
    VpeSurfaceBuffers buffers = {
        .sdr = baseSptr,
        .gainmap = gainMapSptr,
        .hdr = hdrSurfaceBuffer,
    };
    if (!DecomposeImage(buffers, metadata, false, sdrIsSRGB)) {
        IMAGE_LOGE("EncodeDualVivid decomposeImage failed");
        FreeBaseAndGainMapSurfaceBuffer(baseSptr, gainMapSptr);
        return IMAGE_RESULT_CREATE_SURFAC_FAILED;
    }
    metadata.hdrMetadataType = static_cast<int32_t>(hdrMetadataType);
    uint32_t error;
    if (encodeFormat_ == SkEncodedImageFormat::kJPEG) {
        sk_sp<SkData> baseImageData = GetImageEncodeData(baseSptr, baseInfo, opts_.needsPackProperties);
        sk_sp<SkData> gainMapImageData = GetImageEncodeData(gainMapSptr, gainmapInfo, false);
        error = HdrJpegPackerHelper::SpliceHdrStream(baseImageData, gainMapImageData, outputStream, metadata);
    } else if (encodeFormat_ == SkEncodedImageFormat::kHEIF) {
        error = EncodeHeifDualHdrImage(baseSptr, gainMapSptr, metadata);
    } else {
        error = ERR_IMAGE_INVALID_PARAMETER;
    }
    FreeBaseAndGainMapSurfaceBuffer(baseSptr, gainMapSptr);
    return error;
}

uint32_t ExtEncoder::EncodeSdrImage(ExtWStream& outputStream)
{
    IMAGE_LOGD("ExtEncoder EncodeSdrImage");
    if (!pixelmap_->IsHdr()) {
        return EncodeImageByPixelMap(pixelmap_, opts_.needsPackProperties, outputStream);
    }
    if (pixelmap_->GetAllocatorType() != AllocatorType::DMA_ALLOC) {
        IMAGE_LOGE("pixelmap is 10bit, but not dma buffer");
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    ImageInfo info;
    pixelmap_->GetImageInfo(info);
    bool sdrIsSRGB = pixelmap_->GetToSdrColorSpaceIsSRGB();
    SkImageInfo baseInfo = GetSkInfo(pixelmap_, false, sdrIsSRGB);
    sptr<SurfaceBuffer> baseSptr = AllocSurfaceBuffer(baseInfo.width(), baseInfo.height());
    VpeUtils::SetSbMetadataType(baseSptr, CM_IMAGE_HDR_VIVID_DUAL);
    VpeUtils::SetSbColorSpaceType(baseSptr, CM_SRGB_FULL);
    if (baseSptr == nullptr) {
        IMAGE_LOGE("EncodeSdrImage sdr buffer alloc failed");
        return IMAGE_RESULT_CREATE_SURFAC_FAILED;
    }
    sptr<SurfaceBuffer> hdrSurfaceBuffer(reinterpret_cast<SurfaceBuffer*>(pixelmap_->GetFd()));
    VpeUtils::SetSbMetadataType(hdrSurfaceBuffer, CM_IMAGE_HDR_VIVID_SINGLE);
    VpeSurfaceBuffers buffers = {
        .sdr = baseSptr,
        .hdr = hdrSurfaceBuffer,
    };
    HdrMetadata metadata;
    if (!DecomposeImage(buffers, metadata, true, sdrIsSRGB)) {
        IMAGE_LOGE("EncodeSdrImage decomposeImage failed");
        ImageUtils::SurfaceBuffer_Unreference(baseSptr.GetRefPtr());
        return IMAGE_RESULT_CREATE_SURFAC_FAILED;
    }
    uint32_t error;
    if (encodeFormat_ == SkEncodedImageFormat::kHEIF) {
        error = EncodeHeifSdrImage(baseSptr, baseInfo);
    } else {
        error = EncodeImageBySurfaceBuffer(baseSptr, baseInfo, opts_.needsPackProperties, outputStream);
    }
    ImageUtils::SurfaceBuffer_Unreference(baseSptr.GetRefPtr());
    return error;
}

uint32_t ExtEncoder::EncodeHeifDualHdrImage(sptr<SurfaceBuffer>& sdr, sptr<SurfaceBuffer>& gainmap,
    Media::HdrMetadata& metadata, bool sdrIsSRGB)
{
#ifdef HEIF_HW_ENCODE_ENABLE
    std::vector<ImageItem> inputImgs;
    ColorSpaceManager colorspaceName =
        sdrIsSRGB ? ColorManager::ColorSpaceName::SRGB : ColorManager::ColorSpaceName::DISPLAY_P3;
    std::shared_ptr<ImageItem> primaryItem =
        AssembleHdrBaseImageItem(sdr, colorspaceName, metadata, opts_);
    if (primaryItem == nullptr) {
        IMAGE_LOGE("AssmbleHeifDualHdrImage, get primary image failed");
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    inputImgs.push_back(*primaryItem);
    std::shared_ptr<ImageItem> gainmapItem =
        AssembleGainmapImageItem(gainmap, colorspaceName, opts_);
    if (gainmapItem == nullptr) {
        IMAGE_LOGE("AssembleDualHdrImage, get gainmap image item failed");
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    inputImgs.push_back(*gainmapItem);
    ColorManager::ColorSpaceName tmapColor = pixelmap_->InnerGetGrColorSpace().GetColorSpaceName();
    std::shared_ptr<ImageItem> tmapItem = AssembleTmapImageItem(tmapColor, metadata, opts_);
    if (tmapItem == nullptr) {
        IMAGE_LOGE("AssembleDualHdrImage, get tmap image item failed");
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    inputImgs.push_back(*tmapItem);
    std::vector<MetaItem> inputMetas;
    std::vector<ItemRef> refs;
    if (AssembleExifMetaItem(inputMetas)) {
        AssembleExifRefItem(refs);
    }
    AssembleDualHdrRefItem(refs);
    return DoHeifEncode(inputImgs, inputMetas, refs);
#else
    return ERR_IMAGE_INVALID_PARAMETER;
#endif
}

uint32_t ExtEncoder::EncodeHeifSdrImage(sptr<SurfaceBuffer>& sdr, SkImageInfo sdrInfo)
{
#ifdef HEIF_HW_ENCODE_ENABLE
    if (sdr == nullptr) {
        IMAGE_LOGE("EncodeHeifSdrImage, sdr surfacebuffer is nullptr");
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    ImageItem item;
    item.id = PRIMARY_IMAGE_ITEM_ID;
    item.pixelBuffer = sptr<NativeBuffer>::MakeSptr(sdr->GetBufferHandle());
    item.isPrimary = true;
    item.isHidden = false;
    item.compressType = COMPRESS_TYPE_HEVC;
    item.quality = opts_.quality;
    item.sharedProperties.fd = -1;
    item.pixelSharedBuffer.fd = -1;
    ImageInfo info;
    pixelmap_->GetImageInfo(info);
    sk_sp<SkData> iccProfile = icc_from_color_space(sdrInfo);
    bool tempRes = AssembleICCImageProperty(iccProfile, item.sharedProperties);
    if (!tempRes) {
        IMAGE_LOGE("EncodeSdrImage AssembleICCImageProperty failed");
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    uint32_t litePropertiesSize = (sizeof(PropertyType::COLOR_TYPE) + sizeof(ColorType));
    item.liteProperties.resize(litePropertiesSize);
    size_t offset = 0;
    ColorType colorType = ColorType::RICC;
    if (!FillLitePropertyItem(item.liteProperties, offset, PropertyType::COLOR_TYPE, &colorType, sizeof(ColorType))) {
        IMAGE_LOGE("EncodeHeifSdrImage Fill color type failed");
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    std::vector<ImageItem> inputImgs;
    inputImgs.push_back(item);
    std::vector<MetaItem> inputMetas;
    std::vector<ItemRef> refs;
    if (AssembleExifMetaItem(inputMetas)) {
        AssembleExifRefItem(refs);
    }
    return DoHeifEncode(inputImgs, inputMetas, refs);
#else
    return ERR_IMAGE_INVALID_PARAMETER;
#endif
}

uint32_t ExtEncoder::EncodePicture()
{
    if ((encodeFormat_ != SkEncodedImageFormat::kJPEG && encodeFormat_ != SkEncodedImageFormat::kHEIF)) {
        IMAGE_LOGE("%{public}s: unsupported encode format: %{public}s", __func__, opts_.format.c_str());
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    if (opts_.isEditScene && encodeFormat_ == SkEncodedImageFormat::kHEIF) {
        return EncodeEditScenePicture();
    }
    if (encodeFormat_ == SkEncodedImageFormat::kJPEG) {
        CheckJpegAuxiliaryTagName();
    }
    ExtWStream wStream(output_);
    return EncodeCameraScenePicture(wStream);
}

uint32_t ExtEncoder::EncodeCameraScenePicture(SkWStream& skStream)
{
    uint32_t retCode = ERR_IMAGE_ENCODE_FAILED;
    std::string errorMsg = "Load hardware encode library failed";
    static ImageFwkExtManager imageFwkExtManager;
    if (imageFwkExtManager.LoadImageFwkExtNativeSo() && imageFwkExtManager.doHardwareEncodePictureFunc_ != nullptr) {
        retCode = imageFwkExtManager.doHardwareEncodePictureFunc_(&skStream, opts_, picture_);
        errorMsg = "Hardware encode picture failed";
    }
    if (retCode != SUCCESS && encodeFormat_ == SkEncodedImageFormat::kJPEG) {
        IMAGE_LOGE("%{public}s, retCode is: %{public}d, try jpeg software encode", errorMsg.c_str(), retCode);
        retCode = EncodeJpegPicture(skStream);
        errorMsg = "Jpeg software encode picture failed";
    }
    if (retCode != SUCCESS) {
        ImageInfo imageInfo;
        picture_->GetMainPixel()->GetImageInfo(imageInfo);
        IMAGE_LOGE("%{public}s, retCode is: %{public}d", errorMsg.c_str(), retCode);
        ReportEncodeFault(imageInfo.size.width, imageInfo.size.height, opts_.format, errorMsg);
    }
    return retCode;
}

uint32_t ExtEncoder::EncodeEditScenePicture()
{
    if (!picture_) {
        IMAGE_LOGE("picture_ is nullptr");
        return ERR_IMAGE_DATA_ABNORMAL;
    }
    auto mainPixelMap = picture_->GetMainPixel();
    if (!mainPixelMap || mainPixelMap->GetAllocatorType() != AllocatorType::DMA_ALLOC) {
        IMAGE_LOGE("MainPixelMap is nullptr or mainPixelMap is not DMA buffer");
        return ERR_IMAGE_DATA_ABNORMAL;
    }

    bool sdrIsSRGB = mainPixelMap->GetToSdrColorSpaceIsSRGB();
    SkImageInfo baseInfo = GetSkInfo(mainPixelMap.get(), false, false);
    sptr<SurfaceBuffer> baseSptr(reinterpret_cast<SurfaceBuffer*>(mainPixelMap->GetFd()));
    if (!baseSptr) {
        IMAGE_LOGE("creat main pixels surfaceBuffer error");
        return IMAGE_RESULT_CREATE_SURFAC_FAILED;
    }
    return EncodeHeifPicture(baseSptr, baseInfo, sdrIsSRGB);
}

uint32_t ExtEncoder::EncodeHeifPicture(sptr<SurfaceBuffer>& mainSptr, SkImageInfo mainInfo, bool sdrIsSRGB)
{
#ifdef HEIF_HW_ENCODE_ENABLE
    uint32_t error = SUCCESS;
    std::vector<ImageItem> inputImgs;
    std::vector<MetaItem> inputMetas;
    std::vector<ItemRef> refs;
    switch (opts_.desiredDynamicRange) {
        case EncodeDynamicRange::AUTO:
            if (picture_->HasAuxiliaryPicture(AuxiliaryPictureType::GAINMAP) &&
                AssembleHeifHdrPicture(mainSptr, sdrIsSRGB, inputImgs) == SUCCESS) {
                AssembleDualHdrRefItem(refs);
            } else {
                inputImgs.clear();
                error = AssembleSdrImageItem(mainSptr, mainInfo, inputImgs);
            }
            break;
        case EncodeDynamicRange::SDR:
            error = AssembleSdrImageItem(mainSptr, mainInfo, inputImgs);
            break;
        case EncodeDynamicRange::HDR_VIVID_DUAL:
            if (picture_->HasAuxiliaryPicture(AuxiliaryPictureType::GAINMAP)) {
                error = AssembleHeifHdrPicture(mainSptr, sdrIsSRGB, inputImgs);
                AssembleDualHdrRefItem(refs);
            } else {
                IMAGE_LOGE("Picture don't has GAINMAP pixels");
                error = ERR_IMAGE_ENCODE_FAILED;
            }
            break;
        case EncodeDynamicRange::HDR_VIVID_SINGLE:
            IMAGE_LOGE("Heif picture not support HDR_VIVID_SINGLE");
            return ERR_IMAGE_ENCODE_FAILED;
        default:
            return ERR_IMAGE_INVALID_PARAMETER;
    }
    if (error != SUCCESS) {
        return error;
    }
    if (AssembleExifMetaItem(inputMetas)) {
        AssembleExifRefItem(refs);
    }
    error = AssembleHeifAuxiliaryPicture(inputImgs, refs);
    if (error != SUCCESS) {
        return error;
    }
    return DoHeifEncode(inputImgs, inputMetas, refs);
#else
    return ERR_IMAGE_INVALID_PARAMETER;
#endif
}

void ExtEncoder::CheckJpegAuxiliaryTagName()
{
    if (picture_ == nullptr) {
        return;
    }
    auto auxTypes = ImageUtils::GetAllAuxiliaryPictureType();
    for (AuxiliaryPictureType auxType : auxTypes) {
        auto auxPicture = picture_->GetAuxiliaryPicture(auxType);
        if (auxPicture == nullptr) {
            continue;
        }
        AuxiliaryPictureInfo auxInfo = auxPicture->GetAuxiliaryPictureInfo();
        auto iter = DEFAULT_AUXILIARY_TAG_MAP.find(auxType);
        if (auxInfo.jpegTagName.size() == 0 && iter != DEFAULT_AUXILIARY_TAG_MAP.end()) {
            auxInfo.jpegTagName = iter->second;
            auxPicture->SetAuxiliaryPictureInfo(auxInfo);
        }
    }
}

uint32_t ExtEncoder::EncodeJpegPicture(SkWStream& skStream)
{
    uint32_t error = ERR_IMAGE_ENCODE_FAILED;
    switch (opts_.desiredDynamicRange) {
        case EncodeDynamicRange::AUTO:
            error = EncodeJpegPictureDualVivid(skStream);
            if (error != SUCCESS) {
                IMAGE_LOGI("%{public}s jpeg picture encode dual vivid failed, try encode sdr", __func__);
                error = EncodeJpegPictureSdr(skStream);
            }
            break;
        case EncodeDynamicRange::SDR:
            error = EncodeJpegPictureSdr(skStream);
            break;
        case EncodeDynamicRange::HDR_VIVID_DUAL:
            error = EncodeJpegPictureDualVivid(skStream);
            break;
        case EncodeDynamicRange::HDR_VIVID_SINGLE:
            error = ERR_IMAGE_DECODE_FAILED;
            break;
        default:
            error = ERR_IMAGE_INVALID_PARAMETER;
            break;
    }
    return error;
}

uint32_t ExtEncoder::EncodeJpegPictureDualVividInner(SkWStream& skStream, std::shared_ptr<PixelMap>& mainPixelmap,
    std::shared_ptr<PixelMap>& gainmapPixelmap)
{
    bool mainIsSRGB = mainPixelmap->GetToSdrColorSpaceIsSRGB();
    SkImageInfo baseInfo = GetSkInfo(mainPixelmap.get(), false, mainIsSRGB);
    sptr<SurfaceBuffer> baseSptr(reinterpret_cast<SurfaceBuffer*>(mainPixelmap->GetFd()));
    VpeUtils::SetSbMetadataType(baseSptr, CM_IMAGE_HDR_VIVID_DUAL);
    VpeUtils::SetSbColorSpaceType(baseSptr, mainIsSRGB ? CM_SRGB_FULL : CM_P3_FULL);
    pixelmap_ = mainPixelmap.get();
    sk_sp<SkData> baseImageData = GetImageEncodeData(baseSptr, baseInfo, opts_.needsPackProperties);

    bool gainmapIsSRGB = gainmapPixelmap->GetToSdrColorSpaceIsSRGB();
    SkImageInfo gainmapInfo = GetSkInfo(gainmapPixelmap.get(), true, gainmapIsSRGB);
    ImageInfo tempInfo;
    gainmapPixelmap->GetImageInfo(tempInfo);
    gainmapInfo = gainmapInfo.makeWH(tempInfo.size.width, tempInfo.size.height);
    sptr<SurfaceBuffer> gainMapSptr(reinterpret_cast<SurfaceBuffer*>(gainmapPixelmap->GetFd()));
    VpeUtils::SetSbMetadataType(gainMapSptr, CM_METADATA_NONE);
    VpeUtils::SetSbColorSpaceType(gainMapSptr, gainmapIsSRGB ? CM_SRGB_FULL : CM_P3_FULL);
    pixelmap_ = gainmapPixelmap.get();
    sk_sp<SkData> gainMapImageData = GetImageEncodeData(gainMapSptr, gainmapInfo, false);

    HdrMetadata hdrMetadata = GetHdrMetadata(baseSptr, gainMapSptr);
    SkDynamicMemoryWStream hdrStream;
    uint32_t error = HdrJpegPackerHelper::SpliceHdrStream(baseImageData, gainMapImageData, hdrStream, hdrMetadata);
    IMAGE_LOGD("%{public}s splice hdr stream result is: %{public}u", __func__, error);
    if (error == SUCCESS) {
        sk_sp<SkData> hdrSkData = hdrStream.detachAsData();
        skStream.write(hdrSkData->data(), hdrSkData->size());
        EncodeJpegAuxiliaryPictures(skStream);
    }
    return error;
}

uint32_t ExtEncoder::EncodeJpegPictureDualVivid(SkWStream& skStream)
{
    ImageFuncTimer imageFuncTimer("%s enter", __func__);
    if (!picture_->HasAuxiliaryPicture(AuxiliaryPictureType::GAINMAP)) {
        IMAGE_LOGE("%{public}s no gainmap in picture", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    auto mainPixelmap = picture_->GetMainPixel();
    auto gainmapPixelmap = picture_->GetGainmapPixelMap();
    if (!mainPixelmap || !gainmapPixelmap) {
        IMAGE_LOGE("%{public}s mainPixelmap or gainmapPixelmap is null", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    AllocatorType mainAllocType = mainPixelmap->GetAllocatorType();
    AllocatorType gainmapAllocType = gainmapPixelmap->GetAllocatorType();
    if (mainAllocType != AllocatorType::DMA_ALLOC || gainmapAllocType != AllocatorType::DMA_ALLOC) {
        IMAGE_LOGE("%{public}s AllocatorType is not DMA, mainAllocType: %{public}d, gainmapAllocType: %{public}d",
            __func__, mainAllocType, gainmapAllocType);
        return ERR_IMAGE_ENCODE_FAILED;
    }
    return EncodeJpegPictureDualVividInner(skStream, mainPixelmap, gainmapPixelmap);
}

uint32_t ExtEncoder::EncodeJpegPictureSdr(SkWStream& skStream)
{
    ImageFuncTimer imageFuncTimer("%s enter", __func__);
    auto mainPixelmap = picture_->GetMainPixel();
    if (!mainPixelmap) {
        IMAGE_LOGE("%{public}s mainPixelmap is null", __func__);
        return ERR_IMAGE_INVALID_PARAMETER;
    }
    pixelmap_ = mainPixelmap.get();
    uint32_t error = ERR_IMAGE_ENCODE_FAILED;
    if (!mainPixelmap->IsHdr()) {
        error = EncodeImageByPixelMap(mainPixelmap.get(), opts_.needsPackProperties, skStream);
        IMAGE_LOGD("%{public}s encode sdr picture result is: %{public}u", __func__, error);
    } else {
        if (mainPixelmap->GetAllocatorType() != AllocatorType::DMA_ALLOC) {
            IMAGE_LOGE("pixelmap is 10bit, but not dma buffer");
            return ERR_IMAGE_INVALID_PARAMETER;
        }
        bool mainIsSRGB = mainPixelmap->GetToSdrColorSpaceIsSRGB();
        SkImageInfo baseInfo = GetSkInfo(mainPixelmap.get(), false, mainIsSRGB);
        sptr<SurfaceBuffer> baseSptr(reinterpret_cast<SurfaceBuffer*>(mainPixelmap->GetFd()));
        VpeUtils::SetSbMetadataType(baseSptr, CM_IMAGE_HDR_VIVID_DUAL);
        VpeUtils::SetSbColorSpaceType(baseSptr, mainIsSRGB ? CM_SRGB_FULL : CM_P3_FULL);
        error = EncodeImageBySurfaceBuffer(baseSptr, baseInfo, opts_.needsPackProperties, skStream);
        IMAGE_LOGD("%{public}s encode hdr picture result is: %{public}u", __func__, error);
    }
    if (error == SUCCESS) {
        EncodeJpegAuxiliaryPictures(skStream);
    }
    return error;
}

static bool GetMetadataValueInt32(const std::shared_ptr<ImageMetadata>& metadata, const std::string& key,
    int32_t& outVal)
{
    std::string strVal("");
    uint32_t u32Val = 0;
    if (metadata == nullptr) {
        IMAGE_LOGE("%{public}s: metadata is nullptr!", __func__);
        return false;
    }
    if (metadata->GetValue(key, strVal) != SUCCESS || !ImageUtils::StrToUint32(strVal, u32Val)) {
        IMAGE_LOGE("%{public}s: get metadata key[%{public}s]'s value failed!", __func__, key.c_str());
        return false;
    }
    outVal = static_cast<int32_t>(u32Val);
    return true;
}

static bool CheckFragmentMetadata(Picture* picture, Media::Rect& outData)
{
    if (!picture || !picture->GetMainPixel() || !picture->HasAuxiliaryPicture(AuxiliaryPictureType::FRAGMENT_MAP)) {
        IMAGE_LOGE("%{public}s: picture or mainPixelMap or fragment picture does not exist!", __func__);
        return false;
    }
    int32_t mainW = picture->GetMainPixel()->GetWidth();
    int32_t mainH = picture->GetMainPixel()->GetHeight();

    auto fragmentPicture = picture->GetAuxiliaryPicture(AuxiliaryPictureType::FRAGMENT_MAP);
    auto fragmentMetadata = fragmentPicture->GetMetadata(MetadataType::FRAGMENT);
    if (fragmentMetadata == nullptr) {
        IMAGE_LOGE("%{public}s: fragmentMetadata is nullptr!", __func__);
        return false;
    }

    if (!GetMetadataValueInt32(fragmentMetadata, FRAGMENT_METADATA_KEY_X, outData.left) ||
        !GetMetadataValueInt32(fragmentMetadata, FRAGMENT_METADATA_KEY_Y, outData.top) ||
        !GetMetadataValueInt32(fragmentMetadata, FRAGMENT_METADATA_KEY_WIDTH, outData.width) ||
        !GetMetadataValueInt32(fragmentMetadata, FRAGMENT_METADATA_KEY_HEIGHT, outData.height)) {
        IMAGE_LOGE("%{public}s: GetMetadataValueInt32 failed!", __func__);
        return false;
    }
    if (!ImageUtils::IsInRange(outData.left, 0, mainW) || !ImageUtils::IsInRange(outData.top, 0, mainH) ||
        !ImageUtils::IsInRange(outData.width, 0, mainW) || !ImageUtils::IsInRange(outData.height, 0, mainH) ||
        !ImageUtils::IsInRange(outData.left + outData.width, 0, mainW) ||
        !ImageUtils::IsInRange(outData.top + outData.height, 0, mainH)) {
        IMAGE_LOGW("%{public}s: Fragment Rect is not in main Rect!", __func__);
        return false;
    }
    return true;
}

void ExtEncoder::EncodeJpegAuxiliaryPictures(SkWStream& skStream)
{
    ImageFuncTimer imageFuncTimer("%s enter", __func__);
    if (picture_ == nullptr) {
        return;
    }
    auto auxTypes = ImageUtils::GetAllAuxiliaryPictureType();
    for (AuxiliaryPictureType auxType : auxTypes) {
        auto auxPicture = picture_->GetAuxiliaryPicture(auxType);
        // Gainmap has been encoded before
        if (auxPicture == nullptr || auxType == AuxiliaryPictureType::GAINMAP) {
            continue;
        }
        IMAGE_LOGI("%{public}s try to encode auxiliary picture type: %{public}d", __func__, auxType);
        uint32_t error = ERR_IMAGE_ENCODE_FAILED;
        size_t writtenSize = skStream.bytesWritten();
        if (ImageUtils::IsAuxiliaryPictureEncoded(auxType)) {
            error = WriteJpegCodedData(auxPicture, skStream);
        } else {
            error = WriteJpegUncodedData(auxPicture, skStream);
        }
        if (error != SUCCESS) {
            IMAGE_LOGE("%{public}s encode auxiliary picture type [%{public}d] failed, error: %{public}u",
                __func__, auxType, error);
        } else {
            uint32_t currentDataSize = static_cast<uint32_t>(skStream.bytesWritten() - writtenSize);
            WriteJpegAuxiliarySizeAndTag(currentDataSize, auxPicture, skStream);
        }
    }
}

uint32_t ExtEncoder::WriteJpegCodedData(std::shared_ptr<AuxiliaryPicture>& auxPicture, SkWStream& skStream)
{
    if (auxPicture == nullptr || auxPicture->GetContentPixel() == nullptr) {
        return ERR_IMAGE_ENCODE_FAILED;
    }
    auto pixelMap = auxPicture->GetContentPixel();
    pixelmap_ = pixelMap.get();
    sk_sp<SkData> skData = nullptr;
    if (pixelMap->GetAllocatorType() != AllocatorType::DMA_ALLOC || pixelMap->GetFd() == nullptr) {
        SkDynamicMemoryWStream nonDMAStream;
        uint32_t error = EncodeImageByPixelMap(pixelmap_, false, nonDMAStream);
        IMAGE_LOGD("%{public}s EncodeImageByPixelMap result:%{public}u", __func__, error);
        skData = nonDMAStream.detachAsData();
    } else {
        sptr<SurfaceBuffer> auxSptr(reinterpret_cast<SurfaceBuffer*>(pixelMap->GetFd()));
        bool isSRGB = pixelMap->GetToSdrColorSpaceIsSRGB();
        SkImageInfo skInfo = GetSkInfo(pixelmap_, false, isSRGB);
        skData = GetImageEncodeData(auxSptr, skInfo, false);
    }

    if (skData == nullptr) {
        return ERR_IMAGE_ENCODE_FAILED;
    }
    if (auxPicture->GetType() == AuxiliaryPictureType::FRAGMENT_MAP) {
        return SpliceFragmentStream(skStream, skData);
    }
    skStream.write(skData->data(), skData->size());
    return SUCCESS;
}

uint32_t ExtEncoder::SpliceFragmentStream(SkWStream& skStream, sk_sp<SkData>& skData)
{
    Media::Rect fragmentMetadata;
    if (!CheckFragmentMetadata(picture_, fragmentMetadata)) {
        IMAGE_LOGE("%{public}s: CheckFragmentMetadata failed!", __func__);
        return ERR_IMAGE_PROPERTY_NOT_EXIST;
    }
    const uint8_t* dataBytes = reinterpret_cast<const uint8_t*>(skData->data());
    // write JPEG SOI(0xFFD8)
    skStream.write(dataBytes, JPEG_MARKER_TAG_SIZE);
    std::vector<uint8_t> packedFragmentMetadata = JpegMpfPacker::PackFragmentMetadata(fragmentMetadata);
    // write fragment metadata
    skStream.write(packedFragmentMetadata.data(), packedFragmentMetadata.size());
    // write fragment auxiliary image data
    skStream.write(dataBytes + JPEG_MARKER_TAG_SIZE, skData->size() - JPEG_MARKER_TAG_SIZE);
    return SUCCESS;
}

uint32_t ExtEncoder::WriteJpegUncodedData(std::shared_ptr<AuxiliaryPicture>& auxPicture, SkWStream& skStream)
{
    auto pixelMap = auxPicture->GetContentPixel();
    if (pixelMap == nullptr) {
        return ERR_IMAGE_DATA_ABNORMAL;
    }
    void* bytes = nullptr;
    uint32_t size = 0;
    Size imageSize;
    if (pixelMap->GetAllocatorType() != AllocatorType::DMA_ALLOC || pixelMap->GetFd() == nullptr) {
        bytes = pixelMap->GetWritablePixels();
        size = pixelMap->GetCapacity();
        imageSize.width = pixelMap->GetWidth();
        imageSize.height = pixelMap->GetHeight();
    } else {
        auto surfaceBuffer = reinterpret_cast<SurfaceBuffer*>(pixelMap->GetFd());
        bytes = surfaceBuffer->GetVirAddr();
        size = surfaceBuffer->GetSize();
        imageSize.width = surfaceBuffer->GetWidth();
        imageSize.height = surfaceBuffer->GetHeight();
    }
    uint32_t writeSize = imageSize.width * imageSize.height;
    AuxiliaryPictureInfo auxInfo = auxPicture->GetAuxiliaryPictureInfo();
    if (auxInfo.auxiliaryPictureType == AuxiliaryPictureType::DEPTH_MAP) {
        writeSize *= DEPTH_MAP_BYTES;
    } else if (auxInfo.auxiliaryPictureType == AuxiliaryPictureType::LINEAR_MAP) {
        writeSize *= LINEAR_MAP_BYTES;
    }
    IMAGE_LOGD("%{public}s auxType: %{public}d, width: %{public}d, height: %{public}d, buffer size: %{public}u,"
        " write size: %{public}u", __func__, auxInfo.auxiliaryPictureType, imageSize.width, imageSize.height,
        size, writeSize);
    skStream.write(bytes, std::min(size, writeSize));
    return SUCCESS;
}

void ExtEncoder::WriteJpegAuxiliarySizeAndTag(uint32_t size, std::shared_ptr<AuxiliaryPicture>& auxPicture,
    SkWStream& skStream)
{
    // Write auxiliary image size(little endian)
    std::vector<uint8_t> auxSize = JpegMpfPacker::PackDataSize(size, false);
    skStream.write(auxSize.data(), auxSize.size());

    // Write auxiliary tag name
    AuxiliaryPictureInfo auxInfo = auxPicture->GetAuxiliaryPictureInfo();
    std::vector<uint8_t> tagName = JpegMpfPacker::PackAuxiliaryTagName(auxInfo.jpegTagName);
    skStream.write(tagName.data(), tagName.size());
}
#endif

#ifdef HEIF_HW_ENCODE_ENABLE
static size_t GetBufferSize(size_t contentSize)
{
    return sizeof(PropertyType) + sizeof(int) + contentSize;
}

// format: enum + int buffersize + buffer
static bool FillImagePropertyItem(const std::shared_ptr<AbsMemory> &mem, const size_t offset,
    PropertyType type, const void* payloadData, size_t payloadSize)
{
    uint8_t* memData = reinterpret_cast<uint8_t*>(mem->data.data);
    size_t memSize = mem->data.size;
    IMAGE_LOGD("FileImagePropertyItem memSize is %{public}ld, payloadSize is %{public}ld", memSize, payloadSize);
    IMAGE_LOGD("FileImagePropertyItem sizeof(type) is %{public}ld, sizeof(payloadSize) %{public}ld",
        sizeof(type), sizeof(payloadSize));
    if (payloadSize > INT32_MAX) {
        IMAGE_LOGI("payloadSize is over INT32_MAX");
        return false;
    }
    int payloadIntSize = static_cast<int>(payloadSize);
    size_t typeSize = sizeof(type);
    size_t intSize = sizeof(int);
    bool res = (memcpy_s(memData + offset, memSize - offset, &type, typeSize) == EOK) &&
        (memcpy_s(memData + offset + typeSize, memSize - offset - typeSize, &payloadIntSize, intSize) == EOK) &&
        (memcpy_s(memData + offset + typeSize + intSize, memSize - offset - typeSize - intSize,
        payloadData, payloadSize) == EOK);
    return res;
}

std::shared_ptr<AbsMemory> ExtEncoder::AllocateNewSharedMem(size_t memorySize, std::string tag)
{
    MemoryData memoryData;
    memoryData.size = memorySize;
    memoryData.tag = tag.empty() ? DEFAULT_ASHMEM_TAG.c_str() : tag.c_str();
    std::unique_ptr<AbsMemory> memory =
        MemoryManager::CreateMemory(AllocatorType::SHARE_MEM_ALLOC, memoryData);
    std::shared_ptr<AbsMemory> res = std::move(memory);
    return res;
}

bool ExtEncoder::GetStaticMetadata(HdrMetadata& metadata, MasteringDisplayColourVolume& color, ContentLightLevel& light)
{
    HdrStaticMetadata staticMetadata;
    size_t staticMetadataSize = sizeof(HdrStaticMetadata);
    if (metadata.staticMetadata.size() < staticMetadataSize) {
        IMAGE_LOGI("GetStaticMetadata failed");
        return false;
    }
    if (memcpy_s(&staticMetadata, staticMetadataSize,
        metadata.staticMetadata.data(), metadata.staticMetadata.size()) != EOK) {
        IMAGE_LOGI("GetStaticMetadata failed, memcpy_s failed");
        return false;
    }
    color.displayPrimariesRX =
        (uint16_t)(STATIC_METADATA_COLOR_SCALE * staticMetadata.smpte2086.displayPrimaryRed.x);
    color.displayPrimariesRY =
        (uint16_t)(STATIC_METADATA_COLOR_SCALE * staticMetadata.smpte2086.displayPrimaryRed.y);
    color.displayPrimariesGX =
        (uint16_t)(STATIC_METADATA_COLOR_SCALE * staticMetadata.smpte2086.displayPrimaryGreen.x);
    color.displayPrimariesGY =
        (uint16_t)(STATIC_METADATA_COLOR_SCALE * staticMetadata.smpte2086.displayPrimaryGreen.y);
    color.displayPrimariesBX =
        (uint16_t)(STATIC_METADATA_COLOR_SCALE * staticMetadata.smpte2086.displayPrimaryBlue.x);
    color.displayPrimariesBY =
        (uint16_t)(STATIC_METADATA_COLOR_SCALE * staticMetadata.smpte2086.displayPrimaryBlue.y);
    color.whitePointX = (uint16_t)(STATIC_METADATA_COLOR_SCALE * staticMetadata.smpte2086.whitePoint.x);
    color.whitePointY = (uint16_t)(STATIC_METADATA_COLOR_SCALE * staticMetadata.smpte2086.whitePoint.y);
    color.maxDisplayMasteringLuminance = (uint32_t)staticMetadata.smpte2086.maxLuminance;
    color.minDisplayMasteringLuminance = (uint32_t)(STATIC_METADATA_LUM_SCALE * staticMetadata.smpte2086.minLuminance);
    light.maxContentLightLevel = (uint16_t)staticMetadata.cta861.maxContentLightLevel;
    light.maxPicAverageLightLevel = (uint16_t)staticMetadata.cta861.maxFrameAverageLightLevel;
    return true;
}

bool ExtEncoder::GetToneMapChannel(ISOMetadata& metadata, ToneMapChannel& channel, uint8_t index)
{
    if (index > GAINMAP_CHANNEL_MULTI - 1) {
        IMAGE_LOGE("GetToneMapChannel index:[%{public}d] unsupported", index);
        return false;
    }
    channel.gainMapMin.numerator = DEFAULT_DENOMINATOR * metadata.enhanceClippedThreholdMinGainmap[index];
    channel.gainMapMin.denominator = DEFAULT_DENOMINATOR;
    channel.gainMapMax.numerator = DEFAULT_DENOMINATOR * metadata.enhanceClippedThreholdMaxGainmap[index];
    channel.gainMapMax.denominator = DEFAULT_DENOMINATOR;
    if (metadata.enhanceMappingGamma[index] > 0.0f) {
        channel.gamma.numerator = DEFAULT_DENOMINATOR * metadata.enhanceMappingGamma[index];
    } else {
        channel.gamma.numerator = 0;
    }
    channel.gamma.denominator = DEFAULT_DENOMINATOR;
    channel.baseOffset.numerator = DEFAULT_DENOMINATOR * metadata.enhanceMappingBaselineOffset[index];
    channel.baseOffset.denominator = DEFAULT_DENOMINATOR;
    channel.alternateOffset.numerator = DEFAULT_DENOMINATOR * metadata.enhanceMappingAlternateOffset[index];
    channel.alternateOffset.denominator = DEFAULT_DENOMINATOR;
    IMAGE_LOGD("GetToneMapChannel [%{public}d],gainmapMin:%{public}f, gainmapMax:%{public}f,"
        "gamma:%{public}f,baseOffset:%{public}f, alternateOffset:%{public}f", index,
        metadata.enhanceClippedThreholdMinGainmap[index], metadata.enhanceClippedThreholdMaxGainmap[index],
        metadata.enhanceMappingGamma[index],
        metadata.enhanceMappingBaselineOffset[index], metadata.enhanceMappingAlternateOffset[index]);
    return true;
}

bool ExtEncoder::GetToneMapMetadata(HdrMetadata& metadata, ToneMapMetadata& toneMapMetadata)
{
    ISOMetadata isoMeta = metadata.extendMeta.metaISO;
    toneMapMetadata.useBaseColorSpace = (isoMeta.useBaseColorFlag == 1) ? true : false;
    toneMapMetadata.channelCnt = (isoMeta.gainmapChannelNum == 0) ? GAINMAP_CHANNEL_SINGLE : GAINMAP_CHANNEL_MULTI;
    toneMapMetadata.baseHdrHeadroom.denominator = DEFAULT_DENOMINATOR;
    if (isoMeta.baseHeadroom > 0.0f) {
        toneMapMetadata.baseHdrHeadroom.numerator = (uint32_t)(isoMeta.baseHeadroom * DEFAULT_DENOMINATOR);
    } else {
        toneMapMetadata.baseHdrHeadroom.numerator = 0;
    }
    toneMapMetadata.alternateHdrHeadroom.denominator = DEFAULT_DENOMINATOR;
    if (isoMeta.alternateHeadroom > 0.0f) {
        toneMapMetadata.alternateHdrHeadroom.numerator = (uint32_t)(isoMeta.alternateHeadroom * DEFAULT_DENOMINATOR);
    } else {
        toneMapMetadata.alternateHdrHeadroom.numerator = 0;
    }
    GetToneMapChannel(isoMeta, toneMapMetadata.channels1, INDEX_ZERO);
    if (toneMapMetadata.channelCnt == GAINMAP_CHANNEL_MULTI) {
        GetToneMapChannel(isoMeta, toneMapMetadata.channels2, INDEX_ONE);
        GetToneMapChannel(isoMeta, toneMapMetadata.channels3, INDEX_TWO);
    }
    IMAGE_LOGD("GetToneMapMetadata useBaseColorSpace:%{public}d, gainmapChannelNum:%{public}d,"
        "baseHeadroom:%{public}f,alternateHeadroom:%{public}f", isoMeta.useBaseColorFlag, isoMeta.gainmapChannelNum,
        isoMeta.baseHeadroom, isoMeta.alternateHeadroom);
    return true;
}

void ExtEncoder::GetColourInfo(ColorManager::ColorSpaceName color, ColourInfo& info)
{
    uint8_t fullRangeFlag;
    ColorUtils::ColorSpaceGetCicp(color, info.colourPrimaries, info.transferCharacteristics, info.matrixCoefficients,
        fullRangeFlag);
    // 1 : full range ; 0 : limit range.
    info.fullRangeFlag = (fullRangeFlag == 1);
}

bool ExtEncoder::AssembleIT35SharedBuffer(HdrMetadata metadata, SharedBuffer& outBuffer)
{
    std::vector<uint8_t> it35Info;
    if (!HdrHeifPackerHelper::PackIT35Info(metadata, it35Info)) {
        IMAGE_LOGE("get it35 info failed");
        return false;
    }
    std::shared_ptr<AbsMemory> propertyAshmem =
        AllocateNewSharedMem(GetBufferSize(it35Info.size()), IT35_ASHMEM_TAG);
    if (propertyAshmem == nullptr) {
        IMAGE_LOGE("AssembleIT35SharedBuffer it35 alloc failed");
        return false;
    };
    tmpMemoryList_.push_back(propertyAshmem);
    if (!FillImagePropertyItem(propertyAshmem, 0, PropertyType::IT35_INFO, it35Info.data(), it35Info.size())) {
        IMAGE_LOGE("AssembleIT35SharedBuffer fill failed");
        return false;
    }
    outBuffer.fd = *static_cast<int *>(propertyAshmem->extend.data);
    outBuffer.capacity = propertyAshmem->data.size;
    outBuffer.filledLen = propertyAshmem->data.size;
    return true;
}

bool ExtEncoder::AssembleICCImageProperty(sk_sp<SkData>& iccProfile, SharedBuffer& outBuffer)
{
    if (iccProfile == nullptr || iccProfile->size() == 0) {
        IMAGE_LOGI("AssembleICCImageProperty iccprofile is nullptr");
        return false;
    }
    std::shared_ptr<AbsMemory> propertyAshmem =
        AllocateNewSharedMem(GetBufferSize(iccProfile->size()), ICC_ASHMEM_TAG);
    if (propertyAshmem == nullptr) {
        IMAGE_LOGE("AssembleICCImageProperty alloc failed");
        return false;
    }
    tmpMemoryList_.push_back(propertyAshmem);
    bool fillRes = FillImagePropertyItem(propertyAshmem, 0, PropertyType::ICC_PROFILE,
        iccProfile->data(), iccProfile->size());
    if (fillRes) {
        outBuffer.fd = *static_cast<int *>(propertyAshmem->extend.data);
        outBuffer.capacity = propertyAshmem->data.size;
        outBuffer.filledLen = propertyAshmem->data.size;
    }
    return fillRes;
}

bool ExtEncoder::FillNclxColorProperty(std::shared_ptr<ImageItem>& item, size_t& offset, ColourInfo& colorInfo)
{
    ColorType colorType = ColorType::NCLX;
    if (!FillLitePropertyItem(item->liteProperties, offset,
        PropertyType::COLOR_TYPE, &colorType, sizeof(ColorType))) {
        IMAGE_LOGE("Fill colorType failed");
        return false;
    }
    if (!FillLitePropertyItem(item->liteProperties, offset,
        PropertyType::COLOR_INFO, &colorInfo, sizeof(ColourInfo))) {
        IMAGE_LOGI("Fill colorInfo failed");
        return false;
    }
    return true;
}

bool ExtEncoder::AssembleOutputSharedBuffer(SharedBuffer& outBuffer, std::shared_ptr<AbsMemory>& outMem)
{
    if (output_ == nullptr) {
        IMAGE_LOGE("AssembleOutputSharedBuffer output_ is nullptr");
        return false;
    }
    OutputStreamType outType = output_->GetType();
    size_t outputCapacity = DEFAULT_OUTPUT_SIZE;
    if (outType != OutputStreamType::FILE_PACKER) {
        output_->GetCapicity(outputCapacity);
    }
    std::shared_ptr<AbsMemory> mem = AllocateNewSharedMem(outputCapacity, OUTPUT_ASHMEM_TAG);
    if (mem == nullptr) {
        IMAGE_LOGE("AssembleOutputSharedBuffer alloc out sharemem failed");
        return false;
    }
    outMem = mem;
    tmpMemoryList_.push_back(mem);
    outBuffer.fd = *static_cast<int *>(mem->extend.data);
    outBuffer.capacity = outputCapacity;
    return true;
}

void ExtEncoder::AssembleDualHdrRefItem(std::vector<ItemRef>& refs)
{
    auto item = std::make_shared<ItemRef>();
    item->type = ReferenceType::DIMG;
    item->from = TMAP_IMAGE_ITEM_ID;
    item->to.resize(INDEX_TWO);
    item->to[INDEX_ZERO] = PRIMARY_IMAGE_ITEM_ID;
    item->to[INDEX_ONE] = GAINMAP_IMAGE_ITEM_ID;
    refs.push_back(*item);
}

uint32_t ExtEncoder::DoHeifEncode(std::vector<ImageItem>& inputImgs, std::vector<MetaItem>& inputMetas,
    std::vector<ItemRef>& refs)
{
    SharedBuffer outputBuffer {};
    std::shared_ptr<AbsMemory> outputAshmem;
    bool tempRes = AssembleOutputSharedBuffer(outputBuffer, outputAshmem);
    if (!tempRes) {
        IMAGE_LOGE("ExtEncoder::DoHeifEncode alloc sharedbuffer failed");
        return ERR_IMAGE_INVALID_PARAMETER;
    }

    sptr<ICodecImage> codec = GetCodecManager();
    if (codec == nullptr) {
        return ERR_IMAGE_ENCODE_FAILED;
    }
    uint32_t outSize = DEFAULT_OUTPUT_SIZE;
    int32_t encodeRes = codec->DoHeifEncode(inputImgs, inputMetas, refs, outputBuffer, outSize);
    if (encodeRes != HDF_SUCCESS) {
        IMAGE_LOGE("ExtEncoder::DoHeifEncode DoHeifEncode failed");
        return ERR_IMAGE_ENCODE_FAILED;
    }
    IMAGE_LOGI("ExtEncoder::DoHeifEncode output type is %{public}d", output_->GetType());
    bool writeRes = output_->Write(reinterpret_cast<uint8_t *>(outputAshmem->data.data), outSize);
    if (!writeRes) {
        IMAGE_LOGE("ExtEncoder::DoHeifEncode Write failed");
        return ERR_IMAGE_ENCODE_FAILED;
    }
    return SUCCESS;
}

std::shared_ptr<ImageItem> ExtEncoder::AssembleTmapImageItem(ColorManager::ColorSpaceName color,
    HdrMetadata metadata, const PlEncodeOptions &opts)
{
    auto item = std::make_shared<ImageItem>();
    item->id = TMAP_IMAGE_ITEM_ID;
    item->itemName = "Tone-mapped representation";
    item->isPrimary = false;
    item->isHidden = false;
    item->compressType = COMPRESS_TYPE_TMAP;
    item->quality = opts.quality;
    item->sharedProperties.fd = -1;
    item->pixelSharedBuffer.fd = -1;
    ColourInfo colorInfo;
    GetColourInfo(color, colorInfo);
    ContentLightLevel light;
    MasteringDisplayColourVolume colour;
    bool hasLight = GetStaticMetadata(metadata, colour, light);
    uint32_t propertiesSize = 0;
    propertiesSize +=
        (sizeof(PropertyType::COLOR_TYPE) + sizeof(ColorType) + sizeof(PropertyType::COLOR_INFO) + sizeof(ColourInfo));
    if (hasLight) {
        propertiesSize += (sizeof(PropertyType::CONTENT_LIGHT_LEVEL) + sizeof(ContentLightLevel));
    }
    ToneMapMetadata toneMap;
    bool hasToneMap = GetToneMapMetadata(metadata, toneMap);
    if (hasToneMap) {
        propertiesSize += (sizeof(PropertyType::TONE_MAP_METADATA) + sizeof(ToneMapMetadata));
    }
    item->liteProperties.resize(propertiesSize);
    size_t offset = 0;
    if (!FillNclxColorProperty(item, offset, colorInfo)) {
        return nullptr;
    }
    if (hasLight && (!FillLitePropertyItem(item->liteProperties, offset,
        PropertyType::CONTENT_LIGHT_LEVEL, &colour, sizeof(ContentLightLevel)))) {
        IMAGE_LOGE("AssembleTmapImageItem fill CONTENT_LIGHT_LEVEL failed");
        return nullptr;
    }
    if (hasToneMap && (!FillLitePropertyItem(item->liteProperties, offset,
        PropertyType::TONE_MAP_METADATA, &toneMap, sizeof(ToneMapMetadata)))) {
        IMAGE_LOGE("AssembleTmapImageItem fill toneMap failed");
        return nullptr;
    }
    if (!AssembleIT35SharedBuffer(metadata, item->sharedProperties)) {
        IMAGE_LOGE("AssembleTmapImageItem fill it35 failed");
        return nullptr;
    }
    return item;
}

#if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
std::shared_ptr<ImageItem> ExtEncoder::AssemblePrimaryImageItem(sptr<SurfaceBuffer>& surfaceBuffer,
    const PlEncodeOptions &opts)
{
    if (pixelmap_ == nullptr || surfaceBuffer == nullptr) {
        IMAGE_LOGE("AssemblePrimaryImageItem surfaceBuffer is nullptr");
        return nullptr;
    }
    auto item = std::make_shared<ImageItem>();
    item->id = PRIMARY_IMAGE_ITEM_ID;
    item->pixelBuffer = sptr<NativeBuffer>::MakeSptr(surfaceBuffer->GetBufferHandle());
    item->isPrimary = true;
    item->isHidden = false;
    item->compressType = COMPRESS_TYPE_HEVC;
    item->quality = opts.quality;
    item->sharedProperties.fd = -1;
    item->pixelSharedBuffer.fd = -1;
    sk_sp<SkData> iccProfile = icc_from_color_space(ToSkInfo(pixelmap_));
    bool tempRes = AssembleICCImageProperty(iccProfile, item->sharedProperties);
    if (!tempRes) {
        return nullptr;
    }
    uint32_t litePropertiesSize = 0;
    litePropertiesSize += (sizeof(PropertyType::COLOR_TYPE) + sizeof(ColorType));
    item->liteProperties.resize(litePropertiesSize);
    size_t offset = 0;
    ColorType colorType = ColorType::RICC;
    if (!FillLitePropertyItem(item->liteProperties, offset,
        PropertyType::COLOR_TYPE, &colorType, sizeof(ColorType))) {
        IMAGE_LOGE("AssemblePrimaryImageItem Fill color type failed");
        return nullptr;
    }
    return item;
}
#endif

void ExtEncoder::AssembleExifRefItem(std::vector<ItemRef>& refs)
{
    auto item = std::make_shared<ItemRef>();
    item->type = ReferenceType::CDSC;
    item->from = EXIF_META_ITEM_ID;
    item->to.resize(INDEX_ONE);
    item->to[INDEX_ZERO] = PRIMARY_IMAGE_ITEM_ID;
    refs.push_back(*item);
}

void inline FreeExifBlob(uint8_t** exifBlob)
{
    if (exifBlob != nullptr && *exifBlob != nullptr) {
        free(*exifBlob);
        *exifBlob = nullptr;
    }
}

bool ExtEncoder::AssembleExifMetaItem(std::vector<MetaItem>& metaItems)
{
    if (!opts_.needsPackProperties) {
        IMAGE_LOGD("no need encode exif");
        return false;
    }
    ExifData* exifData = nullptr;
    if (picture_ != nullptr && picture_->GetExifMetadata() != nullptr &&
        picture_->GetExifMetadata()->GetExifData() != nullptr) {
        exifData = picture_->GetExifMetadata()->GetExifData();
    } else if (pixelmap_ != nullptr && pixelmap_->GetExifMetadata() != nullptr &&
        pixelmap_->GetExifMetadata()->GetExifData() != nullptr) {
        exifData = pixelmap_->GetExifMetadata()->GetExifData();
    } else {
        IMAGE_LOGD("no exif");
        return false;
    }
    uint8_t* exifBlob = nullptr;
    uint32_t exifSize = 0;
    TiffParser::Encode(&exifBlob, exifSize, exifData);
    if (exifBlob == nullptr) {
        IMAGE_LOGE("Encode exif data failed");
        return false;
    }
    auto item = std::make_shared<MetaItem>();
    item->id = EXIF_META_ITEM_ID;
    item->itemName = "exif";
    item->data.fd = -1;
    std::shared_ptr<AbsMemory> propertyAshmem = AllocateNewSharedMem(exifSize + EXIF_PRE_SIZE, EXIF_ASHMEM_TAG);
    if (propertyAshmem == nullptr) {
        FreeExifBlob(&exifBlob);
        IMAGE_LOGE("AssembleExifMetaItem alloc propertyAshmem failed");
        return false;
    }
    tmpMemoryList_.push_back(propertyAshmem);
    uint8_t* memData = reinterpret_cast<uint8_t*>(propertyAshmem->data.data);
    size_t memSize = propertyAshmem->data.size;
    bool fillRes = (memcpy_s(memData, memSize, EXIF_PRE_TAG, EXIF_PRE_SIZE) == EOK) &&
        (memcpy_s(memData + EXIF_PRE_SIZE, memSize - EXIF_PRE_SIZE, exifBlob, exifSize) == EOK);
    if (fillRes) {
        item->data.fd = *static_cast<int *>(propertyAshmem->extend.data);
        item->data.capacity = propertyAshmem->data.size;
        item->data.filledLen = propertyAshmem->data.size;
        metaItems.push_back(*item);
    }
    FreeExifBlob(&exifBlob);
    return fillRes;
}

bool ExtEncoder::FillPixelSharedBuffer(sptr<SurfaceBuffer> sbBuffer, uint32_t capacity, SharedBuffer& outBuffer)
{
    if (sbBuffer == nullptr || capacity == 0) {
        IMAGE_LOGI("%{public}s iccprofile is nullptr", __func__);
        return false;
    }
    std::shared_ptr<AbsMemory> sharedMem = AllocateNewSharedMem(capacity, IMAGE_DATA_TAG);
    if (sharedMem == nullptr) {
        IMAGE_LOGE("%{public}s alloc failed", __func__);
        return false;
    }
    tmpMemoryList_.push_back(sharedMem);
    uint8_t* memData = reinterpret_cast<uint8_t*>(sharedMem->data.data);
    size_t memSize = sharedMem->data.size;
    if (capacity > memSize) {
        IMAGE_LOGE("%{public}s shared capacity[%{public}d] over memSize[%{public}ld]", __func__, capacity, memSize);
        return false;
    }
    if (sharedMem->extend.data == nullptr) {
        IMAGE_LOGE("%{public}s sharedMem's extend data is nullptr", __func__);
        return false;
    }
    if (memcpy_s(memData, memSize, sbBuffer->GetVirAddr(), capacity) == EOK) {
        outBuffer.fd = *static_cast<int *>(sharedMem->extend.data);
        outBuffer.capacity = memSize;
        outBuffer.filledLen = memSize;
    } else {
        IMAGE_LOGE("%{public}s memcpy failed", __func__);
        return false;
    }
    return true;
}

void ExtEncoder::AssembleAuxiliaryRefItem(AuxiliaryPictureType type, std::vector<ItemRef>& refs)
{
    auto item = std::make_shared<ItemRef>();
    item->type = ReferenceType::AUXL;
    item->to.resize(INDEX_ONE);
    item->to[INDEX_ZERO] = PRIMARY_IMAGE_ITEM_ID;
    switch (type) {
        case AuxiliaryPictureType::DEPTH_MAP:
            item->from = DEPTH_MAP_ITEM_ID;
            break;
        case AuxiliaryPictureType::UNREFOCUS_MAP:
            item->from = UNREFOCUS_MAP_ITEM_ID;
            break;
        case AuxiliaryPictureType::LINEAR_MAP:
            item->from = LINEAR_MAP_ITEM_ID;
            break;
        case AuxiliaryPictureType::FRAGMENT_MAP:
            item->from = FRAGMENT_MAP_ITEM_ID;
            break;
        default:
            break;
    }
    refs.push_back(*item);
}
#endif
} // namespace ImagePlugin
} // namespace OHOS