新增视频动态元数据生成风格选择

Signed-off-by: Hennes <lurihong@h-partners.com>

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<std::string, VPE_MODEL_KEY_NUM> 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

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<bool> initBuffer_{false};
+    std::atomic<VideoMetadataGeneratorStyle> style_{VideoMetadataGeneratorStyle::META_GEN_BRIGHT_STYLE};
 
     // task相关
     std::mutex mtxTaskDone_;

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<std::mutex> 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<std::mutex> 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<std::mutex> lock(mutex_);

framework/capi/video_processing/metadata_generator/include/metadata_generator_video_native.h

@@ -63,6 +63,7 @@ private:
 
         const std::shared_ptr<MetadataGeneratorVideoNative> owner_{};
     };
+    int CApiStyleToInner(int Style) const;
 
     mutable std::mutex lock_{};
     // Guarded by lock_ begin

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<int, int> 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<Surface> MetadataGeneratorVideoNative::GetSurface()
 
 VideoProcessing_ErrorCode MetadataGeneratorVideoNative::SetParameter(const OHOS::Media::Format& parameter)
 {
-    return VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED;
+    std::lock_guard<std::mutex> 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<VideoMetadataGeneratorStyle>(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<std::mutex> 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<int>(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]() {

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

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<double> 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);

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

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;

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"
     }
 ]

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.
  *

test/unittest/metadata_gen_video_ndk/metadata_gen_video_ndk_unit_test.cpp

@@ -74,7 +74,8 @@ public:
 
     void SetMeatadata(sptr<SurfaceBuffer> &buffer, uint32_t value);
     void SetMeatadata(sptr<SurfaceBuffer> &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<SurfaceBuffer> &bu
     }
 }
 
-VideoProcessing_ErrorCode MetadataGeneratorVideoNdkImplUnitTest::Process()
+VideoProcessing_ErrorCode MetadataGeneratorVideoNdkImplUnitTest::ProcessContrastStyle()
 {
     VideoProcessing_ErrorCode ret = VIDEO_PROCESSING_SUCCESS;
     sptr<SurfaceBuffer> 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<SurfaceBuffer> buffer;
+    CM_ColorSpaceInfo inColspcInfo = {
+        static_cast<CM_ColorPrimaries>((inColspc_ & COLORPRIMARIES_MASK) >> COLORPRIMARIES_OFFSET),
+        static_cast<CM_TransFunc>((inColspc_ & TRANSFUNC_MASK) >> TRANSFUNC_OFFSET),
+        static_cast<CM_Matrix>((inColspc_ & MATRIX_MASK) >> MATRIX_OFFSET),
+        static_cast<CM_Range>((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<GraphicPixelFormat>(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<CM_HDR_Metadata_Type>(colorMetaList[n][colorMetaParaInMetaNum]);
+        inColspc_ = static_cast<CM_ColorSpaceType>(colorMetaList[n][colorMetaParaInColorNum]);
+        for (int i = 0; i < formatListNum; i++) {
+            surfacePixelFmt_ = static_cast<GraphicPixelFormat>(formatListHDR[i]);
+            requestCfg_.format = surfacePixelFmt_;
+            VideoProcessing_ErrorCode ret = ProcessBrightStyle();
             EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
         }
     }