diff --git a/frameworks/innerkitsimpl/codec/src/image_source.cpp b/frameworks/innerkitsimpl/codec/src/image_source.cpp
index a11c955618e31523ad8a46671f03521e79455f49..c3cb7fdc6fd067404223b1937e1d6df962dccd57 100644
--- a/frameworks/innerkitsimpl/codec/src/image_source.cpp
+++ b/frameworks/innerkitsimpl/codec/src/image_source.cpp
@@ -4452,6 +4452,7 @@ bool ImageSource::ComposeHdrImage(ImageHdrType hdrType, DecodeContext& baseCtx,
         FreeContextBuffer(hdrCtx.freeFunc, hdrCtx.allocatorType, hdrCtx.pixelsBuffer);
         return false;
     }
+    ImageUtils::DumpHdrBufferEnabled(buffers.hdr, "PixelMap-GAINMAP-Composed");
     SetDmaContextYuvInfo(hdrCtx);
     if (GetHdrMediaType(metadata) == CM_IMAGE_HDR_VIVID_SINGLE) {
         VpeUtils::SetSbMetadataType(hdrSptr, static_cast<CM_HDR_Metadata_Type>(metadata.hdrMetadataType));
@@ -4572,6 +4573,8 @@ void ImageSource::SpecialSetComposeBuffer(DecodeContext &baseCtx, sptr<SurfaceBu
     if (baseCtx.isCreateWideGamutSdrPixelMap) {
         VpeUtils::SetSbColorSpaceType(hdrSptr, CM_DISPLAY_BT2020_SRGB);
     }
+    ImageUtils::DumpHdrBufferEnabled(baseSptr, "PixelMap-SDR-tobeComposed");
+    ImageUtils::DumpHdrBufferEnabled(gainmapSptr, "PixelMap-GAINMAP-tobeComposed");
 }
 
 static uint32_t CopyContextIntoSurfaceBuffer(Size dstSize, const DecodeContext &context, DecodeContext &dstCtx,
@@ -4640,7 +4643,9 @@ static uint32_t DoAiHdrProcess(sptr<SurfaceBuffer> &input, DecodeContext &hdrCtx
     VpeUtils::SetSbColorSpaceDefault(output);
 
     std::unique_ptr<VpeUtils> utils = std::make_unique<VpeUtils>();
+    ImageUtils::DumpHdrBufferEnabled(input, "PixelMap-AIprocess-input");
     res = utils->ColorSpaceConverterImageProcess(input, output);
+    ImageUtils::DumpHdrBufferEnabled(output, "PixelMap-AIprocess-output");
     if (res != VPE_ERROR_OK) {
         IMAGE_LOGE("[ImageSource]DoAiHdrProcess ColorSpaceConverterImageProcess failed! %{public}d", res);
         FreeContextBuffer(hdrCtx.freeFunc, hdrCtx.allocatorType, hdrCtx.pixelsBuffer);
diff --git a/frameworks/innerkitsimpl/common/src/pixel_map.cpp b/frameworks/innerkitsimpl/common/src/pixel_map.cpp
index 01e58962beec00e14357f00151f500c0d5f2aaa6..62223999f8e5e6bcee25b51fd033d5610ed524bd 100644
--- a/frameworks/innerkitsimpl/common/src/pixel_map.cpp
+++ b/frameworks/innerkitsimpl/common/src/pixel_map.cpp
@@ -4443,12 +4443,15 @@ std::unique_ptr<AbsMemory> PixelMap::CreateSdrMemory(ImageInfo &imageInfo, Pixel
         VpeUtils::SetSbColorSpaceType(hdrSurfaceBuffer, colorspaceType);
 #endif
     }
+    ImageUtils::DumpHdrBufferEnabled(hdrSurfaceBuffer, "decompose-HDR");
     if (!DecomposeImage(hdrSurfaceBuffer, sdrSurfaceBuffer, toSRGB)) {
         sdrMemory->Release();
-        IMAGE_LOGI("ToSdr decompose failed");
+        IMAGE_LOGE("HDR-IMAGE ToSdr decompose failed, CM_ColorType : %{public}d",
+            static_cast<uint32_t>(colorspaceType));
         errorCode = IMAGE_RESULT_GET_SURFAC_FAILED;
         return nullptr;
     }
+    ImageUtils::DumpHdrBufferEnabled(sdrSurfaceBuffer, "decompose-SDR");
     errorCode = SUCCESS;
     return sdrMemory;
 #else
diff --git a/frameworks/innerkitsimpl/converter/src/image_format_convert.cpp b/frameworks/innerkitsimpl/converter/src/image_format_convert.cpp
index 14625559076ad87dc8c5012ecb7fdcc790020eea..03b3862ef21db427ef89e2562b3ac93402b9c5ac 100644
--- a/frameworks/innerkitsimpl/converter/src/image_format_convert.cpp
+++ b/frameworks/innerkitsimpl/converter/src/image_format_convert.cpp
@@ -23,6 +23,7 @@
 #include "hilog/log.h"
 #include "image_format_convert_ext_utils.h"
 #include "image_log.h"
+#include "image_trace.h"
 #include "image_source.h"
 #include "log_tags.h"
 #include "media_errors.h"
@@ -30,6 +31,7 @@
 #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
 #include "v1_0/buffer_handle_meta_key_type.h"
 #include "v1_0/cm_color_space.h"
+#include "v2_1/cm_color_space.h"
 #include "v1_0/hdr_static_metadata.h"
 #include "surface_buffer.h"
 #endif
@@ -63,6 +65,7 @@ namespace OHOS {
 namespace Media {
 #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
 using namespace HDI::Display::Graphic::Common::V1_0;
+using CM_ColorSpaceType_V2_1 = OHOS::HDI::Display::Graphic::Common::V2_1::CM_ColorSpaceType;
 #endif
 
 static const std::map<std::pair<PixelFormat, PixelFormat>, ConvertFunction> g_cvtFuncMap = []() {
@@ -349,41 +352,43 @@ uint32_t ImageFormatConvert::ConvertImageFormat(const ConvertDataInfo &srcDataIn
     return RGBConvert(srcDataInfo, destInfo);
 }
 
-uint32_t ImageFormatConvert::ConvertImageFormat(std::shared_ptr<PixelMap> &srcPiexlMap, PixelFormat destFormat)
+uint32_t ImageFormatConvert::ConvertImageFormat(std::shared_ptr<PixelMap> &srcPixelMap, PixelFormat destFormat)
 {
-    if (srcPiexlMap == nullptr) {
+    if (srcPixelMap == nullptr) {
         IMAGE_LOGE("source pixel map is null");
         return ERR_IMAGE_INVALID_PARAMETER;
     }
+    ImageTrace imageTrace("ImageFormatConvert::ConvertImageFormat srcFmt %u, dstFmt %u",
+        static_cast<uint32_t>(srcPixelMap->GetPixelFormat(), static_cast<uint32_t>(destFormat)));
     if (!IsSupport(destFormat)) {
         IMAGE_LOGE("destination format not support");
         return ERR_MEDIA_FORMAT_UNSUPPORT;
     }
-    PixelFormat srcFormat = srcPiexlMap->GetPixelFormat();
+    PixelFormat srcFormat = srcPixelMap->GetPixelFormat();
     if (IsYUVConvert(srcFormat)) {
         uint32_t ret = 0;
-        ret = YUVConvertImageFormatOption(srcPiexlMap, srcFormat, destFormat);
+        ret = YUVConvertImageFormatOption(srcPixelMap, srcFormat, destFormat);
         if (ret != SUCCESS) {
             IMAGE_LOGE("convert yuv format failed!");
         }
         return ret;
     }
-    if (srcPiexlMap->IsAstc()) {
+    if (srcPixelMap->IsAstc()) {
         uint32_t ret = 0;
-        std::unique_ptr<PixelMap> resultPixelMap = PixelMap::ConvertFromAstc(srcPiexlMap.get(), ret,
+        std::unique_ptr<PixelMap> resultPixelMap = PixelMap::ConvertFromAstc(srcPixelMap.get(), ret,
             destFormat);
-        srcPiexlMap = std::move(resultPixelMap);
+        srcPixelMap = std::move(resultPixelMap);
         if (ret != SUCCESS) {
             IMAGE_LOGE("convert astc format failed!");
         }
         return ret;
     }
-    uint32_t ret = RGBConvertImageFormatOption(srcPiexlMap, srcFormat, destFormat);
+    uint32_t ret = RGBConvertImageFormatOption(srcPixelMap, srcFormat, destFormat);
     if (ret != SUCCESS) {
         IMAGE_LOGE("convert rgb format failed!");
         return ret;
     }
-    ImageUtils::DumpPixelMapIfDumpEnabled(*srcPiexlMap, __func__);
+    ImageUtils::DumpPixelMapIfDumpEnabled(*srcPixelMap, __func__);
     return SUCCESS;
 }
 
@@ -563,31 +568,109 @@ std::unique_ptr<AbsMemory> ImageFormatConvert::CreateMemory(PixelFormat pixelFor
     return m;
 }
 
-uint32_t ImageFormatConvert::RGBConvertImageFormatOption(std::shared_ptr<PixelMap> &srcPiexlMap,
+bool IsRGBA1010102ToRGBA8888(std::shared_ptr<PixelMap> &srcPixelMap, PixelFormat destFormat)
+{
+    if (srcPixelMap == nullptr) {
+        IMAGE_LOGE("%{public}s srcPixelMap get null", __func__);
+        return false;
+    }
+    PixelFormat srcFormat = srcPixelMap->GetPixelFormat();
+    if (srcFormat != PixelFormat::RGBA_1010102 || destFormat != PixelFormat::RGBA_8888) {
+        return false;
+    }
+    return true;
+}
+
+std::unique_ptr<AbsMemory> Truncate10BitMemory(std::shared_ptr<PixelMap> &srcPixelmap,
+    ImageInfo &imageInfo, PixelFormat destFormat, AllocatorType dstType, uint32_t &errorCode)
+{
+#if !defined(CROSS_PLATFORM)
+    ImageTrace imageTrace("ImageFormatConvert::Truncate10BitMemory");
+    IMAGE_LOGD("%{public}s srcPixelMap get format %{public}d", __func__, destFormat);
+    bool cond = srcPixelmap == nullptr;
+    CHECK_ERROR_RETURN_RET_LOG(cond, nullptr, "Truncate function error by src null");
+    // hdr and sdr has same byte size.
+    size_t byteSize = srcPixelmap->GetByteCount();
+    MemoryData sdrData = {nullptr, byteSize, "Trans ImageData", imageInfo.size, destFormat};
+    auto sdrMemory = MemoryManager::CreateMemory(dstType, sdrData);
+    if (sdrMemory == nullptr) {
+        IMAGE_LOGI("sdr memory alloc failed.");
+        errorCode = IMAGE_RESULT_GET_SURFAC_FAILED;
+        return nullptr;
+    }
+    VpeSurfaceBuffers buffers;
+    buffers.sdr = sptr<SurfaceBuffer>(reinterpret_cast<SurfaceBuffer*>(sdrMemory->extend.data));
+    buffers.hdr = sptr<SurfaceBuffer>(reinterpret_cast<SurfaceBuffer*>(srcPixelmap->GetFd()));
+    std::unique_ptr<VpeUtils> utils = std::make_unique<VpeUtils>();
+    int32_t res = utils->TruncateBuffer(buffers, true);
+    if (res != SUCCESS) {
+        sdrMemory->Release();
+        IMAGE_LOGE("HDR-IMAGE Truncate10BitMemory failed");
+        errorCode = IMAGE_RESULT_GET_SURFAC_FAILED;
+        return nullptr;
+    }
+    errorCode = SUCCESS;
+    return sdrMemory;
+#else
+    errorCode = ERR_MEDIA_INVALID_OPERATION;
+    return nullptr;
+#endif
+}
+
+uint32_t ConvertRGB1010102ToRGBA8888(std::shared_ptr<PixelMap> &srcPixelMap, PixelFormat destFormat)
+{
+    IMAGE_LOGI("do %{public}s", __func__);
+    if (srcPixelMap == nullptr) {
+        return ERR_IMAGE_INVALID_PARAMETER;
+    }
+    PixelFormat srcFormat = srcPixelMap->GetPixelFormat();
+    auto allocateType = srcPixelMap->GetAllocatorType();
+    if (allocateType != AllocatorType::DMA_ALLOC) {
+        IMAGE_LOGE("do %{public}s allocatorType error", __func__);
+        return ERR_IMAGE_INVALID_PARAMETER;
+    }
+    AllocatorType dstType = AllocatorType::DMA_ALLOC;
+    ImageInfo imageInfo;
+    srcPixelMap->GetImageInfo(imageInfo);
+    uint32_t ret = SUCCESS;
+    auto sdrMemory = Truncate10BitMemory(srcPixelMap, imageInfo, destFormat, dstType, ret);
+    if (sdrMemory == nullptr) {
+        return IMAGE_RESULT_FORMAT_CONVERT_FAILED;
+    }
+    srcPixelMap->SetPixelsAddr(sdrMemory->data.data, sdrMemory->extend.data, sdrMemory->data.size, dstType, nullptr);
+    imageInfo.pixelFormat = sdrMemory->data.format;
+    srcPixelMap->SetImageInfo(imageInfo, true);
+    return SUCCESS;
+}
+
+uint32_t ImageFormatConvert::RGBConvertImageFormatOption(std::shared_ptr<PixelMap> &srcPixelMap,
                                                          const PixelFormat &srcFormat, PixelFormat destFormat)
 {
     ConvertFunction cvtFunc = GetConvertFuncByFormat(srcFormat, destFormat);
     if (cvtFunc == nullptr) {
-        IMAGE_LOGE("get convert function by format failed!");
-        return ERR_IMAGE_INVALID_PARAMETER;
+        if (!IsRGBA1010102ToRGBA8888(srcPixelMap, destFormat)) {
+            IMAGE_LOGE("get convert function by format failed!");
+            return ERR_IMAGE_INVALID_PARAMETER;
+        }
+        return ConvertRGB1010102ToRGBA8888(srcPixelMap, destFormat);
     }
-    const_uint8_buffer_type srcBuffer = srcPiexlMap->GetPixels();
+    const_uint8_buffer_type srcBuffer = srcPixelMap->GetPixels();
     ImageInfo imageInfo;
-    srcPiexlMap->GetImageInfo(imageInfo);
+    srcPixelMap->GetImageInfo(imageInfo);
 
     int32_t width = imageInfo.size.width;
     int32_t height = imageInfo.size.height;
     YUVStrideInfo dstStrides;
-    auto allocType = srcPiexlMap->GetAllocatorType();
-    auto m = CreateMemory(destFormat, allocType, imageInfo.size, dstStrides, srcPiexlMap->GetNoPaddingUsage());
+    auto allocType = srcPixelMap->GetAllocatorType();
+    auto m = CreateMemory(destFormat, allocType, imageInfo.size, dstStrides, srcPixelMap->GetNoPaddingUsage());
     if (m == nullptr) {
         IMAGE_LOGE("CreateMemory failed");
         return ERR_IMAGE_INVALID_PARAMETER;
     }
-    int32_t stride = srcPiexlMap->GetRowStride();
+    int32_t stride = srcPixelMap->GetRowStride();
     #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
     if (allocType == AllocatorType::DMA_ALLOC) {
-        auto sb = reinterpret_cast<SurfaceBuffer*>(srcPiexlMap->GetFd());
+        auto sb = reinterpret_cast<SurfaceBuffer*>(srcPixelMap->GetFd());
         stride = sb->GetStride();
         sptr<SurfaceBuffer> sourceSurfaceBuffer(sb);
         sptr<SurfaceBuffer> dstSurfaceBuffer(reinterpret_cast<SurfaceBuffer*>(m->extend.data));
@@ -602,12 +685,12 @@ uint32_t ImageFormatConvert::RGBConvertImageFormatOption(std::shared_ptr<PixelMa
     destInfo.uvStride = dstStrides.uvStride;
     destInfo.yOffset = dstStrides.yOffset;
     destInfo.uvOffset = dstStrides.uvOffset;
-    if (!cvtFunc(srcBuffer, rgbDataInfo, destInfo, srcPiexlMap->GetColorSpace())) {
+    if (!cvtFunc(srcBuffer, rgbDataInfo, destInfo, srcPixelMap->GetColorSpace())) {
         IMAGE_LOGE("format convert failed!");
         m->Release();
         return IMAGE_RESULT_FORMAT_CONVERT_FAILED;
     }
-    auto ret = MakeDestPixelMap(srcPiexlMap, imageInfo, destInfo, m->extend.data);
+    auto ret = MakeDestPixelMap(srcPixelMap, imageInfo, destInfo, m->extend.data);
     if (ret == ERR_IMAGE_PIXELMAP_CREATE_FAILED) {
         m->Release();
     }
@@ -615,26 +698,26 @@ uint32_t ImageFormatConvert::RGBConvertImageFormatOption(std::shared_ptr<PixelMa
 }
 
 uint32_t ImageFormatConvert::RGBConvertImageFormatOptionUnique(
-    std::unique_ptr<PixelMap> &srcPiexlMap, const PixelFormat &srcFormat, PixelFormat destFormat)
+    std::unique_ptr<PixelMap> &srcPixelMap, const PixelFormat &srcFormat, PixelFormat destFormat)
 {
     ConvertFunction cvtFunc = GetConvertFuncByFormat(srcFormat, destFormat);
     bool cond = cvtFunc == nullptr;
     CHECK_ERROR_RETURN_RET_LOG(cond, ERR_IMAGE_INVALID_PARAMETER, "get convert function by format failed!");
-    const_uint8_buffer_type srcBuffer = srcPiexlMap->GetPixels();
+    const_uint8_buffer_type srcBuffer = srcPixelMap->GetPixels();
     ImageInfo imageInfo;
-    srcPiexlMap->GetImageInfo(imageInfo);
+    srcPixelMap->GetImageInfo(imageInfo);
 
     int32_t width = imageInfo.size.width;
     int32_t height = imageInfo.size.height;
     YUVStrideInfo dstStrides;
-    auto allocType = srcPiexlMap->GetAllocatorType();
-    auto memory = CreateMemory(destFormat, allocType, imageInfo.size, dstStrides, srcPiexlMap->GetNoPaddingUsage());
+    auto allocType = srcPixelMap->GetAllocatorType();
+    auto memory = CreateMemory(destFormat, allocType, imageInfo.size, dstStrides, srcPixelMap->GetNoPaddingUsage());
     cond = memory == nullptr;
     CHECK_ERROR_RETURN_RET_LOG(cond, ERR_IMAGE_INVALID_PARAMETER, "CreateMemory failed");
-    int32_t stride = srcPiexlMap->GetRowStride();
+    int32_t stride = srcPixelMap->GetRowStride();
     #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
     if (allocType == AllocatorType::DMA_ALLOC) {
-        auto sb = reinterpret_cast<SurfaceBuffer*>(srcPiexlMap->GetFd());
+        auto sb = reinterpret_cast<SurfaceBuffer*>(srcPixelMap->GetFd());
         stride = sb->GetStride();
         sptr<SurfaceBuffer> sourceSurfaceBuffer(sb);
         sptr<SurfaceBuffer> dstSurfaceBuffer(reinterpret_cast<SurfaceBuffer*>(memory->extend.data));
@@ -649,12 +732,12 @@ uint32_t ImageFormatConvert::RGBConvertImageFormatOptionUnique(
     destInfo.uvStride = dstStrides.uvStride;
     destInfo.yOffset = dstStrides.yOffset;
     destInfo.uvOffset = dstStrides.uvOffset;
-    if (!cvtFunc(srcBuffer, rgbDataInfo, destInfo, srcPiexlMap->GetColorSpace())) {
+    if (!cvtFunc(srcBuffer, rgbDataInfo, destInfo, srcPixelMap->GetColorSpace())) {
         IMAGE_LOGE("format convert failed!");
         memory->Release();
         return IMAGE_RESULT_FORMAT_CONVERT_FAILED;
     }
-    auto ret = MakeDestPixelMapUnique(srcPiexlMap, imageInfo, destInfo, memory->extend.data);
+    auto ret = MakeDestPixelMapUnique(srcPixelMap, imageInfo, destInfo, memory->extend.data);
     if (ret == ERR_IMAGE_PIXELMAP_CREATE_FAILED) {
         memory->Release();
     }
@@ -693,9 +776,9 @@ bool ImageFormatConvert::SetConvertImageMetaData(std::shared_ptr<PixelMap> &srcP
     return true;
 }
 
-static AllocatorType GetAllocatorType(std::shared_ptr<PixelMap> &srcPiexlMap, PixelFormat destFormat)
+static AllocatorType GetAllocatorType(std::shared_ptr<PixelMap> &srcPixelMap, PixelFormat destFormat)
 {
-    auto allocType = srcPiexlMap->GetAllocatorType();
+    auto allocType = srcPixelMap->GetAllocatorType();
     if (destFormat == PixelFormat::RGB_888 || destFormat == PixelFormat::RGB_565 ||
         destFormat == PixelFormat::RGBA_F16) {
         allocType = AllocatorType::SHARE_MEM_ALLOC;
@@ -703,18 +786,18 @@ static AllocatorType GetAllocatorType(std::shared_ptr<PixelMap> &srcPiexlMap, Pi
     return allocType;
 }
 
-uint32_t ImageFormatConvert::YUVConvertImageFormatOption(std::shared_ptr<PixelMap> &srcPiexlMap,
+uint32_t ImageFormatConvert::YUVConvertImageFormatOption(std::shared_ptr<PixelMap> &srcPixelMap,
                                                          const PixelFormat &srcFormat, PixelFormat destFormat)
 {
     YUVConvertFunction yuvCvtFunc = YUVGetConvertFuncByFormat(srcFormat, destFormat);
     if (yuvCvtFunc == nullptr) {
         return ERR_IMAGE_INVALID_PARAMETER;
     }
-    const_uint8_buffer_type data = srcPiexlMap->GetPixels();
+    const_uint8_buffer_type data = srcPixelMap->GetPixels();
     YUVDataInfo yDInfo;
-    srcPiexlMap->GetImageYUVInfo(yDInfo);
+    srcPixelMap->GetImageYUVInfo(yDInfo);
     ImageInfo imageInfo;
-    srcPiexlMap->GetImageInfo(imageInfo);
+    srcPixelMap->GetImageInfo(imageInfo);
     if ((srcFormat == PixelFormat::NV21 || srcFormat == PixelFormat::YCBCR_P010 ||
         srcFormat == PixelFormat::YCRCB_P010) &&
         (yDInfo.yWidth == 0 || yDInfo.yHeight == 0 || yDInfo.uvWidth == 0 || yDInfo.uvHeight == 0)) {
@@ -724,16 +807,16 @@ uint32_t ImageFormatConvert::YUVConvertImageFormatOption(std::shared_ptr<PixelMa
         yDInfo.uvHeight = static_cast<uint32_t>((imageInfo.size.height + 1) / NUM_2);
     }
     YUVStrideInfo dstStrides;
-    auto allocType = GetAllocatorType(srcPiexlMap, destFormat);
+    auto allocType = GetAllocatorType(srcPixelMap, destFormat);
     DestConvertInfo destInfo = {imageInfo.size.width, imageInfo.size.height, destFormat, allocType};
     auto m = CreateMemory(destFormat, allocType, imageInfo.size, dstStrides,
-        srcPiexlMap->GetNoPaddingUsage());
+        srcPixelMap->GetNoPaddingUsage());
     if (m == nullptr) {
         return ERR_IMAGE_INVALID_PARAMETER;
     }
 #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
     if (allocType == AllocatorType::DMA_ALLOC) {
-        sptr<SurfaceBuffer> sourceSurfaceBuffer(reinterpret_cast<SurfaceBuffer*>(srcPiexlMap->GetFd()));
+        sptr<SurfaceBuffer> sourceSurfaceBuffer(reinterpret_cast<SurfaceBuffer*>(srcPixelMap->GetFd()));
         sptr<SurfaceBuffer> dstSurfaceBuffer(reinterpret_cast<SurfaceBuffer*>(m->extend.data));
         VpeUtils::CopySurfaceBufferInfo(sourceSurfaceBuffer, dstSurfaceBuffer);
     }
@@ -744,11 +827,11 @@ uint32_t ImageFormatConvert::YUVConvertImageFormatOption(std::shared_ptr<PixelMa
     destInfo.uvStride = dstStrides.uvStride;
     destInfo.yOffset = dstStrides.yOffset;
     destInfo.uvOffset = dstStrides.uvOffset;
-    if (!yuvCvtFunc(data, yDInfo, destInfo, srcPiexlMap->GetColorSpace())) {
+    if (!yuvCvtFunc(data, yDInfo, destInfo, srcPixelMap->GetColorSpace())) {
         m->Release();
         return IMAGE_RESULT_FORMAT_CONVERT_FAILED;
     }
-    auto ret = MakeDestPixelMap(srcPiexlMap, imageInfo, destInfo, m->extend.data);
+    auto ret = MakeDestPixelMap(srcPixelMap, imageInfo, destInfo, m->extend.data);
     if (ret == ERR_IMAGE_PIXELMAP_CREATE_FAILED) {
         m->Release();
     }
diff --git a/frameworks/innerkitsimpl/picture/picture.cpp b/frameworks/innerkitsimpl/picture/picture.cpp
index 8f3f51cb8e2244bd5bdb14fcf7859f7039f6918a..fed93670ba00b401a603ec12dfa4b8f4dd721115 100644
--- a/frameworks/innerkitsimpl/picture/picture.cpp
+++ b/frameworks/innerkitsimpl/picture/picture.cpp
@@ -368,7 +368,10 @@ sptr<SurfaceBuffer> CreateGainmapByHdrAndSdr(std::shared_ptr<PixelMap> &hdrPixel
         .gainmap = gainmapSptr,
         .hdr = hdrSptr,
     };
+    ImageUtils::DumpHdrBufferEnabled(buffers.sdr, "Calgainmap-sdr");
+    ImageUtils::DumpHdrBufferEnabled(buffers.hdr, "Calgainmap-hdr");
     int32_t res = VpeUtils().ColorSpaceCalGainmap(buffers);
+    ImageUtils::DumpHdrBufferEnabled(buffers.gainmap, "Calgainmap-gainmap");
     if (res != VPE_ERROR_OK) {
         IMAGE_LOGE("HDR-IMAGE CalGainmap failed, res: %{public}d", res);
         return nullptr;
@@ -438,11 +441,14 @@ static std::unique_ptr<PixelMap> ComposeHdrPixelMap(
     };
     bool isCuva = ShouldComposeAsCuva(baseSptr, gainmapSptr);
     IMAGE_LOGD("HDR-IMAGE Compose image, isCuva: %{public}d", isCuva);
+    ImageUtils::DumpHdrBufferEnabled(baseSptr, "Picture-SDR-tobeComposed");
+    ImageUtils::DumpHdrBufferEnabled(gainmapSptr, "Picture-GAINMAP-tobeComposed");
     int32_t res = VpeUtils().ColorSpaceConverterComposeImage(buffers, isCuva);
     if (res != VPE_ERROR_OK) {
         IMAGE_LOGE("Compose HDR image failed, res: %{public}d", res);
         return nullptr;
     }
+    ImageUtils::DumpHdrBufferEnabled(hdrSptr, "Picture-HDR-Composed");
     return Picture::SurfaceBuffer2PixelMap(hdrSptr);
 }
 
diff --git a/frameworks/innerkitsimpl/test/BUILD.gn b/frameworks/innerkitsimpl/test/BUILD.gn
index 0bdf6f63a98a8cb93bbb3b20e2f70d887245c72c..81cf3fcb897530ee9d3e444cf80177d643d6e73a 100644
--- a/frameworks/innerkitsimpl/test/BUILD.gn
+++ b/frameworks/innerkitsimpl/test/BUILD.gn
@@ -1277,6 +1277,8 @@ ohos_unittest("jpeg_hw_decoder_test") {
     "${image_subsystem}/plugins/common/libs/image/libextplugin/include/heif_impl/",
   ]
 
+  cflags = [ "-DIMAGE_COLORSPACE_FLAG" ]
+
   deps = [
     "${image_subsystem}/frameworks/innerkitsimpl/utils:image_utils",
     "${image_subsystem}/interfaces/innerkits:image_native",
diff --git a/frameworks/innerkitsimpl/test/unittest/image_format_convert_test.cpp b/frameworks/innerkitsimpl/test/unittest/image_format_convert_test.cpp
index bac1991d31175111555879dd26e0957a93d55f82..1ed856de980481f7309fbd7c895bf03d94709057 100644
--- a/frameworks/innerkitsimpl/test/unittest/image_format_convert_test.cpp
+++ b/frameworks/innerkitsimpl/test/unittest/image_format_convert_test.cpp
@@ -1793,14 +1793,14 @@ HWTEST_F(ImageFormatConvertTest, MakeDestPixelMap_Test_001, TestSize.Level1)
 HWTEST_F(ImageFormatConvertTest, YUVConvertImageFormatOption_Test_001, TestSize.Level1)
 {
     GTEST_LOG_(INFO) << "ImageFormatConvertTest: YUVConvertImageFormatOption_Test_001 start";
-    std::shared_ptr<PixelMap> srcPiexlMap = std::make_shared<PixelMap>();
+    std::shared_ptr<PixelMap> srcPixelMap = std::make_shared<PixelMap>();
     PixelFormat srcFormat = PixelFormat::UNKNOWN;
     PixelFormat destFormat = PixelFormat::ARGB_8888;
-    EXPECT_EQ(ImageFormatConvert::YUVConvertImageFormatOption(srcPiexlMap, srcFormat, destFormat),
+    EXPECT_EQ(ImageFormatConvert::YUVConvertImageFormatOption(srcPixelMap, srcFormat, destFormat),
     ERR_IMAGE_INVALID_PARAMETER);
     srcFormat = PixelFormat::NV21;
     destFormat = PixelFormat::RGB_888;
-    EXPECT_EQ(ImageFormatConvert::YUVConvertImageFormatOption(srcPiexlMap, srcFormat, destFormat),
+    EXPECT_EQ(ImageFormatConvert::YUVConvertImageFormatOption(srcPixelMap, srcFormat, destFormat),
     ERR_IMAGE_INVALID_PARAMETER);
     GTEST_LOG_(INFO) << "ImageFormatConvertTest: YUVConvertImageFormatOption_Test_001 end";
 }
diff --git a/frameworks/innerkitsimpl/test/unittest/image_source_test/image_source_test.cpp b/frameworks/innerkitsimpl/test/unittest/image_source_test/image_source_test.cpp
index 7dbdb8c908bc3399b8572f156516d7935a59e5c2..bca5461b310ed95a770f7b6a4f899b403ad1c4e8 100644
--- a/frameworks/innerkitsimpl/test/unittest/image_source_test/image_source_test.cpp
+++ b/frameworks/innerkitsimpl/test/unittest/image_source_test/image_source_test.cpp
@@ -3174,7 +3174,7 @@ HWTEST_F(ImageSourceTest, WideGamutTest002, TestSize.Level3)
 }
 
 /**
- * @tc.name: WideGamutTest001
+ * @tc.name: WideGamutTest003
  * @tc.desc: test WideGamut one channel gainmap Jpeg HDR input
  * @tc.type: FUNC
  */
diff --git a/frameworks/innerkitsimpl/test/unittest/plugin_test/ext_decoder_test.cpp b/frameworks/innerkitsimpl/test/unittest/plugin_test/ext_decoder_test.cpp
index 77486d05fee743e1fea5a5391a553cc9d61e25d6..8af983cb2ecb57d5c9aaa5d8a703429a76457a06 100644
--- a/frameworks/innerkitsimpl/test/unittest/plugin_test/ext_decoder_test.cpp
+++ b/frameworks/innerkitsimpl/test/unittest/plugin_test/ext_decoder_test.cpp
@@ -24,6 +24,7 @@
 #include "image_packer.h"
 #include "ext_encoder.h"
 #include "ext_stream.h"
+#include "image_format_convert.h"
 #include "mock_data_stream.h"
 #include "mock_skw_stream.h"
 #include "file_source_stream.h"
@@ -2201,6 +2202,278 @@ HWTEST_F(ExtDecoderTest, EncodePixelMapTest001, TestSize.Level3)
     EXPECT_NE(imageSourceDest, nullptr);
 }
 
+/**
+*@tc.name: Encode10bit709Test001
+*@tc.desc: Test JPEG decode to YCBCR_P010 format PixelMap and set to BT709 then convert to RGBA_1010102
+*and encode 8bit sdr decode to sdr pixelmap with BT601 colorspace.
+*@tc.type: FUNC
+*/
+HWTEST_F(ExtDecoderTest, Encode10bit709Test001, TestSize.Level3)
+{
+    uint32_t errorCode = 0;
+    SourceOptions sourceOpts;
+    std::unique_ptr<ImageSource> imageSource =
+        ImageSource::CreateImageSource(IMAGE_JPG_THREE_GAINMAP_HDR_PATH.c_str(), sourceOpts, errorCode);
+    ASSERT_NE(imageSource, nullptr);
+    DecodeOptions opts;
+    opts.desiredDynamicRange = DecodeDynamicRange::AUTO;
+    opts.photoDesiredPixelFormat = PixelFormat::YCBCR_P010;
+    std::shared_ptr<PixelMap> pixelmap = imageSource->CreatePixelMap(opts, errorCode);
+    ASSERT_EQ(errorCode, OHOS::Media::SUCCESS);
+    ASSERT_NE(pixelmap, nullptr);
+    uint32_t ret = ImageFormatConvert::ConvertImageFormat(pixelmap, PixelFormat::RGBA_1010102);
+    PixelFormat format = pixelmap->GetPixelFormat();
+    ASSERT_EQ(format, PixelFormat::RGBA_1010102);
+#ifdef IMAGE_COLORSPACE_FLAG
+    pixelmap->InnerSetColorSpace(OHOS::ColorManager::ColorSpace(
+                OHOS::ColorManager::ColorSpaceName::BT709));
+    ASSERT_EQ(pixelmap->IsHdr(), false);
+#endif
+    // init packer to packfile
+    ImagePacker packer;
+    PackOption option;
+    option.format = "image/jpeg";
+    option.needsPackProperties = true;
+    option.desiredDynamicRange = EncodeDynamicRange::AUTO;
+    uint32_t startpc = packer.StartPacking(IMAGE_DEST, option);
+    ASSERT_EQ(startpc, OHOS::Media::SUCCESS);
+    uint32_t retAddImage = packer.AddImage(*pixelmap);
+    ASSERT_EQ(retAddImage, OHOS::Media::SUCCESS);
+    uint32_t retFinalizePacking = packer.FinalizePacking();
+    ASSERT_EQ(retFinalizePacking, OHOS::Media::SUCCESS);
+    std::unique_ptr<ImageSource> imageSourceDest = ImageSource::CreateImageSource(IMAGE_DEST, sourceOpts, errorCode);
+    ASSERT_EQ(errorCode, OHOS::Media::SUCCESS);
+    ASSERT_NE(imageSourceDest, nullptr);
+    DecodeOptions optsForDest;
+    optsForDest.desiredDynamicRange = DecodeDynamicRange::AUTO;
+    std::shared_ptr<PixelMap> pixelmapAfterPacker = imageSourceDest->CreatePixelMap(optsForDest, errorCode);
+    ASSERT_NE(pixelmapAfterPacker, nullptr);
+    ASSERT_EQ(pixelmapAfterPacker->IsHdr(), false);
+#ifdef IMAGE_COLORSPACE_FLAG
+    PixelFormat encodeAndDecodeFormat = pixelmapAfterPacker->GetPixelFormat();
+    ASSERT_EQ(encodeAndDecodeFormat, PixelFormat::RGBA_8888);
+    auto newColorspace = pixelmapAfterPacker->InnerGetGrColorSpace();
+    auto newColorSpaceName = newColorspace.GetColorSpaceName();
+    EXPECT_EQ(newColorSpaceName, ColorManager::ColorSpaceName::SRGB);
+#endif
+}
+
+/**
+*@tc.name: Encode10bit709Test002
+*@tc.desc: Test JPEG decode to YCBCR_P010 format PixelMap and set to BT709 
+*and encode 8bit sdr decode to sdr pixelmap with BT601 colorspace.
+*@tc.type: FUNC
+*/
+HWTEST_F(ExtDecoderTest, Encode10bit709Test002, TestSize.Level3)
+{
+    uint32_t errorCode = 0;
+    SourceOptions sourceOpts;
+    std::unique_ptr<ImageSource> imageSource =
+        ImageSource::CreateImageSource(IMAGE_JPG_THREE_GAINMAP_HDR_PATH.c_str(), sourceOpts, errorCode);
+    ASSERT_NE(imageSource, nullptr);
+    DecodeOptions opts;
+    opts.desiredDynamicRange = DecodeDynamicRange::AUTO;
+    opts.photoDesiredPixelFormat = PixelFormat::YCBCR_P010;
+    std::shared_ptr<PixelMap> pixelmap = imageSource->CreatePixelMap(opts, errorCode);
+    ASSERT_EQ(errorCode, OHOS::Media::SUCCESS);
+    ASSERT_NE(pixelmap, nullptr);
+    PixelFormat format = pixelmap->GetPixelFormat();
+    ASSERT_EQ(format, PixelFormat::YCBCR_P010);
+#ifdef IMAGE_COLORSPACE_FLAG
+    pixelmap->InnerSetColorSpace(OHOS::ColorManager::ColorSpace(
+                OHOS::ColorManager::ColorSpaceName::BT709_LIMIT));
+    ASSERT_EQ(pixelmap->IsHdr(), false);
+#endif
+    // init packer to packfile
+    ImagePacker packer;
+    PackOption option;
+    option.format = "image/jpeg";
+    option.needsPackProperties = true;
+    option.desiredDynamicRange = EncodeDynamicRange::AUTO;
+    uint32_t startpc = packer.StartPacking(IMAGE_DEST, option);
+    ASSERT_EQ(startpc, OHOS::Media::SUCCESS);
+    uint32_t retAddImage = packer.AddImage(*pixelmap);
+    ASSERT_EQ(retAddImage, OHOS::Media::SUCCESS);
+    uint32_t retFinalizePacking = packer.FinalizePacking();
+    ASSERT_EQ(retFinalizePacking, OHOS::Media::SUCCESS);
+    std::unique_ptr<ImageSource> imageSourceDest = ImageSource::CreateImageSource(IMAGE_DEST, sourceOpts, errorCode);
+    ASSERT_EQ(errorCode, OHOS::Media::SUCCESS);
+    ASSERT_NE(imageSourceDest, nullptr);
+    DecodeOptions optsForDest;
+    optsForDest.desiredDynamicRange = DecodeDynamicRange::AUTO;
+    std::shared_ptr<PixelMap> pixelmapAfterPacker = imageSourceDest->CreatePixelMap(optsForDest, errorCode);
+    ASSERT_NE(pixelmapAfterPacker, nullptr);
+    ASSERT_EQ(pixelmapAfterPacker->IsHdr(), false);
+    PixelFormat encodeAndDecodeFormat = pixelmapAfterPacker->GetPixelFormat();
+    ASSERT_EQ(encodeAndDecodeFormat, PixelFormat::RGBA_8888);
+#ifdef IMAGE_COLORSPACE_FLAG
+    auto newColorspace = pixelmapAfterPacker->InnerGetGrColorSpace();
+    auto newColorSpaceName = newColorspace.GetColorSpaceName();
+    EXPECT_EQ(newColorSpaceName, ColorManager::ColorSpaceName::SRGB);
+#endif
+}
+
+/**
+*@tc.name: Encode10bit709Test003
+*@tc.desc: Test JPEG decode to YCBCR_P010 format PixelMap and set to BT709 
+*and encode 8bit sdr decode to sdr pixelmap with BT601 colorspace.
+*@tc.type: FUNC
+*/
+HWTEST_F(ExtDecoderTest, Encode10bit709Test003, TestSize.Level3)
+{
+    uint32_t errorCode = 0;
+    SourceOptions sourceOpts;
+    std::unique_ptr<ImageSource> imageSource =
+        ImageSource::CreateImageSource(IMAGE_JPG_THREE_GAINMAP_HDR_PATH.c_str(), sourceOpts, errorCode);
+    ASSERT_NE(imageSource, nullptr);
+    DecodeOptions opts;
+    opts.desiredDynamicRange = DecodeDynamicRange::AUTO;
+    std::shared_ptr<PixelMap> pixelmap = imageSource->CreatePixelMap(opts, errorCode);
+    ASSERT_EQ(errorCode, OHOS::Media::SUCCESS);
+    ASSERT_NE(pixelmap, nullptr);
+#ifdef IMAGE_COLORSPACE_FLAG
+    pixelmap->InnerSetColorSpace(OHOS::ColorManager::ColorSpace(
+                OHOS::ColorManager::ColorSpaceName::BT709));
+    ASSERT_EQ(pixelmap->IsHdr(), false);
+#endif
+    ImagePacker packer;
+    PackOption option;
+    option.format = "image/jpg";
+    option.needsPackProperties = true;
+    option.desiredDynamicRange = EncodeDynamicRange::AUTO;
+    uint32_t startpc = packer.StartPacking(IMAGE_DEST, option);
+    ASSERT_EQ(startpc, OHOS::Media::SUCCESS);
+    uint32_t retAddImage = packer.AddImage(*pixelmap);
+    ASSERT_EQ(retAddImage, OHOS::Media::SUCCESS);
+    uint32_t retFinalizePacking = packer.FinalizePacking();
+    ASSERT_EQ(retFinalizePacking, OHOS::Media::SUCCESS);
+    std::unique_ptr<ImageSource> imageSourceDest = ImageSource::CreateImageSource(IMAGE_DEST, sourceOpts, errorCode);
+    ASSERT_EQ(errorCode, OHOS::Media::SUCCESS);
+    ASSERT_NE(imageSourceDest, nullptr);
+    DecodeOptions optsForDest;
+    optsForDest.desiredDynamicRange = DecodeDynamicRange::AUTO;
+    std::shared_ptr<PixelMap> pixelmapAfterPacker = imageSourceDest->CreatePixelMap(optsForDest, errorCode);
+    ASSERT_NE(pixelmapAfterPacker, nullptr);
+    ASSERT_EQ(pixelmapAfterPacker->IsHdr(), false);
+    PixelFormat encodeAndDecodeFormat = pixelmapAfterPacker->GetPixelFormat();
+    ASSERT_EQ(encodeAndDecodeFormat, PixelFormat::RGBA_1010102);
+#ifdef IMAGE_COLORSPACE_FLAG
+    auto newColorspace = pixelmapAfterPacker->InnerGetGrColorSpace();
+    auto newColorSpaceName = newColorspace.GetColorSpaceName();
+    EXPECT_EQ(newColorSpaceName, ColorManager::ColorSpaceName::SRGB);
+#endif
+}
+
+/**
+*@tc.name: Encode10bit709Test004
+*@tc.desc: Test JPEG decode to YCBCR_P010 format PixelMap and set to BT709 
+*and encode 8bit sdr decode to sdr pixelmap with BT601 colorspace.
+*@tc.type: FUNC
+*/
+HWTEST_F(ExtDecoderTest, Encode10bit709Test004, TestSize.Level3)
+{
+    uint32_t errorCode = 0;
+    SourceOptions sourceOpts;
+    std::unique_ptr<ImageSource> imageSource =
+        ImageSource::CreateImageSource(IMAGE_JPG_THREE_GAINMAP_HDR_PATH.c_str(), sourceOpts, errorCode);
+    ASSERT_NE(imageSource, nullptr);
+    DecodeOptions opts;
+    opts.desiredDynamicRange = DecodeDynamicRange::AUTO;
+    std::shared_ptr<PixelMap> pixelmap = imageSource->CreatePixelMap(opts, errorCode);
+    ASSERT_EQ(errorCode, OHOS::Media::SUCCESS);
+    ASSERT_NE(pixelmap, nullptr);
+#ifdef IMAGE_COLORSPACE_FLAG
+    pixelmap->InnerSetColorSpace(OHOS::ColorManager::ColorSpace(
+                OHOS::ColorManager::ColorSpaceName::BT709));
+    ASSERT_EQ(pixelmap->IsHdr(), false);
+#endif
+    uint32_t ret = ImageFormatConvert::ConvertImageFormat(pixelmap, PixelFormat::RGBA_8888);
+    PixelFormat format = pixelmap->GetPixelFormat();
+    ASSERT_EQ(format, PixelFormat::RGBA_8888);
+    // init packer to packfile
+    ImagePacker packer;
+    PackOption option;
+    option.format = "image/jpeg";
+    option.needsPackProperties = true;
+    option.desiredDynamicRange = EncodeDynamicRange::AUTO;
+    uint32_t startpc = packer.StartPacking(IMAGE_DEST, option);
+    ASSERT_EQ(startpc, OHOS::Media::SUCCESS);
+    uint32_t retAddImage = packer.AddImage(*pixelmap);
+    ASSERT_EQ(retAddImage, OHOS::Media::SUCCESS);
+    uint32_t retFinalizePacking = packer.FinalizePacking();
+    ASSERT_EQ(retFinalizePacking, OHOS::Media::SUCCESS);
+    std::unique_ptr<ImageSource> imageSourceDest = ImageSource::CreateImageSource(IMAGE_DEST, sourceOpts, errorCode);
+    ASSERT_EQ(errorCode, OHOS::Media::SUCCESS);
+    ASSERT_NE(imageSourceDest, nullptr);
+    DecodeOptions optsForDest;
+    optsForDest.desiredDynamicRange = DecodeDynamicRange::AUTO;
+    std::shared_ptr<PixelMap> pixelmapAfterPacker = imageSourceDest->CreatePixelMap(optsForDest, errorCode);
+    ASSERT_NE(pixelmapAfterPacker, nullptr);
+    ASSERT_EQ(pixelmapAfterPacker->IsHdr(), false);
+#ifdef IMAGE_COLORSPACE_FLAG
+    PixelFormat encodeAndDecodeFormat = pixelmapAfterPacker->GetPixelFormat();
+    ASSERT_EQ(encodeAndDecodeFormat, PixelFormat::RGBA_8888);
+    auto newColorspace = pixelmapAfterPacker->InnerGetGrColorSpace();
+    auto newColorSpaceName = newColorspace.GetColorSpaceName();
+    ASSERT_EQ(newColorSpaceName, ColorManager::ColorSpaceName::SRGB);
+#endif
+}
+
+/**
+*@tc.name: Encode10bit709Test002
+*@tc.desc: Test heic decode to YCBCR_P010 format PixelMap and set to BT709 
+*and encode 8bit heic decode to sdr pixelmap with BT601 colorspace.
+*@tc.type: FUNC
+*/
+HWTEST_F(ExtDecoderTest, Encode10bit709Test005, TestSize.Level3)
+{
+    uint32_t errorCode = 0;
+    SourceOptions sourceOpts;
+    std::unique_ptr<ImageSource> imageSource =
+        ImageSource::CreateImageSource(IMAGE_HEIC_THREE_GAINMAP_HDR_PATH.c_str(), sourceOpts, errorCode);
+    ASSERT_NE(imageSource, nullptr);
+    DecodeOptions opts;
+    opts.desiredDynamicRange = DecodeDynamicRange::AUTO;
+    opts.photoDesiredPixelFormat = PixelFormat::YCBCR_P010;
+    std::shared_ptr<PixelMap> pixelmap = imageSource->CreatePixelMap(opts, errorCode);
+    ASSERT_EQ(errorCode, OHOS::Media::SUCCESS);
+    ASSERT_NE(pixelmap, nullptr);
+    PixelFormat format = pixelmap->GetPixelFormat();
+    ASSERT_EQ(format, PixelFormat::YCBCR_P010);
+#ifdef IMAGE_COLORSPACE_FLAG
+    pixelmap->InnerSetColorSpace(OHOS::ColorManager::ColorSpace(
+                OHOS::ColorManager::ColorSpaceName::BT709));
+    ASSERT_EQ(pixelmap->IsHdr(), false);
+#endif
+    // init packer to packfile
+    ImagePacker packer;
+    PackOption option;
+    option.format = "image/heic";
+    option.needsPackProperties = true;
+    option.desiredDynamicRange = EncodeDynamicRange::SDR;
+    uint32_t startpc = packer.StartPacking(IMAGE_DEST, option);
+    ASSERT_EQ(startpc, OHOS::Media::SUCCESS);
+    uint32_t retAddImage = packer.AddImage(*pixelmap);
+    ASSERT_EQ(retAddImage, OHOS::Media::SUCCESS);
+    uint32_t retFinalizePacking = packer.FinalizePacking();
+    ASSERT_EQ(retFinalizePacking, OHOS::Media::SUCCESS);
+    std::unique_ptr<ImageSource> imageSourceDest = ImageSource::CreateImageSource(IMAGE_DEST, sourceOpts, errorCode);
+    ASSERT_EQ(errorCode, OHOS::Media::SUCCESS);
+    ASSERT_NE(imageSourceDest, nullptr);
+    DecodeOptions optsForDest;
+    optsForDest.desiredDynamicRange = DecodeDynamicRange::AUTO;
+    std::shared_ptr<PixelMap> pixelmapAfterPacker = imageSourceDest->CreatePixelMap(optsForDest, errorCode);
+    ASSERT_NE(pixelmapAfterPacker, nullptr);
+    ASSERT_EQ(pixelmapAfterPacker->IsHdr(), false);
+    PixelFormat encodeAndDecodeFormat = pixelmapAfterPacker->GetPixelFormat();
+    ASSERT_EQ(encodeAndDecodeFormat, PixelFormat::RGBA_8888);
+#ifdef IMAGE_COLORSPACE_FLAG
+    auto newColorspace = pixelmapAfterPacker->InnerGetGrColorSpace();
+    auto newColorSpaceName = newColorspace.GetColorSpaceName();
+    ASSERT_EQ(newColorSpaceName, ColorManager::ColorSpaceName::SRGB);
+#endif
+}
+
 /**
  * @tc.name: EncodeWideGamutPixelMapAndDecodeTest001
  * @tc.desc: Test HEIF encoding from a RGBA_1010102 format PixelMap and decode to widegamut image.
@@ -2221,8 +2494,8 @@ HWTEST_F(ExtDecoderTest, EncodeWideGamutPixelMapAndDecodeTest001, TestSize.Level
     ASSERT_NE(pixelmap, nullptr);
 #ifdef IMAGE_COLORSPACE_FLAG
     auto colorSpace = pixelmap->InnerGetGrColorSpace();
-    auto colorSpaceName = outColorSpace.GetColorSpaceName();
-    EXPECT_EQ(colorSpace, ColorManager::colorSPaceName::DISPLAY_BT2020_SRGB);
+    auto colorSpaceName = colorSpace.GetColorSpaceName();
+    EXPECT_EQ(colorSpaceName, ColorManager::ColorSpaceName::DISPLAY_BT2020_SRGB);
 #endif
     ImagePacker packer;
     PackOption option;
@@ -2244,8 +2517,8 @@ HWTEST_F(ExtDecoderTest, EncodeWideGamutPixelMapAndDecodeTest001, TestSize.Level
     std::shared_ptr<PixelMap> pixelmapAfterPacker = imageSourceDest->CreatePixelMap(optsForDest, errorCode);
 #ifdef IMAGE_COLORSPACE_FLAG
     auto newColorspace = pixelmapAfterPacker->InnerGetGrColorSpace();
-    auto newColorSpaceName = outColorSpace.GetColorSpaceName();
-    EXPECT_EQ(colorSpace, ColorManager::colorSPaceName::DISPLAY_BT2020_SRGB);
+    auto newColorSpaceName = newColorspace.GetColorSpaceName();
+    EXPECT_EQ(newColorSpaceName, ColorManager::ColorSpaceName::DISPLAY_BT2020_SRGB);
 #endif
 }
 
@@ -2290,7 +2563,7 @@ HWTEST_F(ExtDecoderTest, EncodeWideGamutPixelMapAndDecodeTest003, TestSize.Level
 #ifdef IMAGE_COLORSPACE_FLAG
     auto colorSpace = pixelmap->InnerGetGrColorSpace();
     auto colorSpaceName = colorSpace.GetColorSpaceName();
-    EXPECT_EQ(colorSpaceName, ColorManager::colorSPaceName::DISPLAY_BT2020_SRGB);
+    EXPECT_EQ(colorSpaceName, ColorManager::ColorSpaceName::DISPLAY_BT2020_SRGB);
 #endif
     ImagePacker packer;
     PackOption option;
@@ -2313,7 +2586,7 @@ HWTEST_F(ExtDecoderTest, EncodeWideGamutPixelMapAndDecodeTest003, TestSize.Level
 #ifdef IMAGE_COLORSPACE_FLAG
     auto newColorspace = pixelmapAfterPacker->InnerGetGrColorSpace();
     auto newColorSpaceName = newColorspace.GetColorSpaceName();
-    EXPECT_EQ(newColorSpaceName, ColorManager::colorSPaceName::DISPLAY_BT2020_SRGB);
+    EXPECT_EQ(newColorSpaceName, ColorManager::ColorSpaceName::DISPLAY_BT2020_SRGB);
 #endif
 }
 
diff --git a/frameworks/innerkitsimpl/utils/include/image_system_properties.h b/frameworks/innerkitsimpl/utils/include/image_system_properties.h
index 2a39390c098be9830ecdc28c214cd5b9575db785..e9a3546a01b05f215bbad7c1e668c680065a2973 100644
--- a/frameworks/innerkitsimpl/utils/include/image_system_properties.h
+++ b/frameworks/innerkitsimpl/utils/include/image_system_properties.h
@@ -29,6 +29,7 @@ public:
     static bool GetDumpPictureEnabled();
     static bool GetHardWareDecodeEnabled();
     static bool GetHardWareEncodeEnabled();
+    static bool GetDumpHdrEnbaled();
     static bool GetHeifHardwareDecodeEnabled();
     static bool GetAstcHardWareEncodeEnabled();
     static bool GetSLRParallelEnabled();
diff --git a/frameworks/innerkitsimpl/utils/include/image_utils.h b/frameworks/innerkitsimpl/utils/include/image_utils.h
index c5ed4728e09144159af25504769978492a627f86..6b1576604f34a0df3c608bc86865b3b683517932 100644
--- a/frameworks/innerkitsimpl/utils/include/image_utils.h
+++ b/frameworks/innerkitsimpl/utils/include/image_utils.h
@@ -69,6 +69,13 @@ public:
     static void DumpPixelMapBeforeEncode(PixelMap& pixelMap);
     static void DumpDataIfDumpEnabled(const char* data, const size_t& totalSize, const std::string& fileSuffix = "dat",
         uint64_t imageId = 0);
+    static void DumpData(const char* data, const size_t& totalSize,
+        const std::string& fileSuffix, uint64_t imageId);
+#if !defined(CROSS_PLATFORM)
+    static bool SurfaceBuffer2PixelMap(sptr<SurfaceBuffer> &surfaceBuffer, std::unique_ptr<PixelMap>& Pixelmap);
+    static void DumpHdrBufferEnabled(sptr<SurfaceBuffer>& buffer, const std::string& fileName);
+#endif
+    static PixelFormat SbFormat2PixelFormat(int32_t sbFormat);
     static uint64_t GetNowTimeMilliSeconds();
     static uint64_t GetNowTimeMicroSeconds();
     static std::string GetCurrentProcessName();
@@ -117,7 +124,7 @@ public:
         int height, const std::shared_ptr<PixelMap> &reusePixelmap);
     static bool IsReuseYUV(ImagePlugin::DecodeContext& context, const std::shared_ptr<PixelMap> &reusePixelmap);
     static bool IsReuseRGB(ImagePlugin::DecodeContext& context, const std::shared_ptr<PixelMap> &reusePixelmap);
-    static bool IsYUV(PixelFormat format);
+    static bool IsYuvFormat(PixelFormat format);
     static bool IsRGBX(PixelFormat format);
     static bool PixelMapCreateCheckFormat(PixelFormat format);
     static bool CheckTlvSupportedFormat(PixelFormat format);
diff --git a/frameworks/innerkitsimpl/utils/include/vpe_utils.h b/frameworks/innerkitsimpl/utils/include/vpe_utils.h
index f781eed163325dbecfffc89a969b58bc639cc054..9ace52600be05096e4612e29e4ef14b8a2043a35 100644
--- a/frameworks/innerkitsimpl/utils/include/vpe_utils.h
+++ b/frameworks/innerkitsimpl/utils/include/vpe_utils.h
@@ -17,6 +17,8 @@
 #define FRAMEWORKS_INNERKITSIMPL_UTILS_INCLUDE_VPE_UTILS_H
 
 #include <mutex>
+#include <string>
+#include <sstream>
 
 #if !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
 #include "v1_0/cm_color_space.h"
@@ -39,6 +41,29 @@ struct VpeSurfaceBuffers {
 };
 #endif
 
+struct SurfaceBufferInfo {
+    int32_t width = 0;
+    int32_t height = 0;
+    int32_t stride = 0;
+    uint8_t *buffer = nullptr;
+    uint32_t bufferSize = 0;
+    // set param if buffer is yuv format
+    int32_t yStride = 0;
+    int32_t uvStride = 0;
+    int32_t yOffset = 0;
+    int32_t uvOffset = 0;
+
+    std::string Tostring() const
+    {
+        std::stringstream message;
+        message << " width: " << width << ", height: " << height << ", stride: " << stride <<
+        ", bufferSize: " << bufferSize << ", yStride: " << yStride << ", uvStride: " << uvStride <<
+        ", yOffset: " << yOffset << ", uvOffset: " << uvOffset;
+        return message.str();
+    }
+};
+
+
 class VpeUtils {
 public:
     VpeUtils();
@@ -49,6 +74,7 @@ public:
     int32_t ColorSpaceCalGainmap(VpeSurfaceBuffers& sb);
     int32_t ColorSpaceConverterImageProcess(sptr<SurfaceBuffer>& input, sptr<SurfaceBuffer>& output);
     int32_t DetailEnhancerImageProcess(sptr<SurfaceBuffer>& input, sptr<SurfaceBuffer>& output, int32_t level);
+    int32_t TruncateBuffer(VpeSurfaceBuffers& sb, bool shouldCalDiff = false);
     static bool SetSbColorSpaceType(sptr<SurfaceBuffer>& buffer,
         const HDI::Display::Graphic::Common::V1_0::CM_ColorSpaceType& colorSpaceType);
     static bool GetSbColorSpaceType(const sptr<SurfaceBuffer>& buffer,
diff --git a/frameworks/innerkitsimpl/utils/src/image_system_properties.cpp b/frameworks/innerkitsimpl/utils/src/image_system_properties.cpp
index eb890dfc5bc1bb967ccdb3b9646789e01d579d43..e40e920fc4fe8066e9d4c78d51626cab0f49b8fd 100644
--- a/frameworks/innerkitsimpl/utils/src/image_system_properties.cpp
+++ b/frameworks/innerkitsimpl/utils/src/image_system_properties.cpp
@@ -162,6 +162,15 @@ bool ImageSystemProperties::GetHeifHardwareDecodeEnabled()
 #endif
 }
 
+bool ImageSystemProperties::GetDumpHdrEnbaled()
+{
+#if !defined(IOS_PLATFORM) &&!defined(ANDROID_PLATFORM)
+    return system::GetBoolParameter("persist.multimedia.image.DumpHdrImage.enabled", false);
+#else
+    return false;
+#endif
+}
+
 bool ImageSystemProperties::GetAstcHardWareEncodeEnabled()
 {
 #if !defined(IOS_PLATFORM) &&!defined(ANDROID_PLATFORM)
diff --git a/frameworks/innerkitsimpl/utils/src/image_utils.cpp b/frameworks/innerkitsimpl/utils/src/image_utils.cpp
index 9045e31bf6845064285905a4c0089e3e266c633a..b9b7a0584ffb75da562e3c70aa0c13c404b0c886 100644
--- a/frameworks/innerkitsimpl/utils/src/image_utils.cpp
+++ b/frameworks/innerkitsimpl/utils/src/image_utils.cpp
@@ -77,6 +77,7 @@ namespace OHOS {
 namespace Media {
 using namespace std;
 using namespace MultimediaPlugin;
+using namespace HDI:Display::Graphic::Common::V1_0;
 
 constexpr int32_t ALPHA8_BYTES = 1;
 constexpr int32_t RGB565_BYTES = 2;
@@ -239,7 +240,7 @@ static AVPixelFormat PixelFormatToAVPixelFormat(const PixelFormat &pixelFormat)
 
 int32_t ImageUtils::GetYUVByteCount(const ImageInfo& info)
 {
-    if (!IsYUV(info.pixelFormat)) {
+    if (!IsYuvFormat(info.pixelFormat)) {
         IMAGE_LOGE("[ImageUtil]unsupported pixel format");
         return -1;
     }
@@ -260,7 +261,7 @@ int32_t ImageUtils::GetByteCount(ImageInfo imageInfo)
     if (ImageUtils::IsAstc(imageInfo.pixelFormat)) {
         return static_cast<int32_t>(ImageUtils::GetAstcBytesCount(imageInfo));
     }
-    if (IsYUV(imageInfo.pixelFormat)) {
+    if (IsYuvFormat(imageInfo.pixelFormat)) {
         return GetYUVByteCount(imageInfo);
     }
     int64_t rowDataSize =
@@ -465,7 +466,7 @@ bool IsYUV10Bit(PixelFormat &format)
     return format == PixelFormat::YCBCR_P010 || format == PixelFormat::YCRCB_P010;
 }
 
-bool ImageUtils::IsYUV(PixelFormat format)
+bool ImageUtils::IsYuvFormat(PixelFormat format)
 {
     return IsYUV8Bit(format) || IsYUV10Bit(format);
 }
@@ -484,7 +485,7 @@ bool ImageUtils::PixelMapCreateCheckFormat(PixelFormat format)
     if (IsRGBX(format)) {
         return true;
     }
-    if (IsYUV(format)) {
+    if (IsYuvFormat(format)) {
         return true;
     }
     return false;
@@ -686,12 +687,9 @@ void ImageUtils::DumpPixelMapBeforeEncode(PixelMap& pixelMap)
     DumpPixelMap(&pixelMap, "_beforeEncode");
 }
 
-void ImageUtils::DumpDataIfDumpEnabled(const char* data, const size_t& totalSize,
+void ImageUtils::DumpData(const char* data, const size_t& totalSize,
     const std::string& fileSuffix, uint64_t imageId)
 {
-    if (!ImageSystemProperties::GetDumpImageEnabled()) {
-        return;
-    }
     std::string fileName = FILE_DIR_IN_THE_SANDBOX + GetLocalTime() + "_imageId" + std::to_string(imageId) +
         "_data_total" + std::to_string(totalSize) + "." + fileSuffix;
     if (SUCCESS != SaveDataToFile(fileName, data, totalSize)) {
@@ -701,6 +699,138 @@ void ImageUtils::DumpDataIfDumpEnabled(const char* data, const size_t& totalSize
     IMAGE_LOGI("ImageUtils::DumpDataIfDumpEnabled success, path = %{public}s", fileName.c_str());
 }
 
+void ImageUtils::DumpDataIfDumpEnabled(const char* data, const size_t& totalSize,
+    const std::string& fileSuffix, uint64_t imageId)
+{
+    if (!ImageSystemProperties::GetDumpImageEnabled()) {
+        return;
+    }
+    DumpData(data, totalSize, fileSuffix, imageId);
+}
+
+#if !defined(CROSS_PLATFORM)
+void ImageUtils::DumpHdrBufferEnabled(sptr<SurfaceBuffer>& buffer, const std::string& fileName)
+{
+    bool cond = !ImageSystemProperties::GetDumpHdrEnabled() || buffer == nullptr;
+    CHECK_ERROR_RETURN(cond);
+    uint32_t bufferSize = static_cast<int32_t>(buffer->GetSize());
+    std::string fileSuffix = fileName + "-format-" + std::to_string(buffer->GetFormat()) + "-Width-"
+        + std::to_string(buffer->GetWidth()) + "-Height-" + std::to_string(buffer->GetWidth()) + "-Stride-"
+        + std::to_string(buffer->GetStride()) + ".dat";
+    std::vector<uint8_t> staticMetadata;
+    std::vector<uint8_t> dynamicMetadata;
+    buffer->GetMetadata(HDI::Display::Graphic::Common::V1_0::ATTRKEY_HDR_STATIC_METADATA, staticMetadata);
+    buffer->GetMetadata(HDI::Display::Graphic::Common::V1_0::ATTRKEY_HDR_DYNAMIC_METADATA, dynamicMetadata);
+    DumpData(reinterpret_cast<const char*>(buffer->GetVirAddr()), bufferSize, fileSuffix, 0);
+    DumpData(reinterpret_cast<const char*>(staticMetadata.data()), staticMetadata.size(), fileSuffix, 0);
+    DumpData(reinterpret_cast<const char*>(dynamicMetadata.data()), dynamicMetadata.size(), fileSuffix, 0);
+}
+
+static bool IsAlphaFormat(PixelFormat format)
+{
+    return format == PixelFormat::RGBA_8888 || format == PixelFormat::BGRA_8888 ||
+        format == PixelFormat::RGBA_1010102 || format == PixelFormat::RGBA_F16;
+}
+
+static PixelFormat SbFormat2PixelFormat(int32_t sbFormat)
+{
+    auto iter = PIXEL_FORMAT_MAP.find(sbFormat);
+    if (iter == PIXEL_FORMAT_MAP.end()) {
+        return PixelFormat::UNKNOWN;
+    }
+    return iter->second;
+}
+
+static CM_ColorSpaceType GetCMColorSpaceType(sptr<SurfaceBuffer>& buffer)
+{
+    CHECK_ERROR_RETURN_RET(buffer == nullptr, CM_ColorSpaceType::CM_COLORSPACE_NONE);
+    CM_ColorSpaceType type;
+    MetadataHelper::GetColorSpaceType(buffer, type);
+    return type;
+}
+
+static ColorSpace CMColorSpaceType2ColorSpace(CM_ColorSpaceType type)
+{
+    auto iter = CM_COLORSPACE_MAP.find(type);
+    CHECK_ERROR_RETURN_RET(iter == CM_COLORSPACE_MAP.end(), ColorSpace::UNKNOWN);
+    return iter->second;
+}
+
+#ifdef IMAGE_COLORSPACE_FLAG
+static ColorManager::ColorSpaceName CMColorSpaceType2ColorSpaceName(CM_ColorSpaceType type)
+{
+    auto iter = CM_COLORSPACE_NAME_MAP.find(type);
+    CHECK_ERROR_RETURN_RET(iter == CM_COLORSPACE_NAME_MAP.end(), ColorManager::NONE);
+    return iter->second;
+}
+#endif
+
+static ImageInfo MakeImageInfo(int width, int height, PixelFormat pf, AlphaType at, ColorSpace cs)
+{
+    ImageInfo info;
+    info.size.width = width;
+    info.size.height = height;
+    info.pixelFormat = pf;
+    info.alphaType = at;
+    info.colorSpace = cs;
+    return info;
+}
+
+static void SetYuvDataInfo(std::unique_ptr<PixelMap> &pixelmap, sptr<OHOS::SurfaceBuffer>& sBuffer)
+{
+    bool cond = pixelmap == nullptr || sBuffer == nullptr;
+    CHECK_ERROR_RETURN(cond);
+    int32_t width = sBuffer->GetWidth();
+    int32_t height = sBuffer->GetHeight();
+    OH_NativeBuffer_Planes *planes = nullptr;
+    GSError retVal = sBuffer->GetPlanesInfo(reinterpret_cast<void**>(&planes));
+    YUVDataInfo info;
+    info.imageSize = { width, height };
+    cond = retVal != OHOS::GSERROR_OK || planes == nullptr || planes->planeCount <= NUM_1;
+    CHECK_ERROR_RETURN_LOG(cond, "Get planesInfo failed, retVal:%{public}d", retVal);
+    if (planes->planeCount >= NUM_2) {
+        info.yWidth = static_cast<uint32_t>(info.imageSize.width);
+        info.yHeight = static_cast<uint32_t>(info.imageSize.height);
+        info.yStride = planes->planes[NUM_0].columnStride;
+        info.uvStride = planes->planes[NUM_1].columnStride;
+        info.yOffset = planes->planes[NUM_0].offset;
+        info.uvOffset = planes->planes[NUM_1].offset - NUM_1;
+    }
+    pixelmap->SetImageYUVInfo(info);
+}
+
+bool ImageUtils::SurfaceBuffer2PixelMap(sptr<OHOS::SurfaceBuffer> &surfaceBuffer, std::unique_ptr<PixelMap> &Pixelmap)
+{
+    if (surfaceBuffer == nullptr || Pixelmap == nullptr) {
+        return false;
+    }
+    PixelFormat pixelFormat = ImageUtils::SbFormat2PixelFormat(surfaceBuffer->GetFormat());
+    ColorSpace colorSpace = CMColorSpaceType2ColorSpace(GetCMColorSpaceType(surfaceBuffer));
+    AlphaType alphaType = IsAlphaFormat(pixelFormat) ?
+             AlphaType::IMAGE_ALPHA_TYPE_PREMUL : AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
+    void* nativeBuffer = surfaceBuffer.GetRefPtr();
+    int32_t err = ImageUtils::SurfaceBuffer_Reference(nativeBuffer);
+    CHECK_ERROR_RETURN_RET_LOG(err != OHOS::GSERROR_OK, false, "NativeBufferReference failed");
+
+    ImageInfo imageInfo = MakeImageInfo(surfaceBuffer->GetWidth(),
+                                        surfaceBuffer->GetHeight(), pixelFormat, alphaType, colorSpace);
+    Pixelmap->SetImageInfo(imageInfo, true);
+    Pixelmap->SetPixelsAddr(surfaceBuffer->GetVirAddr(),
+                            nativeBuffer, Pixelmap->GetRowBytes() * Pixelmap->GetHeight(),
+                            AllocatorType::DMA_ALLOC, nullptr);
+#ifdef IMAGE_COLORSPACE_FLAG
+    ColorManager::ColorSpaceName colorSpaceName =
+        CMColorSpaceType2ColorSpaceName(GetCMColorSpaceType(surfaceBuffer));
+    Pixelmap->InnerSetColorSpace(ColorManager::ColorSpace(colorSpaceName));
+#endif
+    if (ImageUtils::IsYuvFormat(pixelFormat)) {
+        SetYuvDataInfo(Pixelmap, surfaceBuffer);
+    }
+    return true;
+}
+
+#endif
+
 uint64_t ImageUtils::GetNowTimeMilliSeconds()
 {
     auto now = std::chrono::system_clock::now();
diff --git a/frameworks/innerkitsimpl/utils/src/vpe_utils.cpp b/frameworks/innerkitsimpl/utils/src/vpe_utils.cpp
index b73d26f4b1066ae6e861d4712624021e5349b45b..52ab0ea7fcc9f73fd1a24e1bf1c2874648a24bbd 100644
--- a/frameworks/innerkitsimpl/utils/src/vpe_utils.cpp
+++ b/frameworks/innerkitsimpl/utils/src/vpe_utils.cpp
@@ -40,9 +40,21 @@ using namespace OHOS::HDI::Display::Graphic::Common::V1_0;
 static constexpr uint32_t TRANSFUNC_OFFSET = 8;
 static constexpr uint32_t MATRIX_OFFSET = 16;
 static constexpr uint32_t RANGE_OFFSET = 21;
+static constexpr uint32_t RGBA1010102_G_SHIFT = 10;
+static constexpr uint32_t RGBA1010102_B_SHIFT = 20;
+static constexpr uint32_t RGBA8888_G_SHIFT = 8;
+static constexpr uint32_t RGBA8888_B_SHIFT = 16;
+static constexpr uint32_t RGBA8888_A_SHIFT = 24;
+static constexpr uint32_t TRUNCAT_BIT = 2;
+static constexpr uint8_t P010_TO_YUV420_SHIFT = 8;
+static constexpr uint8_t YUV420_CHROMA_DIVIDER = 2;
+static constexpr uint8_t CHROMA_V_INDEX = 1;
+
 constexpr uint8_t INDEX_ZERO = 0;
 constexpr uint8_t INDEX_ONE = 1;
 constexpr uint8_t INDEX_TWO = 2;
+static constexpr int32_t PLANE_U = 1;
+static constexpr int32_t PLANE_V = 2;
 #endif
 const static char* VPE_SO_NAME = "libvideoprocessingengine.z.so";
 void* VpeUtils::dlHandler_ = nullptr;
@@ -155,10 +167,8 @@ int32_t VpeUtils::ColorSpaceConverterComposeImage(VpeSurfaceBuffers& sb, bool le
     if (dlHandler_ == nullptr) {
         return VPE_ERROR_FAILED;
     }
-    
-    int32_t res;
     int32_t instanceId = VPE_ERROR_FAILED;
-    res = ColorSpaceConverterCreate(dlHandler_, &instanceId);
+    int32_t res = ColorSpaceConverterCreate(dlHandler_, &instanceId);
     if (instanceId == VPE_ERROR_FAILED || res != VPE_ERROR_OK) {
         return VPE_ERROR_FAILED;
     }
@@ -213,6 +223,167 @@ int32_t VpeUtils::ColorSpaceConverterDecomposeImage(VpeSurfaceBuffers& sb)
     return res;
 }
 
+
+void DoTruncateP010ToYUV420(const SurfaceBufferInfo& srcInfo, const SurfaceBufferInfo& outInfo)
+{
+    bool cond = srcInfo.buffer == nullptr || outInfo.buffer == nullptr;
+    CHECK_ERROR_RETURN(cond);
+    uint8_t* srcY = srcInfo.buffer + srcInfo.yOffset;
+    uint8_t* srcUV = srcInfo.buffer + srcInfo.uvOffset;
+    uint8_t* dstY = outInfo.buffer + outInfo.yOffset;
+    uint8_t* dstUV = outInfo.buffer + outInfo.uvOffset;
+
+    // compute stride
+    const int32_t srcYStride = srcInfo.yStride > 0 ? srcInfo.yStride : srcInfo.stride;
+    const int32_t srcUVStride = srcInfo.uvStride > 0 ? srcInfo.uvStride : srcInfo.stride;
+    const int32_t dstYStride = outInfo.yStride > 0 ? outInfo.yStride : outInfo.stride;
+    const int32_t dstUVStride = outInfo.uvStride > 0 ? outInfo.uvStride : outInfo.stride;
+
+    // transfer y : p010 (10-bit) - > yuv420 (8-bit)
+    for (int32_t y = 0; y < srcInfo.height; y++) {
+        const uint16_t* srcYLine = reinterpret_cast<const uint16_t*>(srcY + y *srcYStride);
+        uint8_t* dstYLine = dstY + y * dstYStride;
+
+        for (int32_t x = 0; x < srcInfo.width; x++) {
+            uint16_t p010Pixel = srcYLine[x];
+            uint8_t yuv420Pixel = static_cast<uint8_t>((p010Pixel >> P010_TO_YUV420_SHIFT) & 0xFF);
+            dstYLine[x] = yuv420Pixel;
+        }
+    }
+    const int32_t uvWidth = srcInfo.width / YUV420_CHROMA_DIVIDER;
+    const int32_t uvHeight = srcInfo.height / YUV420_CHROMA_DIVIDER;
+
+    // tranfer uv : P010 (10-bit) - > YUV420 (8-bit) 420
+    for (int32_t y = 0; y < uvHeight; y++) {
+        const uint16_t* srcUVLine = reinterpret_cast<const uint16_t*>(srcY + y *srcYStride);
+        uint8_t* dstUVLine = dstUV + y * dstUVStride;
+
+        // same as vu
+        for (int32_t x = 0; x < uvWidth; x++) {
+            uint16_t p010U = srcUVLine[YUV420_CHROMA_DIVIDER * x];
+            uint8_t yuv420U = static_cast<uint8_t>((p010U >> P010_TO_YUV420_SHIFT) & 0xFF);
+
+            uint16_t p010V = srcUVLine[YUV420_CHROMA_DIVIDER * x + CHROMA_V_INDEX];
+            uint8_t yuv420V = static_cast<uint8_t>((p010V >> P010_TO_YUV420_SHIFT) & 0xFF);
+
+            dstUVLine[YUV420_CHROMA_DIVIDER * x] = yuv420U;
+            dstUVLine[YUV420_CHROMA_DIVIDER * x + CHROMA_V_INDEX] = yuv420V;
+        }
+    }
+}
+
+void DoTruncateRGBA1010102ToRGBA8888(const SurfaceBufferInfo& srcInfo, const SurfaceBufferInfo& dstInfo)
+{
+    bool cond = srcInfo.buffer == nullptr || dstInfo.buffer == nullptr;
+    CHECK_ERROR_RETURN(cond);
+    for (int32_t y = 0; y < dstInfo.height; ++y) {
+        const uint32_t* srcRow = reinterpret_cast<const uint32_t*>(
+            srcInfo.buffer + y * srcInfo.stride);
+        uint32_t* dstRow = reinterpret_cast<uint32_t*>(
+            dstInfo.buffer + y * dstInfo.stride);
+
+        for (int x = 0; x < dstInfo.width; ++x) {
+            uint32_t pixel = srcRow[x];
+            // get 10-bit R G B
+            uint32_t rPixel = (pixel & 0x3FF);
+            uint32_t gPixel = ((pixel >> RGBA1010102_G_SHIFT) & 0x3FF);
+            uint32_t bPixel = ((pixel >> RGBA1010102_B_SHIFT) & 0x3FF);
+            uint32_t aPixel = 0xFF;
+            // transfer to RGBA_8888 [r8 g8 b8 a8]
+            dstRow[x] = (rPixel >> TRUNCAT_BIT) | ((gPixel >> TRUNCAT_BIT) << RGBA8888_G_SHIFT)
+                | ((bPixel >> TRUNCAT_BIT) << RGBA8888_B_SHIFT) | (aPixel << RGBA8888_A_SHIFT);
+        }
+    }
+}
+
+int32_t TruncateRGBA1010102ToRGBA8888(VpeSurfaceBuffers& buffers, bool shouldCalDiff)
+{
+    int32_t res = VPE_ERROR_OK;
+    SurfaceBufferInfo srcInfo = {buffers.hdr->GetWidth(), buffers.hdr->GetHeight(), buffers.hdr->GetStride(),
+        static_cast<uint8_t*>(buffers.hdr->GetVirAddr()), buffers.hdr->GetSize()};
+    SurfaceBufferInfo dstInfo = {buffers.sdr->GetWidth(), buffers.sdr->GetHeight(), buffers.sdr->GetStride(),
+        static_cast<uint8_t*>(buffers.sdr->GetVirAddr()), buffers.sdr->GetSize()};
+    if (shouldCalDiff) {
+        bool cond = buffers.sdr == nullptr || buffers.sdr == nullptr;
+        CHECK_ERROR_RETURN_RET(cond, false);
+        DoTruncateRGBA1010102ToRGBA8888(srcInfo, dstInfo);
+    } else {
+        res = VPE_ERROR_FAILED;
+    }
+    return res;
+}
+
+SurfaceBufferInfo GetSurfaceBufferInfo(sptr<SurfaceBuffer>& buffer)
+{
+    SurfaceBufferInfo info;
+    if (buffer == nullptr) {
+        return info;
+    }
+    bool cond = buffer == nullptr;
+    CHECK_ERROR_RETURN_RET_LOG(cond, info, "buffer get null source buffer");
+    OH_NativeBuffer_Planes *planes = nullptr;
+    info = {buffer->GetWidth(), buffer->GetHeight(), buffer->GetStride(),
+        static_cast<uint8_t*>(buffer->GetVirAddr()), buffer->GetSize(), buffer->GetStride(),
+        buffer->GetStride()};
+    auto pixelFmt = buffer->GetFormat();
+    uint32_t uvPlaneOffset = (pixelFmt == GRAPHIC_PIXEL_FMT_YCBCR_420_SP || pixelFmt == GRAPHIC_PIXEL_FMT_YCBCR_P010) ?
+        PLANE_U : PLANE_V;
+    if ((buffer->GetPlanesInfo(reinterpret_cast<void**>(&planes)) == OHOS::SURFACE_ERROR_OK) &&
+        (planes != nullptr)) {
+        // plane nums > 1, which indicates has yuv plane
+        if (planes->planeCount > 1) {
+            info.uvOffset = planes->planes[uvPlaneOffset].offset;
+        }
+    }
+    return info;
+}
+
+int32_t TruncateP010ToYUV420(VpeSurfaceBuffers& buffers, bool shouldCalDiff)
+{
+    int32_t res = VPE_ERROR_OK;
+    SurfaceBufferInfo srcInfo = GetSurfaceBufferInfo(buffers.hdr);
+    SurfaceBufferInfo dstInfo = GetSurfaceBufferInfo(buffers.hdr);
+    IMAGE_LOGD("do TruncateP010ToYUV420 srcInfo %{public}s", srcInfo.Tostring().c_str());
+    IMAGE_LOGD("do TruncateP010ToYUV420 outInfo %{public}s", dstInfo.Tostring().c_str());
+    if (shouldCalDiff) {
+        bool cond = buffers.hdr == nullptr || buffers.sdr == nullptr;
+        CHECK_ERROR_RETURN_RET(cond, false);
+        DoTruncateP010ToYUV420(srcInfo, dstInfo);
+    } else {
+        res = VPE_ERROR_FAILED;
+    }
+    return res;
+}
+
+int32_t VpeUtils::TruncateBuffer(VpeSurfaceBuffers& buffers, bool shouldCalDiff)
+{
+    int32_t res = VPE_ERROR_OK;
+#ifdef IMAGE_VPE_FLAG
+    bool cond = buffers.hdr == nullptr || buffers.sdr == nullptr;
+    CHECK_ERROR_RETURN_RET(cond, VPE_ERROR_FAILED);
+    cond = buffers.hdr->GetWidth() != buffers.sdr->GetWidth() || buffers.hdr->GetHeight() != buffers.sdr->GetHeight();
+    CHECK_ERROR_RETURN_RET_LOG(cond, VPE_ERROR_FAILED, "TruncateBuffer get input of different sizes");
+    GraphicPixelFormat srcPixelFormat = static_cast<GraphicPixelFormat>(buffers.hdr->GetFormat());
+    if (shouldCalDiff) {
+        bool cond = buffers.hdr == nullptr || buffers.sdr == nullptr;
+        CHECK_ERROR_RETURN_RET(cond, false);
+        if (srcPixelFormat == GRAPHIC_PIXEL_FMT_YCRCB_P010 || srcPixelFormat == GRAPHIC_PIXEL_FMT_YCBCR_P010) {
+            TruncateP010ToYUV420(buffers, shouldCalDiff);
+        } else {
+            TruncateRGBA1010102ToRGBA8888(buffers, shouldCalDiff);
+        }
+    } else {
+        IMAGE_LOGE("do TruncateBuffer with not surpport format");
+        return VPE_ERROR_FAILED;
+    }
+    VpeUtils::SetSbColorSpaceType(buffers.hdr, colorSpaceType);
+    cond = res != VPE_ERROR_OK;
+    CHECK_ERROR_RETURN_RET_LOG(cond, VPE_ERROR_FAILED, "TruncateImage shouldCalDiff [%{public}d]"
+        "failed, res = %{public}d", shouldCalDiff, res);
+#endif
+    return res;
+}
+
 int32_t VpeUtils::ColorSpaceCalGainmap(VpeSurfaceBuffers& sb)
 {
     int32_t res = VPE_ERROR_OK;
diff --git a/interfaces/innerkits/BUILD.gn b/interfaces/innerkits/BUILD.gn
index d2072fae07a4a67944315d7214e56a8593758084..3ae1f01914efb5603a3a0f8707e563390568fa0b 100644
--- a/interfaces/innerkits/BUILD.gn
+++ b/interfaces/innerkits/BUILD.gn
@@ -255,6 +255,7 @@ if (use_clang_android) {
         "drivers_interface_display:libdisplay_commontype_proxy_1.0",
         "drivers_interface_display:libdisplay_composer_proxy_1.2",
         "drivers_interface_display:libhdifd_parcelable",
+        "hitrace:hitrace_meter",
         "ffmpeg:libohosffmpeg",
         "ffrt:libffrt",
         "hilog:libhilog",
diff --git a/interfaces/innerkits/include/image_format_convert.h b/interfaces/innerkits/include/image_format_convert.h
index 154b3302fa227644611cd290190d19bbb716a7fc..0dcf93595c72d9e2082bc7291b55db5be318e994 100644
--- a/interfaces/innerkits/include/image_format_convert.h
+++ b/interfaces/innerkits/include/image_format_convert.h
@@ -46,17 +46,17 @@ class ImageFormatConvert {
     friend class ImageFormatConvertTest;
 public:
     static uint32_t ConvertImageFormat(const ConvertDataInfo &srcDataInfo, DestConvertInfo &destInfo);
-    static uint32_t ConvertImageFormat(std::shared_ptr<PixelMap> &srcPiexlMap, PixelFormat destFormat);
+    static uint32_t ConvertImageFormat(std::shared_ptr<PixelMap> &srcPixelMap, PixelFormat destFormat);
     static uint32_t MakeDestPixelMapUnique(std::unique_ptr<PixelMap> &destPixelMap,
         ImageInfo &srcImageinfo, DestConvertInfo &destInfo, void *context);
-    static uint32_t RGBConvertImageFormatOptionUnique(std::unique_ptr<PixelMap> &srcPiexlMap,
+    static uint32_t RGBConvertImageFormatOptionUnique(std::unique_ptr<PixelMap> &srcPixelMap,
         const PixelFormat &srcFormat, PixelFormat destFormat);
     static bool SetConvertImageMetaData(std::unique_ptr<PixelMap> &srcPixelMap, std::unique_ptr<PixelMap> &dstPixelMap);
     static bool SetConvertImageMetaData(std::shared_ptr<PixelMap> &srcPixelMap, std::unique_ptr<PixelMap> &dstPixelMap);
 private:
     static bool IsValidSize(const Size &size);
     static bool CheckConvertDataInfo(const ConvertDataInfo &convertDataInfo);
-    static uint32_t YUVConvertImageFormatOption(std::shared_ptr<PixelMap> &srcPiexlMap, const PixelFormat &srcFormat,
+    static uint32_t YUVConvertImageFormatOption(std::shared_ptr<PixelMap> &srcPixelMap, const PixelFormat &srcFormat,
                                                 PixelFormat destFormat);
     static size_t GetBufferSizeByFormat(PixelFormat format, const Size &size);
     static ConvertFunction GetConvertFuncByFormat(PixelFormat srcFormat, PixelFormat destFormat);
@@ -67,7 +67,7 @@ private:
     static std::unique_ptr<AbsMemory> CreateMemory(PixelFormat pixelFormat,
                                                    AllocatorType allocatorType, Size size,
                                                    YUVStrideInfo &strides, uint64_t usage = 0);
-    static uint32_t RGBConvertImageFormatOption(std::shared_ptr<PixelMap> &srcPiexlMap,
+    static uint32_t RGBConvertImageFormatOption(std::shared_ptr<PixelMap> &srcPixelMap,
                                                 const PixelFormat &srcFormat, PixelFormat destFormat);
     static uint32_t YUVConvert(const ConvertDataInfo &srcDataInfo, DestConvertInfo &destInfo);
     static uint32_t RGBConvert(const ConvertDataInfo &srcDataInfo, DestConvertInfo &destInfo);
diff --git a/plugins/common/libs/image/libextplugin/include/ext_encoder.h b/plugins/common/libs/image/libextplugin/include/ext_encoder.h
index 6e1c56133ea2a0c0f850763cddfc5537cb276e17..8bf45bf2915f683cad2e44ad30d9103ec6b76be0 100644
--- a/plugins/common/libs/image/libextplugin/include/ext_encoder.h
+++ b/plugins/common/libs/image/libextplugin/include/ext_encoder.h
@@ -80,6 +80,9 @@ private:
     sptr<SurfaceBuffer> ConvertPixelMapToDmaBuffer(std::shared_ptr<PixelMap> pixelmap);
     uint32_t EncodeSdrImage(ExtWStream& outputStream);
     uint32_t EncodeDualVivid(ExtWStream& outputStream);
+
+    uint32_t Encode10bitSdrPixelMap(Media::PixelMap* pixelmap, ExtWStream& outputStream);
+
     uint32_t EncodeSingleVivid(ExtWStream& outputStream);
     uint32_t EncodePicture();
     uint32_t EncodeCameraScenePicture(SkWStream& skStream);
@@ -107,7 +110,7 @@ private:
     void SetHdrColorSpaceType(sptr<SurfaceBuffer>& surfaceBuffer);
 #endif
     uint32_t EncodeImageByBitmap(SkBitmap& bitmap, bool needExif, SkWStream& outStream);
-    uint32_t EncodeImageByPixelMap(Media::PixelMap* pixelMap, bool needExif, SkWStream& outputStream);
+    uint32_t EncodeImageByPixelMap(Media::PixelMap* pixelmap, bool needExif, SkWStream& outputStream);
 #ifdef HEIF_HW_ENCODE_ENABLE
     std::shared_ptr<HDI::Codec::Image::V2_1::ImageItem> AssembleTmapImageItem(ColorManager::ColorSpaceName color,
         Media::HdrMetadata metadata, const PlEncodeOptions &opts);
diff --git a/plugins/common/libs/image/libextplugin/src/ext_encoder.cpp b/plugins/common/libs/image/libextplugin/src/ext_encoder.cpp
index e85cbfcf5efa456dfde0a0d459536970ae247f1b..ceed0f6353a50cae6eeee807490a2ed633ce126a 100644
--- a/plugins/common/libs/image/libextplugin/src/ext_encoder.cpp
+++ b/plugins/common/libs/image/libextplugin/src/ext_encoder.cpp
@@ -27,6 +27,8 @@
 #include "src/images/SkImageEncoderFns.h"
 #endif
 #include "include/core/SkBitmap.h"
+#include "pixel_yuv.h"
+#include "pixel_yuv_ext.h"
 #include "pixel_yuv_utils.h"
 #ifdef IMAGE_COLORSPACE_FLAG
 #include "color_space.h"
@@ -60,6 +62,7 @@
 #include "v2_1/cm_color_space.h"
 #include "vpe_utils.h"
 #include "hdr_helper.h"
+#include "metadata_helper.h"
 #endif
 #include "color_utils.h"
 #include "tiff_parser.h"
@@ -126,6 +129,7 @@ const std::map<PixelFormat, GraphicPixelFormat> SURFACE_FORMAT_MAP = {
         { CM_DISPLAY_BT2020_HLG, ColorManager::DISPLAY_BT2020_HLG },
         { CM_DISPLAY_BT2020_PQ, ColorManager::DISPLAY_BT2020_PQ },
     };
+
 #endif
 
 #endif
@@ -450,7 +454,7 @@ static uint32_t CreateAndWriteBlob(MetadataWStream &tStream, PixelMap *pixelmap,
     return SUCCESS;
 }
 
-bool IsWideGamutSdrPixelMap(Media::PixelMap *pixelmap)
+bool IsWideGamutSdrPixelMap(Media::PixelMap* pixelmap)
 {
 #ifdef IMAGE_COLORSPACE_FLAG
     return pixelmap->InnerGetGrColorSpace().GetColorSpaceName() ==
@@ -460,6 +464,21 @@ bool IsWideGamutSdrPixelMap(Media::PixelMap *pixelmap)
 #endif
 }
 
+bool IsHdrColorSpace(Media::PixelMap* pixelmap)
+{
+#ifdef IMAGE_COLORSPACE_FLAG
+    OHOS::ColorManager::ColorSpace colorSpace = pixelmap->InnerGetGrColorSpace();
+    if (colorSpace.GetColorSpaceName() != ColorManager::BT2020 &&
+        colorSpace.GetColorSpaceName() != ColorManager::BT2020_HLG &&
+        colorSpace.GetColorSpaceName() != ColorManager::BT2020_PQ &&
+        colorSpace.GetColorSpaceName() != ColorManager::BT2020_HLG_LIMIT &&
+        colorSpace.GetColorSpaceName() != ColorManager::BT2020_PQ_LIMIT) {
+        return false;
+    }
+#endif
+    return true;
+}
+
 uint32_t ExtEncoder::PixelmapEncode(ExtWStream& wStream)
 {
     uint32_t error;
@@ -472,6 +491,9 @@ uint32_t ExtEncoder::PixelmapEncode(ExtWStream& wStream)
             if ((pixelmap_->IsHdr() || IsWideGamutSdrPixelMap(pixelmap_)) &&
                 (encodeFormat_ == SkEncodedImageFormat::kJPEG || encodeFormat_ == SkEncodedImageFormat::kHEIF)) {
                 error = EncodeDualVivid(wStream);
+            } else if (pixelmap_->GetAllocatorType() == AllocatorType::DMA_ALLOC &&
+                ImageUtils::Is10Bit(pixelmap_->GetPixelFormat()) && !IsHdrColorSpace(pixelmap_)) {
+                error = Encode10bitSdrPixelMap(pixelmap_, wStream);
             } else {
                 error = EncodeSdrImage(wStream);
             }
@@ -668,29 +690,45 @@ uint32_t ExtEncoder::EncodeImageByBitmap(SkBitmap& bitmap, bool needExif, SkWStr
     return CreateAndWriteBlob(tStream, pixelmap_, outStream, imageInfo, opts_);
 }
 
-uint32_t ExtEncoder::EncodeImageByPixelMap(PixelMap* pixelMap, bool needExif, SkWStream& outputStream)
+bool ApplyColorSpaceBeforeEncode(PixelMap* pixelmap)
+{
+#ifdef IMAGE_COLORSPACE_FLAG
+    bool cond = pixelmap == nullptr;
+    CHECK_DEBUG_RETURN_RET_LOG(cond, false, "isNeedApplycolorspace get src failed");
+    auto grColorSpaceName = pixelmap->InnerGetGrColorSpace().GetColorSpaceName();
+    if (grColorSpaceName != ColorManager::ColorSpaceName::BT709_LIMIT &&
+        grColorSpaceName != ColorManager::ColorSpaceName::BT709) {
+        return false;
+    }
+    auto applyGrColorSpace = OHOS::ColorManager::ColorSpace(OHOS::ColorManager::ColorSpaceName::SRGB);
+    uint32_t ret = pixelmap->ApplyColorSpace(applyGrColorSpace);
+    cond = ret == SUCCESS;
+    CHECK_ERROR_RETURN_RET_LOG(cond, false, "applyColorSpace failed");
+#endif
+    return true;
+}
+
+uint32_t ExtEncoder::EncodeImageByPixelMap(PixelMap* pixelmap, bool needExif, SkWStream& outputStream)
 {
     if (encodeFormat_ == SkEncodedImageFormat::kHEIF) {
-        return EncodeHeifByPixelmap(pixelMap, opts_);
+        return EncodeHeifByPixelmap(pixelmap, opts_);
     }
     SkBitmap bitmap;
     TmpBufferHolder holder;
     SkImageInfo skInfo;
     ImageData imageData;
-    pixelMap->GetImageInfo(imageData.info);
+    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);
-
     bool cond = HardwareEncode(outputStream, needExif) == true;
     CHECK_DEBUG_RETURN_RET_LOG(cond, SUCCESS, "HardwareEncode Success return");
     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) {
+        if (YuvToRgbaSkInfo(imageData.info, skInfo, dstData.get(), pixelmap) != SUCCESS) {
             IMAGE_LOGD("YUV format, convert to RGB fail");
             return ERR_IMAGE_ENCODE_FAILED;
         }
@@ -699,13 +737,13 @@ uint32_t ExtEncoder::EncodeImageByPixelMap(PixelMap* pixelMap, bool needExif, Sk
     } else {
         dstData = std::make_unique<uint8_t[]>(width * height * NUM_3);
         imageData.dst = dstData.get();
-        cond = pixelToSkInfo(imageData, skInfo, pixelMap, holder, encodeFormat_) != SUCCESS;
+        cond = pixelToSkInfo(imageData, skInfo, pixelmap, holder, encodeFormat_) != SUCCESS;
         CHECK_ERROR_RETURN_RET_LOG(cond, ERR_IMAGE_ENCODE_FAILED,
             "ExtEncoder::EncodeImageByPixelMap pixel convert failed");
         rowStride = skInfo.minRowBytes64();
 #if !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM)
-        if (pixelMap->GetAllocatorType() == AllocatorType::DMA_ALLOC) {
-            SurfaceBuffer* sbBuffer = reinterpret_cast<SurfaceBuffer*> (pixelMap->GetFd());
+        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));
         }
@@ -1420,7 +1458,7 @@ uint32_t ExtEncoder::AssembleHeifFragmentMap(std::vector<ImageItem>& inputImgs)
 }
 #endif
 
-uint32_t DecomposeDualVivid(VpeSurfaceBuffers& buffers, Media::PixelMap *pixelmap,
+uint32_t DecomposeDualVivid(VpeSurfaceBuffers& buffers, Media::PixelMap* pixelmap,
     SkEncodedImageFormat format, HdrMetadata& metadata)
 {
     if (pixelmap == nullptr) {
@@ -1465,6 +1503,102 @@ uint32_t DecomposeDualVivid(VpeSurfaceBuffers& buffers, Media::PixelMap *pixelma
     return SUCCESS;
 }
 
+static bool GetDstTruncatePixelFormat(GraphicPixelFormat srcFormat, GraphicPixelFormat& dstFormat)
+{
+    switch (srcFormat) {
+        case GRAPHIC_PIXEL_FMT_RGBA_1010102 : {
+            dstFormat = GRAPHIC_PIXEL_FMT_RGBA_8888;
+            break;
+        }
+        case GRAPHIC_PIXEL_FMT_YCBCR_P010 : {
+            dstFormat = GRAPHIC_PIXEL_FMT_YCBCR_420_SP;
+            break;
+        }
+        case GRAPHIC_PIXEL_FMT_YCRCB_P010 : {
+            dstFormat = GRAPHIC_PIXEL_FMT_YCRCB_420_SP;
+            break;
+        }
+        default: {
+            IMAGE_LOGE("pixel format: [%{public}d] not surpport.", srcFormat);
+            return false;
+        }
+    }
+    return true;
+}
+
+uint32_t Truncate10bBitTo8bit(VpeSurfaceBuffers& buffers, Media::PixelMap* pixelmap,
+    SkEncodedImageFormat format)
+{
+    IMAGE_LOGD("HDR-IMAGE Splice10bitTo8bit");
+    bool cond = pixelmap == nullptr;
+    CHECK_ERROR_RETURN_RET(cond, false);
+    if (!ImageUtils::Is10Bit(pixelmap->GetPixelFormat()) ||
+        pixelmap->GetAllocatorType() != AllocatorType::DMA_ALLOC) {
+        IMAGE_LOGE("HDR-IMAGE Splice10bBitSdrTo8bit condition error");
+        return ERR_IMAGE_INVALID_PARAMETER;
+    }
+    sptr<SurfaceBuffer> hdrSurfaceBuffer(reinterpret_cast<SurfaceBuffer*> (pixelmap->GetFd()));
+    GraphicPixelFormat srcPixelFormat = static_cast<GraphicPixelFormat>(hdrSurfaceBuffer->GetFormat());
+    GraphicPixelFormat dstPixelFormat;
+    cond = !GetDstTruncatePixelFormat(srcPixelFormat, dstPixelFormat);
+    CHECK_ERROR_RETURN_RET_LOG(cond, ERR_IMAGE_INVALID_PARAMETER, "HDR-IMAGE Splice10bitTo8bit"
+        "pixel format :[%{public}d] not support", format);
+    
+    sptr<SurfaceBuffer> baseSptr = AllocSurfaceBuffer(hdrSurfaceBuffer->GetWidth(),
+        hdrSurfaceBuffer->GetHeight(), dstPixelFormat);
+    cond = baseSptr == nullptr;
+    CHECK_ERROR_RETURN_RET(cond, IMAGE_RESULT_CREATE_SURFAC_FAILED);
+    buffers.sdr = baseSptr;
+    buffers.hdr = hdrSurfaceBuffer;
+    IMAGE_LOGD("src buffer alloc pixelFormat is : %{public}d", buffers.sdr->GetFormat());
+    std::unique_ptr<VpeUtils> utils = std::make_unique<VpeUtils>();
+    ImageUtils::DumpHdrBufferEnabled(hdrSurfaceBuffer, "SpliceInput-10-bit");
+    int32_t res = utils->TruncateBuffer(buffers, false);
+    if (res != SUCCESS) {
+        IMAGE_LOGE("HDR-IMAGE Convert10bBitSdrToDual decomposeImage failed");
+        ImageUtils::SurfaceBuffer_Unreference(baseSptr.GetRefPtr());
+        return IMAGE_RESULT_CREATE_SURFAC_FAILED;
+    }
+    ImageUtils::DumpHdrBufferEnabled(baseSptr, "SpliceInput-8-bit");
+    return SUCCESS;
+}
+
+uint32_t ExtEncoder::Encode10bitSdrPixelMap(Media::PixelMap* pixelmap, ExtWStream& outputStream)
+{
+    IMAGE_LOGD("HDR-IMAGE Encode10bitRGBAToSdr");
+    if (pixelmap == nullptr) {
+        return ERR_IMAGE_INVALID_PARAMETER;
+    }
+    VpeSurfaceBuffers buffers;
+    HdrMetadata metadata;
+    uint32_t error = Truncate10bBitTo8bit(buffers, pixelmap, encodeFormat_);
+    if (error != SUCCESS) {
+        IMAGE_LOGE("HDR-IMAGE EncodeRGBA1010102SdrPixelMap failed");
+        return ERR_IMAGE_ENCODE_FAILED;
+    }
+
+    PixelFormat pixelFormat = ImageUtils::SbFormat2PixelFormat(buffers.hdr->GetFormat());
+    std::unique_ptr<PixelMap> encodePixelmap;
+    if (ImageUtils::IsYuvFormat(pixelFormat)) {
+#ifdef EXT_PIXEL
+        encodePixelmap = std::make_unique<PixelYuvExt>();
+#else
+        encodePixelmap = std::make_unique<PixelYuv>();
+#endif
+    } else {
+        encodePixelmap = std::make_unique<PixelMap>();
+    }
+    CHECK_ERROR_RETURN_RET(encodePixelmap == nullptr, ERR_IMAGE_ENCODE_FAILED);
+    if (!ImageUtils::SurfaceBuffer2PixelMap(buffers.sdr, encodePixelmap)) {
+        return ERR_IMAGE_ENCODE_FAILED;
+    }
+    encodePixelmap->InnerSetColorSpace(OHOS::ColorManager::ColorSpace(
+                OHOS::ColorManager::ColorSpaceName::SRGB));
+    error = EncodeImageByPixelMap(encodePixelmap.get(), opts_.needsPackProperties, outputStream);
+    ImageUtils::SurfaceBuffer_Unreference(buffers.sdr);
+    return error;
+}
+
 uint32_t ExtEncoder::EncodeDualVivid(ExtWStream& outputStream)
 {
     IMAGE_LOGD("ExtEncoder::EncodeDualVivid");