diff --git a/framework/algorithm/common/include/vpe_model_path.h b/framework/algorithm/common/include/vpe_model_path.h index 4fbea90..373ddd5 100644 --- a/framework/algorithm/common/include/vpe_model_path.h +++ b/framework/algorithm/common/include/vpe_model_path.h @@ -82,6 +82,7 @@ enum VpeModelKey { VIDEO_AIHDR_ALGO_CONFIG, VIDEO_AIHDR_MODEL, IMAGE_SR_10bit_CONVERT_KERNEL, + VIDEO_META_GEN_AI_SDR, VPE_MODEL_KEY_NUM, }; @@ -147,6 +148,7 @@ const std::array VPE_MODEL_PATHS = { "/sys_prod/etc/VideoProcessingEngine/video_aihdr_algo_config.xml", "/sys_prod/etc/VideoProcessingEngine/GTM_AIHDR.omc", "/sys_prod/etc/VideoProcessingEngine/10bitAisr.bin", + "/sys_prod/etc/VideoProcessingEngine/aimdg.om", }; } // namespace VideoProcessingEngine } // namespace Media diff --git a/framework/algorithm/metadata_generator_video/include/metadata_generator_video_impl.h b/framework/algorithm/metadata_generator_video/include/metadata_generator_video_impl.h index 7cb289b..f65ea3a 100644 --- a/framework/algorithm/metadata_generator_video/include/metadata_generator_video_impl.h +++ b/framework/algorithm/metadata_generator_video/include/metadata_generator_video_impl.h @@ -49,6 +49,8 @@ public: int32_t NotifyEos() override; int32_t ReleaseOutputBuffer(uint32_t index, bool render) override; int32_t Flush() override; + VPEAlgoErrCode SetParameter(const MetadataGeneratorParameter& parameter) override; + VPEAlgoErrCode GetParameter(MetadataGeneratorParameter& parameter) override; GSError OnConsumerBufferAvailable(); GSError OnProducerBufferReleased(); @@ -80,6 +82,7 @@ private: std::mutex mutex_; bool getUsage_{false}; std::atomic initBuffer_{false}; + std::atomic style_{VideoMetadataGeneratorStyle::META_GEN_BRIGHT_STYLE}; // task相关 std::mutex mtxTaskDone_; diff --git a/framework/algorithm/metadata_generator_video/metadata_generator_video_impl.cpp b/framework/algorithm/metadata_generator_video/metadata_generator_video_impl.cpp index eccc634..e77ddc3 100644 --- a/framework/algorithm/metadata_generator_video/metadata_generator_video_impl.cpp +++ b/framework/algorithm/metadata_generator_video/metadata_generator_video_impl.cpp @@ -236,11 +236,37 @@ int32_t MetadataGeneratorVideoImpl::Configure() VPEAlgoState::STOPPED, VPE_ALGO_ERR_INVALID_STATE, "Configure failed: not in INITIALIZED or CONFIGURING state"); MetadataGeneratorParameter param; param.algoType = MetadataGeneratorAlgoType::META_GEN_ALGO_TYPE_VIDEO; + param.styleType = style_; int32_t ret = csc_->SetParameter(param); state_ = (ret == VPE_ALGO_ERR_OK ? VPEAlgoState::CONFIGURING : VPEAlgoState::ERROR); return ret; } +VPEAlgoErrCode MetadataGeneratorVideoImpl::SetParameter(const MetadataGeneratorParameter& parameter) +{ + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOG(parameter.styleType >= VideoMetadataGeneratorStyle::META_GEN_BRIGHT_STYLE && + parameter.styleType <= VideoMetadataGeneratorStyle::META_GEN_CONTRAST_STYLE, + VPE_ALGO_ERR_INVALID_VAL, "Invalid metadata generator style"); + MetadataGeneratorParameter param; + param.algoType = MetadataGeneratorAlgoType::META_GEN_ALGO_TYPE_VIDEO; + param.styleType = parameter.styleType; + VPEAlgoErrCode ret = csc_->SetParameter(param); + style_ = parameter.styleType; + return ret; +} + +VPEAlgoErrCode MetadataGeneratorVideoImpl::GetParameter(MetadataGeneratorParameter& parameter) +{ + std::lock_guard lock(mutex_); + CHECK_AND_RETURN_RET_LOG(style_ >= VideoMetadataGeneratorStyle::META_GEN_BRIGHT_STYLE && + style_ <= VideoMetadataGeneratorStyle::META_GEN_CONTRAST_STYLE, + VPE_ALGO_ERR_INVALID_VAL, "Invalid metadata generator style"); + parameter.algoType = MetadataGeneratorAlgoType::META_GEN_ALGO_TYPE_VIDEO; + parameter.styleType = style_; + return VPE_ALGO_ERR_OK; +} + int32_t MetadataGeneratorVideoImpl::Prepare() { std::lock_guard lock(mutex_); diff --git a/framework/capi/video_processing/metadata_generator/include/metadata_generator_video_native.h b/framework/capi/video_processing/metadata_generator/include/metadata_generator_video_native.h index 7c4c6bd..ba57c42 100644 --- a/framework/capi/video_processing/metadata_generator/include/metadata_generator_video_native.h +++ b/framework/capi/video_processing/metadata_generator/include/metadata_generator_video_native.h @@ -63,6 +63,7 @@ private: const std::shared_ptr owner_{}; }; + int CApiStyleToInner(int Style) const; mutable std::mutex lock_{}; // Guarded by lock_ begin diff --git a/framework/capi/video_processing/metadata_generator/metadata_generator_video_native.cpp b/framework/capi/video_processing/metadata_generator/metadata_generator_video_native.cpp index 94a2c28..3299aa3 100644 --- a/framework/capi/video_processing/metadata_generator/metadata_generator_video_native.cpp +++ b/framework/capi/video_processing/metadata_generator/metadata_generator_video_native.cpp @@ -20,6 +20,12 @@ using namespace OHOS; using namespace OHOS::Media::VideoProcessingEngine; +namespace { +const std::unordered_map styleMap = { + {VIDEO_METADATA_GENERATOR_BRIGHT_MODE, META_GEN_BRIGHT_STYLE}, + {VIDEO_METADATA_GENERATOR_CONTRAST_MODE, META_GEN_CONTRAST_STYLE}, +}; +} VideoProcessing_ErrorCode MetadataGeneratorVideoNative::InitializeInner() { @@ -83,12 +89,36 @@ sptr MetadataGeneratorVideoNative::GetSurface() VideoProcessing_ErrorCode MetadataGeneratorVideoNative::SetParameter(const OHOS::Media::Format& parameter) { - return VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED; + std::lock_guard lock(lock_); + CHECK_AND_RETURN_RET_LOG(isInitialized_.load(), VIDEO_PROCESSING_ERROR_INITIALIZE_FAILED, + "Initialization failed!"); + + int style; + CHECK_AND_RETURN_RET_LOG(parameter.GetIntValue(VIDEO_METADATA_GENERATOR_STYLE_CONTROL, style), + VIDEO_PROCESSING_ERROR_INVALID_PARAMETER, "No metadata generator style!"); + int styleType = CApiStyleToInner(style); + CHECK_AND_RETURN_RET_LOG(styleType != -1, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER, + "Metadata generator style is invalid!"); + MetadataGeneratorParameter param{}; + param.styleType = static_cast(styleType); + auto result = VideoProcessingUtils::InnerErrorToCAPI(metadataGenerator_->SetParameter(param)); + return result; } VideoProcessing_ErrorCode MetadataGeneratorVideoNative::GetParameter(OHOS::Media::Format& parameter) { - return VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED; + std::lock_guard lock(lock_); + CHECK_AND_RETURN_RET_LOG(isInitialized_.load(), VIDEO_PROCESSING_ERROR_INITIALIZE_FAILED, + "Initialization failed!"); + + MetadataGeneratorParameter param{}; + auto result = VideoProcessingUtils::InnerErrorToCAPI(metadataGenerator_->GetParameter(param)); + if (result == VIDEO_PROCESSING_SUCCESS) { + int styleType = static_cast(param.styleType); + CHECK_AND_RETURN_RET_LOG(parameter.PutIntValue(VIDEO_METADATA_GENERATOR_STYLE_CONTROL, styleType), + VIDEO_PROCESSING_ERROR_PROCESS_FAILED, "Get parameter failed!"); + } + return result; } VideoProcessing_ErrorCode MetadataGeneratorVideoNative::OnStart() @@ -138,6 +168,16 @@ MetadataGeneratorVideoNative::NativeCallback::NativeCallback( { } +int MetadataGeneratorVideoNative::CApiStyleToInner(int Style) const +{ + auto it = styleMap.find(Style); + if (it == styleMap.end()) { + VPE_LOGE("Invalid input style:%{public}d", Style); + return -1; + } + return it->second; +} + void MetadataGeneratorVideoNative::NativeCallback::OnError(int32_t errorCode) { SendCallback([this, &errorCode]() { diff --git a/framework/capi/video_processing/video_processing.cpp b/framework/capi/video_processing/video_processing.cpp index 2862bad..e2f8f20 100644 --- a/framework/capi/video_processing/video_processing.cpp +++ b/framework/capi/video_processing/video_processing.cpp @@ -34,6 +34,7 @@ const int32_t VIDEO_PROCESSING_TYPE_DETAIL_ENHANCER = 0x4; // Video processing parameter keys: // Detail enhancement: const char* VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL = "QualityLevel"; +const char* VIDEO_METADATA_GENERATOR_STYLE_CONTROL = "StyleControl"; namespace { // Call video processing interface diff --git a/interfaces/inner_api/algorithm_common.h b/interfaces/inner_api/algorithm_common.h index 4fb2297..19bcc7f 100644 --- a/interfaces/inner_api/algorithm_common.h +++ b/interfaces/inner_api/algorithm_common.h @@ -118,6 +118,11 @@ enum class MetadataGeneratorAlgoType { META_GEN_ALGO_TYPE_VIDEO // video }; +enum class VideoMetadataGeneratorStyle { + META_GEN_BRIGHT_STYLE = 0, + META_GEN_CONTRAST_STYLE = 1 +}; + struct ColorSpaceConverterParameter { RenderIntent renderIntent; // 渲染意图 std::optional sdrUIBrightnessRatio { @@ -145,6 +150,7 @@ struct MetadataGeneratorParameter { MetadataGeneratorAlgoType algoType = MetadataGeneratorAlgoType::META_GEN_ALGO_TYPE_IMAGE; bool isOldHdrVivid = false; float avgGainmapGray = 0.0; + VideoMetadataGeneratorStyle styleType = VideoMetadataGeneratorStyle::META_GEN_BRIGHT_STYLE; }; uint32_t GetColorSpaceType(const CM_ColorSpaceInfo &colorSpaceInfo); diff --git a/interfaces/inner_api/metadata_generator_video.h b/interfaces/inner_api/metadata_generator_video.h index 7c7eb8e..b3fb589 100644 --- a/interfaces/inner_api/metadata_generator_video.h +++ b/interfaces/inner_api/metadata_generator_video.h @@ -133,6 +133,10 @@ public: virtual int32_t ReleaseOutputBuffer(uint32_t index, bool render) = 0; virtual int32_t Flush() = 0; + + virtual VPEAlgoErrCode SetParameter(const MetadataGeneratorParameter& parameter) = 0; + + virtual VPEAlgoErrCode GetParameter(MetadataGeneratorParameter& parameter) = 0; }; using ArgumentType = void; } // namespace VideoProcessingEngine diff --git a/interfaces/inner_api/metadata_generator_video_common.h b/interfaces/inner_api/metadata_generator_video_common.h index 8549df3..27475b8 100644 --- a/interfaces/inner_api/metadata_generator_video_common.h +++ b/interfaces/inner_api/metadata_generator_video_common.h @@ -23,6 +23,11 @@ enum MdgBufferFlag : uint32_t { MDG_BUFFER_FLAG_EOS = 1 << 0, }; +enum VIDEO_META_GEN_STYLE { + META_GEN_BRIGHT_STYLE = 0, + META_GEN_CONTRAST_STYLE = 1, +}; + class __attribute__((visibility("default"))) MetadataGeneratorVideoCallback { public: virtual ~MetadataGeneratorVideoCallback() = default; diff --git a/interfaces/kits/c/video_processing/libvideo_processing.ndk.json b/interfaces/kits/c/video_processing/libvideo_processing.ndk.json index 19fc6e2..3303292 100644 --- a/interfaces/kits/c/video_processing/libvideo_processing.ndk.json +++ b/interfaces/kits/c/video_processing/libvideo_processing.ndk.json @@ -94,5 +94,10 @@ "first_introduced": "12", "name": "VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL", "type": "variable" + }, + { + "first_introduced": "21", + "name": "VIDEO_METADATA_GENERATOR_STYLE_CONTROL", + "type": "variable" } ] diff --git a/interfaces/kits/c/video_processing_types.h b/interfaces/kits/c/video_processing_types.h index d863e2c..2bf286c 100644 --- a/interfaces/kits/c/video_processing_types.h +++ b/interfaces/kits/c/video_processing_types.h @@ -113,6 +113,21 @@ extern const int32_t VIDEO_PROCESSING_TYPE_DETAIL_ENHANCER; */ extern const char* VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL; +/** + * @brief The key is used to specify the style control for video metadata generator. + * + * See {@link VideoMetadataGeneratorStyleControl} for its values. + * Use {@link OH_AVFormat_SetIntValue} to set the mode value into AVFormat parameter. + * Use {@link OH_VideoProcessing_SetParameter} to set parameter into video processing instance. + * Use {@link OH_VideoProcessing_GetParameter} to get the current mode. + * + * @see OH_AVFormat_SetIntValue + * @see OH_VideoProcessing_SetParameter + * @see OH_VideoProcessing_GetParameter + * @since 21 + */ +extern const char* VIDEO_METADATA_GENERATOR_STYLE_CONTROL; + /** * @brief Video color space information structure of querying if video color space conversion is supported. * @@ -148,6 +163,23 @@ typedef enum VideoDetailEnhancer_QualityLevel { VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH, } VideoDetailEnhancer_QualityLevel; +/** + * @brief The style control is used for video metadata generator. + * + * It is the value of the key parameter {@link VIDEO_METADATA_GENERATOR_STYLE_CONTROL}. + * + * @see OH_AVFormat_SetIntValue + * @see OH_VideoProcessing_SetParameter + * @see OH_VideoProcessing_GetParameter + * @since 21 + */ +typedef enum VideoMetadataGeneratorStyleControl { + /** Style Control into bright mode */ + VIDEO_METADATA_GENERATOR_BRIGHT_MODE = 0, + /** Style Control into contrast mode */ + VIDEO_METADATA_GENERATOR_CONTRAST_MODE = 1 +} VideoMetadataGeneratorStyleControl; + /** * @brief Video processing error code. * diff --git a/test/unittest/metadata_gen_video_ndk/metadata_gen_video_ndk_unit_test.cpp b/test/unittest/metadata_gen_video_ndk/metadata_gen_video_ndk_unit_test.cpp index 1beb9f5..56b2d0c 100644 --- a/test/unittest/metadata_gen_video_ndk/metadata_gen_video_ndk_unit_test.cpp +++ b/test/unittest/metadata_gen_video_ndk/metadata_gen_video_ndk_unit_test.cpp @@ -74,7 +74,8 @@ public: void SetMeatadata(sptr &buffer, uint32_t value); void SetMeatadata(sptr &buffer, CM_ColorSpaceInfo &colorspaceInfo); - VideoProcessing_ErrorCode Process(); + VideoProcessing_ErrorCode ProcessContrastStyle(); + VideoProcessing_ErrorCode ProcessBrightStyle(); }; void OnError(OH_VideoProcessing *handle, VideoProcessing_ErrorCode errorCode, void* userData) @@ -119,7 +120,7 @@ void MetadataGeneratorVideoNdkImplUnitTest::SetMeatadata(sptr &bu } } -VideoProcessing_ErrorCode MetadataGeneratorVideoNdkImplUnitTest::Process() +VideoProcessing_ErrorCode MetadataGeneratorVideoNdkImplUnitTest::ProcessContrastStyle() { VideoProcessing_ErrorCode ret = VIDEO_PROCESSING_SUCCESS; sptr buffer; @@ -135,6 +136,62 @@ VideoProcessing_ErrorCode MetadataGeneratorVideoNdkImplUnitTest::Process() OH_VideoProcessing* instance2 = nullptr; ret = OH_VideoProcessing_Create(&instance, createType); ret = OH_VideoProcessing_Create(&instance2, createType); + OH_AVFormat* paramSetted = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(paramSetted, VIDEO_METADATA_GENERATOR_STYLE_CONTROL, + VIDEO_METADATA_GENERATOR_CONTRAST_MODE); + ret = OH_VideoProcessing_SetParameter(instance, paramSetted); + VideoProcessing_Callback* callback = nullptr; + ret = OH_VideoProcessingCallback_Create(&callback); + ret = OH_VideoProcessingCallback_BindOnError(callback, OnError); + ret = OH_VideoProcessingCallback_BindOnState(callback, OnState); + ret = OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBuffer); + OHNativeWindow* window = nullptr; + OHNativeWindow* window2 = nullptr; + ret = OH_VideoProcessing_GetSurface(instance, &window); + ret = OH_VideoProcessing_GetSurface(instance2, &window2); + auto userData = VIDEO_PROCESSING_STATE_STOPPED; + ret = OH_VideoProcessing_RegisterCallback(instance, callback, &userData); + ret = OH_VideoProcessing_SetSurface(instance, window2); + ret = OH_VideoProcessing_Start(instance); + if (ret != VIDEO_PROCESSING_SUCCESS) { + return ret; + } + int videoSurfaceBuffNum = 1; + int sleepTime = 2; + for (int i = 0; i < videoSurfaceBuffNum; i++) { + window->surface->RequestBuffer(buffer, fence_, requestCfg_); + SetMeatadata(buffer, inColspcInfo); + SetMeatadata(buffer, (uint32_t)inMetaType_); + window->surface->FlushBuffer(buffer, fence_, flushCfg_); + OH_VideoProcessing_SetSurface(instance, window2); + sleep(sleepTime); + } + OH_VideoProcessing_Destroy(instance); + OH_VideoProcessing_Destroy(instance2); + OH_VideoProcessing_DeinitializeEnvironment(); + return ret; +} + +VideoProcessing_ErrorCode MetadataGeneratorVideoNdkImplUnitTest::ProcessBrightStyle() +{ + VideoProcessing_ErrorCode ret = VIDEO_PROCESSING_SUCCESS; + sptr buffer; + CM_ColorSpaceInfo inColspcInfo = { + static_cast((inColspc_ & COLORPRIMARIES_MASK) >> COLORPRIMARIES_OFFSET), + static_cast((inColspc_ & TRANSFUNC_MASK) >> TRANSFUNC_OFFSET), + static_cast((inColspc_ & MATRIX_MASK) >> MATRIX_OFFSET), + static_cast((inColspc_ & RANGE_MASK) >> RANGE_OFFSET) + }; + ret = OH_VideoProcessing_InitializeEnvironment(); + int createType = 0x2; + OH_VideoProcessing* instance = nullptr; + OH_VideoProcessing* instance2 = nullptr; + ret = OH_VideoProcessing_Create(&instance, createType); + ret = OH_VideoProcessing_Create(&instance2, createType); + OH_AVFormat* paramSetted = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(paramSetted, VIDEO_METADATA_GENERATOR_STYLE_CONTROL, + VIDEO_METADATA_GENERATOR_BRIGHT_MODE); + ret = OH_VideoProcessing_SetParameter(instance, paramSetted); VideoProcessing_Callback* callback = nullptr; ret = OH_VideoProcessingCallback_Create(&callback); ret = OH_VideoProcessingCallback_BindOnError(callback, OnError); @@ -233,9 +290,9 @@ HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, testVideoProcess_testFun, TestSi EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS); OH_AVFormat* parameter = OH_AVFormat_Create(); ret = OH_VideoProcessing_SetParameter(instance, parameter); - EXPECT_EQ(ret, VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED); + EXPECT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER); ret = OH_VideoProcessing_GetParameter(instance, parameter); - EXPECT_EQ(ret, VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED); + EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS); ret = OH_VideoProcessing_SetSurface(instance, window2); EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS); for (int i = 0; i < 2; i++) { @@ -255,7 +312,286 @@ HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, testVideoProcess_testFun, TestSi EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS); } -HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, testVideoProcess_metadataGen, TestSize.Level1) +// set parameter but param not value +HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, set_parameter_01, TestSize.Level1) +{ + VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment(); + int createType = 0x2; + OH_VideoProcessing* instance = nullptr; + ret = OH_VideoProcessing_Create(&instance, createType); + OH_AVFormat* parameter = OH_AVFormat_Create(); + ret = OH_VideoProcessing_SetParameter(instance, parameter); + EXPECT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER); + OH_VideoProcessing_Destroy(instance); + OH_VideoProcessing_DeinitializeEnvironment(); +} + +// Set param nullptr +HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, set_parameter_02, TestSize.Level1) +{ + VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment(); + int createType = 0x2; + OH_VideoProcessing* instance = nullptr; + ret = OH_VideoProcessing_Create(&instance, createType); + OH_AVFormat* parameter = nullptr; + ret = OH_VideoProcessing_SetParameter(instance, parameter); + EXPECT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER); + OH_VideoProcessing_Destroy(instance); + OH_VideoProcessing_DeinitializeEnvironment(); +} + +// set normal +HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, set_parameter_03, TestSize.Level1) +{ + VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment(); + int createType = 0x2; + OH_VideoProcessing* instance = nullptr; + ret = OH_VideoProcessing_Create(&instance, createType); + OH_AVFormat* parameter = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(parameter, VIDEO_METADATA_GENERATOR_STYLE_CONTROL, + VIDEO_METADATA_GENERATOR_BRIGHT_MODE); + ret = OH_VideoProcessing_SetParameter(instance, parameter); + EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS); + OH_VideoProcessing_Destroy(instance); + OH_VideoProcessing_DeinitializeEnvironment(); +} + +// set normal +HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, set_parameter_04, TestSize.Level1) +{ + VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment(); + int createType = 0x2; + OH_VideoProcessing* instance = nullptr; + ret = OH_VideoProcessing_Create(&instance, createType); + OH_AVFormat* parameter = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(parameter, VIDEO_METADATA_GENERATOR_STYLE_CONTROL, + VIDEO_METADATA_GENERATOR_CONTRAST_MODE); + ret = OH_VideoProcessing_SetParameter(instance, parameter); + EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS); + OH_VideoProcessing_Destroy(instance); + OH_VideoProcessing_DeinitializeEnvironment(); +} + +// set invalid value +HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, set_parameter_05, TestSize.Level1) +{ + VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment(); + int createType = 0x2; + OH_VideoProcessing* instance = nullptr; + ret = OH_VideoProcessing_Create(&instance, createType); + OH_AVFormat* parameter = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(parameter, VIDEO_METADATA_GENERATOR_STYLE_CONTROL, -1); + ret = OH_VideoProcessing_SetParameter(instance, parameter); + EXPECT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER); + OH_VideoProcessing_Destroy(instance); + OH_VideoProcessing_DeinitializeEnvironment(); +} + +// set invalid value +HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, set_parameter_06, TestSize.Level1) +{ + VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment(); + int createType = 0x2; + OH_VideoProcessing* instance = nullptr; + ret = OH_VideoProcessing_Create(&instance, createType); + OH_AVFormat* parameter = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(parameter, VIDEO_METADATA_GENERATOR_STYLE_CONTROL, 2); + ret = OH_VideoProcessing_SetParameter(instance, parameter); + EXPECT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER); + OH_VideoProcessing_Destroy(instance); + OH_VideoProcessing_DeinitializeEnvironment(); +} + +// set normal +HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, set_parameter_07, TestSize.Level1) +{ + VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment(); + int createType = 0x2; + OH_VideoProcessing* instance = nullptr; + ret = OH_VideoProcessing_Create(&instance, createType); + OH_AVFormat* parameter = OH_AVFormat_Create(); + OH_AVFormat* parameterGetted = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(parameter, VIDEO_METADATA_GENERATOR_STYLE_CONTROL, + VIDEO_METADATA_GENERATOR_BRIGHT_MODE); + ret = OH_VideoProcessing_SetParameter(instance, parameter); + EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS); + OH_VideoProcessing_GetParameter(instance, parameterGetted); + int32_t mode = -1; + OH_AVFormat_GetIntValue(parameterGetted, VIDEO_METADATA_GENERATOR_STYLE_CONTROL, &mode); + EXPECT_EQ(mode, VIDEO_METADATA_GENERATOR_BRIGHT_MODE); + OH_VideoProcessing_Destroy(instance); + OH_VideoProcessing_DeinitializeEnvironment(); +} + +// set normal +HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, set_parameter_08, TestSize.Level1) +{ + VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment(); + int createType = 0x2; + OH_VideoProcessing* instance = nullptr; + ret = OH_VideoProcessing_Create(&instance, createType); + OH_AVFormat* parameter = OH_AVFormat_Create(); + OH_AVFormat* parameterGetted = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(parameter, VIDEO_METADATA_GENERATOR_STYLE_CONTROL, + VIDEO_METADATA_GENERATOR_CONTRAST_MODE); + ret = OH_VideoProcessing_SetParameter(instance, parameter); + EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS); + OH_VideoProcessing_GetParameter(instance, parameterGetted); + int32_t mode = -1; + OH_AVFormat_GetIntValue(parameterGetted, VIDEO_METADATA_GENERATOR_STYLE_CONTROL, &mode); + EXPECT_EQ(mode, VIDEO_METADATA_GENERATOR_CONTRAST_MODE); + OH_VideoProcessing_Destroy(instance); + OH_VideoProcessing_DeinitializeEnvironment(); +} + +// set invalid value +HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, set_parameter_09, TestSize.Level1) +{ + VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment(); + int createType = 0x2; + OH_VideoProcessing* instance = nullptr; + ret = OH_VideoProcessing_Create(&instance, createType); + OH_AVFormat* parameter = OH_AVFormat_Create(); + OH_AVFormat* parameterGetted = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(parameter, VIDEO_METADATA_GENERATOR_STYLE_CONTROL, -1); + ret = OH_VideoProcessing_SetParameter(instance, parameter); + EXPECT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER); + OH_VideoProcessing_GetParameter(instance, parameterGetted); + int32_t mode = -1; + OH_AVFormat_GetIntValue(parameterGetted, VIDEO_METADATA_GENERATOR_STYLE_CONTROL, &mode); + EXPECT_EQ(mode, VIDEO_METADATA_GENERATOR_BRIGHT_MODE); + OH_VideoProcessing_Destroy(instance); + OH_VideoProcessing_DeinitializeEnvironment(); +} + +// get parameter but param not null +HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, get_parameter_01, TestSize.Level1) +{ + VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment(); + int createType = 0x2; + OH_VideoProcessing* instance = nullptr; + ret = OH_VideoProcessing_Create(&instance, createType); + OH_AVFormat* parameter = OH_AVFormat_Create(); + ret = OH_VideoProcessing_GetParameter(instance, parameter); + EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS); + OH_VideoProcessing_Destroy(instance); + OH_VideoProcessing_DeinitializeEnvironment(); +} + +// get parameter normal +HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, get_parameter_02, TestSize.Level1) +{ + VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment(); + int createType = 0x2; + OH_VideoProcessing* instance = nullptr; + ret = OH_VideoProcessing_Create(&instance, createType); + OH_AVFormat* parameter = nullptr; + ret = OH_VideoProcessing_GetParameter(instance, parameter); + EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS); + OH_VideoProcessing_Destroy(instance); + OH_VideoProcessing_DeinitializeEnvironment(); +} + +// get parameter normal after set +HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, get_parameter_03, TestSize.Level1) +{ + VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment(); + int createType = 0x2; + OH_VideoProcessing* instance = nullptr; + ret = OH_VideoProcessing_Create(&instance, createType); + OH_AVFormat* parameterSetted = OH_AVFormat_Create(); + OH_AVFormat* parameterGetted = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(parameterSetted, VIDEO_METADATA_GENERATOR_STYLE_CONTROL, + VIDEO_METADATA_GENERATOR_BRIGHT_MODE); + ret = OH_VideoProcessing_SetParameter(instance, parameterSetted); + EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS); + ret = OH_VideoProcessing_GetParameter(instance, parameterGetted); + EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS); + OH_VideoProcessing_Destroy(instance); + OH_VideoProcessing_DeinitializeEnvironment(); +} + +// get parameter normal after set +HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, get_parameter_04, TestSize.Level1) +{ + VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment(); + int createType = 0x2; + OH_VideoProcessing* instance = nullptr; + ret = OH_VideoProcessing_Create(&instance, createType); + OH_AVFormat* parameterSetted = OH_AVFormat_Create(); + OH_AVFormat* parameterGetted = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(parameterSetted, VIDEO_METADATA_GENERATOR_STYLE_CONTROL, + VIDEO_METADATA_GENERATOR_CONTRAST_MODE); + ret = OH_VideoProcessing_SetParameter(instance, parameterSetted); + EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS); + ret = OH_VideoProcessing_GetParameter(instance, parameterGetted); + EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS); + OH_VideoProcessing_Destroy(instance); + OH_VideoProcessing_DeinitializeEnvironment(); +} + +// get default parameter +HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, get_parameter_05, TestSize.Level1) +{ + VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment(); + int createType = 0x2; + OH_VideoProcessing* instance = nullptr; + ret = OH_VideoProcessing_Create(&instance, createType); + OH_AVFormat* parameter = OH_AVFormat_Create(); + ret = OH_VideoProcessing_GetParameter(instance, parameter); + EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS); + int32_t mode = -1; + OH_AVFormat_GetIntValue(parameter, VIDEO_METADATA_GENERATOR_STYLE_CONTROL, &mode); + EXPECT_EQ(mode, VIDEO_METADATA_GENERATOR_BRIGHT_MODE); + OH_VideoProcessing_Destroy(instance); + OH_VideoProcessing_DeinitializeEnvironment(); +} + +// get parameter normal after set +HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, get_parameter_06, TestSize.Level1) +{ + VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment(); + int createType = 0x2; + OH_VideoProcessing* instance = nullptr; + ret = OH_VideoProcessing_Create(&instance, createType); + OH_AVFormat* parameterSetted = OH_AVFormat_Create(); + OH_AVFormat* parameterGetted = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(parameterSetted, VIDEO_METADATA_GENERATOR_STYLE_CONTROL, + VIDEO_METADATA_GENERATOR_BRIGHT_MODE); + ret = OH_VideoProcessing_SetParameter(instance, parameterSetted); + EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS); + ret = OH_VideoProcessing_GetParameter(instance, parameterGetted); + EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS); + int32_t mode = -1; + OH_AVFormat_GetIntValue(parameterGetted, VIDEO_METADATA_GENERATOR_STYLE_CONTROL, &mode); + EXPECT_EQ(mode, VIDEO_METADATA_GENERATOR_BRIGHT_MODE); + OH_VideoProcessing_Destroy(instance); + OH_VideoProcessing_DeinitializeEnvironment(); +} + +// get parameter normal after set +HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, get_parameter_07, TestSize.Level1) +{ + VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment(); + int createType = 0x2; + OH_VideoProcessing* instance = nullptr; + ret = OH_VideoProcessing_Create(&instance, createType); + OH_AVFormat* parameterSetted = OH_AVFormat_Create(); + OH_AVFormat* parameterGetted = OH_AVFormat_Create(); + OH_AVFormat_SetIntValue(parameterSetted, VIDEO_METADATA_GENERATOR_STYLE_CONTROL, + VIDEO_METADATA_GENERATOR_CONTRAST_MODE); + ret = OH_VideoProcessing_SetParameter(instance, parameterSetted); + EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS); + ret = OH_VideoProcessing_GetParameter(instance, parameterGetted); + EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS); + int32_t mode = -1; + OH_AVFormat_GetIntValue(parameterGetted, VIDEO_METADATA_GENERATOR_STYLE_CONTROL, &mode); + EXPECT_EQ(mode, VIDEO_METADATA_GENERATOR_CONTRAST_MODE); + OH_VideoProcessing_Destroy(instance); + OH_VideoProcessing_DeinitializeEnvironment(); +} + +HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, testVideoProcess_metadataGen_01, TestSize.Level1) { const int formatListNum = 3; int formatListHDR[formatListNum] = {GRAPHIC_PIXEL_FMT_YCBCR_P010, GRAPHIC_PIXEL_FMT_YCRCB_P010, @@ -276,7 +612,34 @@ HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, testVideoProcess_metadataGen, Te for (int i = 0; i < formatListNum; i++) { surfacePixelFmt_ = static_cast(formatListHDR[i]); requestCfg_.format = surfacePixelFmt_; - VideoProcessing_ErrorCode ret = Process(); + VideoProcessing_ErrorCode ret = ProcessContrastStyle(); + EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS); + } + } +} + +HWTEST_F(MetadataGeneratorVideoNdkImplUnitTest, testVideoProcess_metadataGen_02, TestSize.Level1) +{ + const int formatListNum = 3; + int formatListHDR[formatListNum] = {GRAPHIC_PIXEL_FMT_YCBCR_P010, GRAPHIC_PIXEL_FMT_YCRCB_P010, + GRAPHIC_PIXEL_FMT_RGBA_1010102}; + const int colorMetaMetaListNum = 4; + const int colorMetaParaNum = 2; + const int colorMetaParaInMetaNum = 0; + const int colorMetaParaInColorNum = 1; + int colorMetaList[colorMetaMetaListNum][colorMetaParaNum] = { + {CM_VIDEO_HDR10, CM_BT2020_PQ_LIMIT}, + {CM_VIDEO_HDR_VIVID, CM_BT2020_PQ_LIMIT}, + {CM_VIDEO_HLG, CM_BT2020_HLG_LIMIT}, + {CM_VIDEO_HDR_VIVID, CM_BT2020_HLG_LIMIT} + }; + for (int n = 0; n < colorMetaMetaListNum; n++) { + inMetaType_ = static_cast(colorMetaList[n][colorMetaParaInMetaNum]); + inColspc_ = static_cast(colorMetaList[n][colorMetaParaInColorNum]); + for (int i = 0; i < formatListNum; i++) { + surfacePixelFmt_ = static_cast(formatListHDR[i]); + requestCfg_.format = surfacePixelFmt_; + VideoProcessing_ErrorCode ret = ProcessBrightStyle(); EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS); } }