From af4f938d92d27167e59770810d410884b1b89972 Mon Sep 17 00:00:00 2001 From: jiejex Date: Tue, 19 Aug 2025 19:29:10 +0800 Subject: [PATCH] =?UTF-8?q?:10bit709=E7=BC=96=E7=A0=81-=E5=9B=BE=E7=89=87?= =?UTF-8?q?=E6=A1=86=E6=9E=B6=E5=A2=9E=E5=8A=A010bit709=E7=9A=84=E7=BC=96?= =?UTF-8?q?=E7=A0=81=E8=83=BD=E5=8A=9B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: jiejex --- .../innerkitsimpl/common/src/pixel_map.cpp | 2 +- .../converter/src/image_format_convert.cpp | 164 ++++++++--- frameworks/innerkitsimpl/test/BUILD.gn | 1 + .../unittest/image_format_convert_test.cpp | 6 +- .../image_source_test/image_source_test.cpp | 2 +- .../unittest/plugin_test/ext_decoder_test.cpp | 256 +++++++++++++++++- frameworks/innerkitsimpl/utils/BUILD.gn | 1 + .../innerkitsimpl/utils/include/vpe_utils.h | 3 + .../innerkitsimpl/utils/src/vpe_utils.cpp | 35 ++- interfaces/innerkits/BUILD.gn | 3 + .../innerkits/include/image_format_convert.h | 8 +- .../image/libextplugin/include/ext_encoder.h | 5 + .../image/libextplugin/src/ext_encoder.cpp | 131 ++++++++- 13 files changed, 561 insertions(+), 56 deletions(-) diff --git a/frameworks/innerkitsimpl/common/src/pixel_map.cpp b/frameworks/innerkitsimpl/common/src/pixel_map.cpp index 18d795be9..a50f33602 100644 --- a/frameworks/innerkitsimpl/common/src/pixel_map.cpp +++ b/frameworks/innerkitsimpl/common/src/pixel_map.cpp @@ -4445,7 +4445,7 @@ std::unique_ptr PixelMap::CreateSdrMemory(ImageInfo &imageInfo, Pixel } 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(colorspaceType)); errorCode = IMAGE_RESULT_GET_SURFAC_FAILED; return nullptr; } diff --git a/frameworks/innerkitsimpl/converter/src/image_format_convert.cpp b/frameworks/innerkitsimpl/converter/src/image_format_convert.cpp index 146255590..f3b7ad491 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, ConvertFunction> g_cvtFuncMap = []() { @@ -349,9 +352,11 @@ uint32_t ImageFormatConvert::ConvertImageFormat(const ConvertDataInfo &srcDataIn return RGBConvert(srcDataInfo, destInfo); } -uint32_t ImageFormatConvert::ConvertImageFormat(std::shared_ptr &srcPiexlMap, PixelFormat destFormat) +uint32_t ImageFormatConvert::ConvertImageFormat(std::shared_ptr &srcPixelMap, PixelFormat destFormat) { - if (srcPiexlMap == nullptr) { + ImageTrace imageTrace("ImageFormatConvert::ConvertImageFormat srcFmt %u, dstFmt %u", + static_cast(srcPixelMap->GetPixelFormat(), static_cast(uint32_t)(destFormat))); + if (srcPixelMap == nullptr) { IMAGE_LOGE("source pixel map is null"); return ERR_IMAGE_INVALID_PARAMETER; } @@ -359,31 +364,31 @@ uint32_t ImageFormatConvert::ConvertImageFormat(std::shared_ptr &srcPi 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 resultPixelMap = PixelMap::ConvertFromAstc(srcPiexlMap.get(), ret, + std::unique_ptr 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,110 @@ std::unique_ptr ImageFormatConvert::CreateMemory(PixelFormat pixelFor return m; } -uint32_t ImageFormatConvert::RGBConvertImageFormatOption(std::shared_ptr &srcPiexlMap, +bool IsRGBA1010102ToRGBA8888(std::shared_ptr &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 Truncate10BitMemory(std::shared_ptr &srcPixelMap, + ImageInfo &imageInfo, PixelFormat format, AllocatorType dstType, uint32_t &errorCode) +{ +#if !defined(CROSS_PLATFORM) + PixelFormat outFormat = format; + if (format != PixelFormat::NV12 && format != PixelFormat::NV21 && format != PixelFormat::RGBA_8888) { + outFormat = PixelFormat::RGBA_8888; + } + // hdr and sdr has same byte size. + size_t byteSize = srcPixelMap->GetByteCount(); + MemoryData sdrData = {nullptr, byteSize, "Trans ImageData", imageInfo.size, outFormat}; + 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; + buffer.sdr = sptr(reinterpret_cast(sdrMemory->extend.data)); + buffer.hdr = sptr(reinterpret_cast(srcPixelMap->GetFd())); + std::unique_ptr utils = std::make_unique(); + int32_t res = utils->ColorSpaceConverterTruncateImage(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 &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 &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(srcPiexlMap->GetFd()); + auto sb = reinterpret_cast(srcPixelMap->GetFd()); stride = sb->GetStride(); sptr sourceSurfaceBuffer(sb); sptr dstSurfaceBuffer(reinterpret_cast(m->extend.data)); @@ -602,12 +686,12 @@ uint32_t ImageFormatConvert::RGBConvertImageFormatOption(std::shared_ptrGetColorSpace())) { + 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 +699,26 @@ uint32_t ImageFormatConvert::RGBConvertImageFormatOption(std::shared_ptr &srcPiexlMap, const PixelFormat &srcFormat, PixelFormat destFormat) + std::unique_ptr &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(srcPiexlMap->GetFd()); + auto sb = reinterpret_cast(srcPixelMap->GetFd()); stride = sb->GetStride(); sptr sourceSurfaceBuffer(sb); sptr dstSurfaceBuffer(reinterpret_cast(memory->extend.data)); @@ -649,12 +733,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 +777,9 @@ bool ImageFormatConvert::SetConvertImageMetaData(std::shared_ptr &srcP return true; } -static AllocatorType GetAllocatorType(std::shared_ptr &srcPiexlMap, PixelFormat destFormat) +static AllocatorType GetAllocatorType(std::shared_ptr &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 +787,18 @@ static AllocatorType GetAllocatorType(std::shared_ptr &srcPiexlMap, Pi return allocType; } -uint32_t ImageFormatConvert::YUVConvertImageFormatOption(std::shared_ptr &srcPiexlMap, +uint32_t ImageFormatConvert::YUVConvertImageFormatOption(std::shared_ptr &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 +808,16 @@ uint32_t ImageFormatConvert::YUVConvertImageFormatOption(std::shared_ptr((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 sourceSurfaceBuffer(reinterpret_cast(srcPiexlMap->GetFd())); + sptr sourceSurfaceBuffer(reinterpret_cast(srcPixelMap->GetFd())); sptr dstSurfaceBuffer(reinterpret_cast(m->extend.data)); VpeUtils::CopySurfaceBufferInfo(sourceSurfaceBuffer, dstSurfaceBuffer); } @@ -744,11 +828,11 @@ uint32_t ImageFormatConvert::YUVConvertImageFormatOption(std::shared_ptrGetColorSpace())) { + 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/test/BUILD.gn b/frameworks/innerkitsimpl/test/BUILD.gn index c199a65bf..2a5d49f78 100644 --- a/frameworks/innerkitsimpl/test/BUILD.gn +++ b/frameworks/innerkitsimpl/test/BUILD.gn @@ -1293,6 +1293,7 @@ ohos_unittest("jpeg_hw_decoder_test") { "drivers_interface_display:libdisplay_buffer_proxy_1.0", "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", "drivers_interface_display:libdisplay_composer_proxy_1.0", + "drivers_interface_display:libdisplay_commontype_proxy_2.1", "googletest:gtest_main", "graphic_surface:surface", "hdf_core:libhdf_utils", diff --git a/frameworks/innerkitsimpl/test/unittest/image_format_convert_test.cpp b/frameworks/innerkitsimpl/test/unittest/image_format_convert_test.cpp index 6de636f3b..d7f66c93e 100644 --- a/frameworks/innerkitsimpl/test/unittest/image_format_convert_test.cpp +++ b/frameworks/innerkitsimpl/test/unittest/image_format_convert_test.cpp @@ -1786,14 +1786,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 srcPiexlMap = std::make_shared(); + std::shared_ptr srcPixelMap = std::make_shared(); 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 7dbdb8c90..bca5461b3 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 6e4c1f975..b92dfdc56 100644 --- a/frameworks/innerkitsimpl/test/unittest/plugin_test/ext_decoder_test.cpp +++ b/frameworks/innerkitsimpl/test/unittest/plugin_test/ext_decoder_test.cpp @@ -2185,6 +2185,261 @@ HWTEST_F(ExtDecoderTest, EncodePixelMapTest001, TestSize.Level3) EXPECT_NE(imageSourceDest, nullptr); } +/** + * @tc.name: Encode10bit709Test001 + * @tc.desc: Test JPEG encoding from a YCBCR_P010 format PixelMap and set to BT709 and encode-decode to sdr. + * @tc.type: FUNC + */ +HWTEST_F(ExtDecoderTest, Encode10bit709Test001, TestSize.Level3) +{ + uint32_t errorCode = 0; + SourceOptions sourceOpts; + std::unique_ptr 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 = 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)); + EXPECT_EQ(pixelmap->IsHdr(), false); +#endif + uint32_t ret = ImageFormatConvert::ConvertImageFormat(pixelMap, PixelFormat::RGBA_1010102); + PixelFormat format = pixelMap->GetPixelFormat(); + ASSERT_EQ(format, PixelFormat::RGBA_1010102); + // 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 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 pixelmapAfterPacker = imageSourceDest->CreatePixelMap(optsForDest, errorCode); + ASSERT_NE(pixelmapAfterPacker, nullptr); + ASSERT_NE(pixelmapAfterPacker->isHdr(), false); +#ifdef IMAGE_COLORSPACE_FLAG + PixelFormat encodeAndDecodeFormat = pixelmap->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 encoding from a YCBCR_P010 format PixelMap and set to BT709 and encode-decode to sdr. + * @tc.type: FUNC + */ +HWTEST_F(ExtDecoderTest, Encode10bit709Test002, TestSize.Level3) +{ + uint32_t errorCode = 0; + SourceOptions sourceOpts; + std::unique_ptr 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 = 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)); + EXPECT_EQ(pixelmap->IsHdr(), false); +#endif + // init packer to packfile + ImagePacker packer; + PackOption option; + option.format = "image/jpeg"; + 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 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 pixelmapAfterPacker = imageSourceDest->CreatePixelMap(optsForDest, errorCode); + ASSERT_NE(pixelmapAfterPacker, nullptr); + ASSERT_NE(pixelmapAfterPacker->isHdr(), false); + PixelFormat encodeAndDecodeFormat = pixelmap->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: Encode10bit709Test003 + * @tc.desc: Test JPEG encoding from a YCBCR_P010 format PixelMap and set to BT709 and encode PNG to hdr. + * @tc.type: FUNC + */ +HWTEST_F(ExtDecoderTest, Encode10bit709Test003, TestSize.Level3) +{ + uint32_t errorCode = 0; + SourceOptions sourceOpts; + std::unique_ptr 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 = 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)); + EXPECT_EQ(pixelmap->IsHdr(), false); +#endif + uint32_t ret = ImageFormatConvert::ConvertImageFormat(pixelmap, PixelFormat::RGBA_8888); + PixelFormat format = pixelmap->GetPixelFormat(); + ASSERT_EQ(format, PixelFormat::RGBA_1010102); + // init packer to pack to png + ImagePacker packer; + PackOption option; + option.format = "image/png"; + 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_NE(retFinalizePacking, OHOS::Media::SUCCESS); +} + +/** + * @tc.name: Encode10bit709Test004 + * @tc.desc: Test JPEG encoding from a YCBCR_P010 format PixelMap and set to BT709 and encode-decode to sdr. + * @tc.type: FUNC + */ +HWTEST_F(ExtDecoderTest, Encode10bit709Test004, TestSize.Level3) +{ + uint32_t errorCode = 0; + SourceOptions sourceOpts; + std::unique_ptr 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 = imageSource->CreatePixelMap(opts, errorCode); + ASSERT_EQ(errorCode, OHOS::Media::SUCCESS); + ASSERT_NE(pixelmap, nullptr); + PixelFormat format = pixelmap->GetPixelFormat(); + ASSERT_EQ(format, PixelFormat::RGBA_1010102); +#ifdef IMAGE_COLORSPACE_FLAG + pixelmap->InnerSetColorSpace(OHOS::ColorManager::ColorSpace( + OHOS::ColorManager::ColorSpaceName::BT709_LIMIT)); + EXPECT_EQ(pixelmap->IsHdr(), false); +#endif + // init packer to packfile + ImagePacker packer; + PackOption option; + option.format = "image/jpeg"; + 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 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 pixelmapAfterPacker = imageSourceDest->CreatePixelMap(optsForDest, errorCode); + ASSERT_NE(pixelmapAfterPacker, nullptr); + ASSERT_NE(pixelmapAfterPacker->isHdr(), false); + PixelFormat encodeAndDecodeFormat = pixelmap->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: Encode10bit709Test005 + * @tc.desc: Test heic encoding from a YCBCR_P010 format PixelMap and set to BT709 and encode heic decode to s. + * @tc.type: FUNC + */ +HWTEST_F(ExtDecoderTest, Encode10bit709Test005, TestSize.Level3) +{ + uint32_t errorCode = 0; + SourceOptions sourceOpts; + std::unique_ptr imageSource = + ImageSource::CreateImageSource(IMAGE_HEIC_THREE_GAINMAP_HDR_PATH.c_str(), sourceOpts, errorCode); + ASSERT_NE(imageSource, nullptr); + DecodeOptions opts; + opts.desiredDynamicRange = DecodeDynamicRange::AUTO; + std::shared_ptr pixelmap = imageSource->CreatePixelMap(opts, errorCode); + ASSERT_EQ(errorCode, OHOS::Media::SUCCESS); + ASSERT_NE(pixelmap, nullptr); + PixelFormat format = pixelmap->GetPixelFormat(); + ASSERT_EQ(format, PixelFormat::RGBA_1010102); +#ifdef IMAGE_COLORSPACE_FLAG + pixelmap->InnerSetColorSpace(OHOS::ColorManager::ColorSpace( + OHOS::ColorManager::ColorSpaceName::BT709)); + EXPECT_EQ(pixelmap->IsHdr(), false); +#endif + // init packer to packfile + ImagePacker packer; + PackOption option; + option.format = "image/heic"; + 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 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 pixelmapAfterPacker = imageSourceDest->CreatePixelMap(optsForDest, errorCode); + ASSERT_NE(pixelmapAfterPacker, nullptr); + ASSERT_NE(pixelmapAfterPacker->isHdr(), false); + PixelFormat encodeAndDecodeFormat = pixelmap->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: EncodeWideGamutPixelMapAndDecodeTest001 * @tc.desc: Test HEIF encoding from a RGBA_1010102 format PixelMap and decode to widegamut image. @@ -2320,6 +2575,5 @@ HWTEST_F(ExtDecoderTest, EncodeWideGamutPixelMapAndDecodeTest004, TestSize.Level ASSERT_NE(errorCode, OHOS::Media::SUCCESS); ASSERT_EQ(pixelmap, nullptr); } - } } \ No newline at end of file diff --git a/frameworks/innerkitsimpl/utils/BUILD.gn b/frameworks/innerkitsimpl/utils/BUILD.gn index d5b6d8cb6..77e8e6a0a 100644 --- a/frameworks/innerkitsimpl/utils/BUILD.gn +++ b/frameworks/innerkitsimpl/utils/BUILD.gn @@ -299,6 +299,7 @@ ohos_static_library("image_utils_static") { external_deps = [ "c_utils:utils", "drivers_interface_display:libdisplay_commontype_proxy_1.0", + "drivers_interface_display:libdisplay_commontype_proxy_2.1", "ffmpeg:libohosffmpeg", "ffrt:libffrt", "graphic_2d:color_manager", diff --git a/frameworks/innerkitsimpl/utils/include/vpe_utils.h b/frameworks/innerkitsimpl/utils/include/vpe_utils.h index f781eed16..df30de271 100644 --- a/frameworks/innerkitsimpl/utils/include/vpe_utils.h +++ b/frameworks/innerkitsimpl/utils/include/vpe_utils.h @@ -22,6 +22,8 @@ #include "v1_0/cm_color_space.h" #include "v1_0/hdr_static_metadata.h" #include "surface_buffer.h" +#include "v1_0/cm_color_space.h" +#include "v2_1/cm_color_space.h" #endif #include "hdr_type.h" @@ -46,6 +48,7 @@ public: #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM) int32_t ColorSpaceConverterComposeImage(VpeSurfaceBuffers& sb, bool legacy); int32_t ColorSpaceConverterDecomposeImage(VpeSurfaceBuffers& sb); + int32_t ColorSpaceConverterTruncateImage(VpeSurfaceBuffers& sb, bool only Sdr = false); int32_t ColorSpaceCalGainmap(VpeSurfaceBuffers& sb); int32_t ColorSpaceConverterImageProcess(sptr& input, sptr& output); int32_t DetailEnhancerImageProcess(sptr& input, sptr& output, int32_t level); diff --git a/frameworks/innerkitsimpl/utils/src/vpe_utils.cpp b/frameworks/innerkitsimpl/utils/src/vpe_utils.cpp index b73d26f4b..cc4dcd34a 100644 --- a/frameworks/innerkitsimpl/utils/src/vpe_utils.cpp +++ b/frameworks/innerkitsimpl/utils/src/vpe_utils.cpp @@ -37,6 +37,7 @@ namespace OHOS { namespace Media { #if !defined(_WIN32) && !defined(_APPLE) && !defined(IOS_PLATFORM) && !defined(ANDROID_PLATFORM) using namespace OHOS::HDI::Display::Graphic::Common::V1_0; +using CM_ColorSpaceType_V2_1 = OHOS::HDI::Display::Graphic::Common::V2_1::CM_ColorSpaceType; static constexpr uint32_t TRANSFUNC_OFFSET = 8; static constexpr uint32_t MATRIX_OFFSET = 16; static constexpr uint32_t RANGE_OFFSET = 21; @@ -155,10 +156,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 +212,36 @@ int32_t VpeUtils::ColorSpaceConverterDecomposeImage(VpeSurfaceBuffers& sb) return res; } +int32_t VpeUtils::ColorSpaceConverterTruncateImage(VpeSurfaceBuffers& buffers, bool onlySdr) +{ + int32_t res = VPE_ERROR_OK; + bool cond = buffers.hdr == nullptr || buffers.sdr == nullptr; + CHECK_ERROR_RETURN_RET(cond, VPE_ERROR_FAILED); + CM_ColorSpaceType colorSpaceType; + VpeUtils::GetSbColorSpaceType(buffers.hdr, colorSpaceType); + IMAGE_LOGI("HDR_IMAGE ColorSpaceConverterTruncateImage get src colorType %{public}d", colorSpaceType); + VpeUtils::SetSbColorSpaceType(buffers.hdr, + static_cast(CM_ColorSpaceType_V2_1::CM_BT2020_LOG_LIMIT)); + VpeUtils::SetSbMetadataType(buffers.hdr, CM_IMAGE_HDR_VIVID_SINGLE); + VpeUtils::SetSbColorSpaceType(buffers.sdr, CM_P3_FULL); + VpeUtils::SetSbMetadataType(buffers.sdr, CM_IMAGE_HDR_VIVID_DUAL); + std::unique_ptr utils = std::make_unique(); + + if (onlySdr) { + bool cond = buffers.hdr == nullptr || buffers.sdr == nullptr; + CHECK_ERROR_RETURN_RET(cond, false); + res = utils->ColorSpaceConverterImageProcess(buffers.hdr, buffers.sdr); + } else { + VpeUtils::SetSbMetadataType(buffers.gainmap, CM_METADATA_NONE); + VpeUtils::SetSbColorSpaceType(buffers.gainmap, CM_P3_FULL); + res = utils->ColorSpaceConverterDecomposeImage(buffers); + } + VpeUtils::SetSbColorSpaceType(buffers.hdr, colorSpaceType); + bool cond = res != VPE_ERROR_OK; + CHECK_ERROR_RETURN_RET_LOG(cond, VPE_ERROR_FAILED, "TruncateImage onlySdr [%{public}d] failed, res = %{public}d", onlySdr, res); + 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 c5fb1ff9a..6bc815b68 100644 --- a/interfaces/innerkits/BUILD.gn +++ b/interfaces/innerkits/BUILD.gn @@ -254,7 +254,9 @@ if (use_clang_android) { "c_utils:utils", "drivers_interface_display:libdisplay_commontype_proxy_1.0", "drivers_interface_display:libdisplay_composer_proxy_1.2", + "drivers_interface_display:libdisplay_buffer_proxy_2.1", "drivers_interface_display:libhdifd_parcelable", + "hitrace:hitrace_meter" "ffmpeg:libohosffmpeg", "ffrt:libffrt", "hilog:libhilog", @@ -469,6 +471,7 @@ if (use_mingw_win || use_clang_mac || use_clang_ios || use_clang_android) { "c_utils:utils", "drivers_interface_display:libdisplay_commontype_proxy_1.0", "drivers_interface_display:libdisplay_composer_proxy_1.2", + "drivers_interface_display:libdisplay_buffer_proxy_2.1", "ffmpeg:libohosffmpeg", "graphic_2d:color_manager", "graphic_surface:surface", diff --git a/interfaces/innerkits/include/image_format_convert.h b/interfaces/innerkits/include/image_format_convert.h index 154b3302f..0dcf93595 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 &srcPiexlMap, PixelFormat destFormat); + static uint32_t ConvertImageFormat(std::shared_ptr &srcPixelMap, PixelFormat destFormat); static uint32_t MakeDestPixelMapUnique(std::unique_ptr &destPixelMap, ImageInfo &srcImageinfo, DestConvertInfo &destInfo, void *context); - static uint32_t RGBConvertImageFormatOptionUnique(std::unique_ptr &srcPiexlMap, + static uint32_t RGBConvertImageFormatOptionUnique(std::unique_ptr &srcPixelMap, const PixelFormat &srcFormat, PixelFormat destFormat); static bool SetConvertImageMetaData(std::unique_ptr &srcPixelMap, std::unique_ptr &dstPixelMap); static bool SetConvertImageMetaData(std::shared_ptr &srcPixelMap, std::unique_ptr &dstPixelMap); private: static bool IsValidSize(const Size &size); static bool CheckConvertDataInfo(const ConvertDataInfo &convertDataInfo); - static uint32_t YUVConvertImageFormatOption(std::shared_ptr &srcPiexlMap, const PixelFormat &srcFormat, + static uint32_t YUVConvertImageFormatOption(std::shared_ptr &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 CreateMemory(PixelFormat pixelFormat, AllocatorType allocatorType, Size size, YUVStrideInfo &strides, uint64_t usage = 0); - static uint32_t RGBConvertImageFormatOption(std::shared_ptr &srcPiexlMap, + static uint32_t RGBConvertImageFormatOption(std::shared_ptr &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 6e1c56133..a728fdfbc 100644 --- a/plugins/common/libs/image/libextplugin/include/ext_encoder.h +++ b/plugins/common/libs/image/libextplugin/include/ext_encoder.h @@ -80,6 +80,11 @@ private: sptr ConvertPixelMapToDmaBuffer(std::shared_ptr pixelmap); uint32_t EncodeSdrImage(ExtWStream& outputStream); uint32_t EncodeDualVivid(ExtWStream& outputStream); + + uint32_t EncodeRGBA1010102SdrPixelMap(Media::PixelMap* pixelmap, ExtWStream& outputStream); + uint32_t Encode10bitYuvPixelMapToSdr(Media::PixelMap* pixelmap, ExtWStream& outputStream); + uint32_t Encode10bitSdrPixelMap(Media::PixelMap* pixelmap, ExtWStream& outputStream); + uint32_t EncodeSingleVivid(ExtWStream& outputStream); uint32_t EncodePicture(); uint32_t EncodeCameraScenePicture(SkWStream& skStream); diff --git a/plugins/common/libs/image/libextplugin/src/ext_encoder.cpp b/plugins/common/libs/image/libextplugin/src/ext_encoder.cpp index 167ce5642..7f384fcd0 100644 --- a/plugins/common/libs/image/libextplugin/src/ext_encoder.cpp +++ b/plugins/common/libs/image/libextplugin/src/ext_encoder.cpp @@ -459,6 +459,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; @@ -471,6 +486,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); } @@ -667,8 +685,28 @@ uint32_t ExtEncoder::EncodeImageByBitmap(SkBitmap& bitmap, bool needExif, SkWStr return CreateAndWriteBlob(tStream, pixelmap_, outStream, imageInfo, opts_); } +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); + bool cond = ret == SUCCESS; + CHECK_ERROR_RETURN_RET_LOG(cond, false, "applyColorSpace failed"); + return true; +} + uint32_t ExtEncoder::EncodeImageByPixelMap(PixelMap* pixelMap, bool needExif, SkWStream& outputStream) { + if (ApplyColorSpaceBeforeEncode(pixelMap)) { + IMAGE_LOGI("need applyColorSpace before encode %{public}d", pixelmap->InnergetGrColorSpace().GetColorSpaceName()); + } if (encodeFormat_ == SkEncodedImageFormat::kHEIF) { return EncodeHeifByPixelmap(pixelMap, opts_); } @@ -679,11 +717,9 @@ uint32_t ExtEncoder::EncodeImageByPixelMap(PixelMap* pixelMap, bool needExif, Sk pixelMap->GetImageInfo(imageData.info); uint32_t width = static_cast(imageData.info.size.width); uint32_t height = static_cast(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 dstData; uint64_t rowStride = 0; if (IsYuvImage(imageData.info.pixelFormat)) { @@ -1421,7 +1457,7 @@ uint32_t ExtEncoder::AssembleHeifFragmentMap(std::vector& 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) { @@ -1466,6 +1502,95 @@ uint32_t DecomposeDualVivid(VpeSurfaceBuffers& buffers, Media::PixelMap *pixelma return SUCCESS; } +uint32_t ExtEncoder::Encode10bitYuvPixelMapToSdr(Media::PixelMap* pixelmap) +{ + IMAGE_LOGD("HDR-IMAGE Encode10bitYuvPixelMapToSdr"); + int32_t errorCode = 0; + auto newPixelmap = pixelmap->clone(errorCode); + std::shared_ptr convertPixelmap = std::move(newPixelmap); + uint32_t res = ImageFormatConvert::ConvertImageFormat(convertPixelmap, PixelFormat::RGBA_1010102); + if (res != SUCCESS) { + IMAGE_LOGE("HDR-IMAGE Encode10bitYuvPixelMapToSdr convert failed"); + return res; + } + return EncodeRGBA1010102SdrPixelMap(convertPixelmap.get(), outputStream); +} + +uint32_t ExtEncoder::Encode10bitSdrPixelMap(Media::PixelMap* pixelmap, ExtWStream& outputStream) +{ + IMAGE_LOGD("HDR-IMAGE Encode10bitSdrPixelMap"); + if (pixelmap->GetPixelFormat() != PixelFormat::RGBA_1010102) { + return Encode10bitYuvPixelMapToSdr(pixelmap, outputStream); + } + return EncodeRGBA1010102SdrPixelMap(pixelmap, outputStream); +} + +uint32_t Convert10bBitSdrToDual(VpeSurfaceBuffers& buffers, Media::PixelMap* pixelmap, + SkEncodeImageFormat format) +{ + bool cond = pixelmap == nullptr; + CHECK_ERROR_RETURN_RET(cond, false); + if (!ImageUtils::Is10Bit(pixelmap) || + pixelmap->GetAllocateType() != AllocatorType::DMA_ALLOC || + (format != SkEncodeImageFormat::KJPEG & format != SkEncodeImageFormat::kHEIF)) { + IMAGE_LOGE("HDR-IMAGE Convert10bitSdrToDual condition error"); + return ERROR_IMAGE_INVALID_PARAMETER; + } + bool sdrIsSRGB = pixelmap->GetToSdrColorSpaceIsSRGB(); + sptr hdrSurfaceBuffer(reinterpret_cast (pixelmap->GetFd())); + sptr baseSptr = AllocSurfaceBuffer(hdrSurfaceBuffer->GetWidth(), + hdrSurfaceBuffer->GetHeight()); + const int halfSizeDenominator = 2; + sptr gainmapSptr = AllocSurfaceBuffer(hdrSurfaceBuffer->GetWidth() / halfSizeDenominator, + hdrSurfaceBuffer->GetHeight() / halfSizeDenominator); + bool cond = baseSptr == nullptr || gainmapSptr == nullptr; + CHECK_ERROR_RETURN_RET(cond, IMAGE_RESULT_CREATE_SURFAC_FAILED); + buffers.sdr = baseSptr; + buffers.gainmap = gainmapSptr; + buffers.hdr = hdrSurfaceBuffer; + std::unique_ptr utils = std::make_unique(); + int32_t res = utils->ColorSpaceConverterTruncateImage(buffers, false); + if (res != SUCCESS) { + IMAGE_LOGE("HDR-IMAGE Convert10bBitSdrToDual decomposeImage failed"); + FreeBaseAndGainMapSurfaceBuffer(baseSptr, gainmapSptr); + return IMAGE_RESULT_CREATE_SURFAC_FAILED; + } + return SUCCESS; +} + +uint32_t ExtEncoder::EncodeRGBA1010102SdrPixelMap(Media::PixelMap* pixelmap, ExtWStream& outputStream) +{ + IMAGE_LOGD("HDR-IMAGE Encode10bitRGBAToSdr"); + if (pixelmap == nulltpr) { + return ERR_IMAGE_INVALID_PARAMETER; + } + VpeSurfaceBuffers buffers; + HdrMetadata metadata; + uint32_t error = Convert10bBitSdrToDual(buffers, pixelmap, encodeFormat_); + if (error != SUCCESS) { + IMAGE_LOGE("HDR-IMAGE EncodeRGBA1010102SdrPixelMap failed"); + return error; + } + // get sdr baseInfo + bool sdrIsSRGB = pixelmap_->GetToSdrColorSpaceIsSRGB(); + sk_sp colorSpace = ToHdrEncodeSkColorSpace(pixelmap, buffers.sdr, sdrIsSRGB, false); + SkImageInfo baseInfo = GetSkInfo(pixelmap, false, colorSpace); + // get gainmap baseInfo + sk_sp gainmapColorSpace = ToHdrEncodeSkColorSpace(pixelmap, buffers.gainmap, sdrIsSRGB, true); + SkImageInfo gainmapInfo = GetSkInfo(pixelmap, true, gainmapColorSpace); + uint32_t error; + if (encodeFormat_ == SkEncodedImageFormat::kJPEG) { + sk_sp baseImageData = GetImageEncodeData(buffers.sdr, baseInfo, opts_.needsPackProperties); + error = HdrJpegPackerHelper::SpliceLogHdrStream(baseImageData, outputStream, metadata); + } else if (encodeFormat_ == SkEncodedImageFormat::kHEIF) { + error = EncodeHeifSdrImage(buffers.sdr, baseInfo); + } else { + error = ERR_IMAGE_INVALID_PARAMETER; + } + FreeBaseAndGainMapSurfaceBuffer(buffers.sdr, buffers.gainmap); + return error; +} + uint32_t ExtEncoder::EncodeDualVivid(ExtWStream& outputStream) { IMAGE_LOGD("ExtEncoder::EncodeDualVivid"); -- Gitee