diff --git a/test/fuzztest/imagesdr2sdr_fuzzer/imagesdr2sdr_fuzzer.cpp b/test/fuzztest/imagesdr2sdr_fuzzer/imagesdr2sdr_fuzzer.cpp index 83cff27..e7aedee 100644 --- a/test/fuzztest/imagesdr2sdr_fuzzer/imagesdr2sdr_fuzzer.cpp +++ b/test/fuzztest/imagesdr2sdr_fuzzer/imagesdr2sdr_fuzzer.cpp @@ -29,8 +29,7 @@ constexpr uint32_t DEFAULT_WIDTH = 3840; constexpr uint32_t DEFAULT_HEIGHT = 2160; OH_ImageProcessing* imageProcessor = nullptr; -static void CreatePixelmap(OH_PixelmapNative **pixelmap, int32_t width, int32_t height, int format, - OH_NativeColorSpaceManager *colorSpaceNative) +static void CreatePixelmap(OH_PixelmapNative **pixelmap, int32_t width, int32_t height, int format, OH_NativeColorSpaceManager *colorSpaceNative) { OH_Pixelmap_InintializationOptions *options = nullptr; (void)OH_Pixelmap_InintializationOptions_Create(&options); diff --git a/test/fuzztest/videohdrvividtohdr_fuzzer/video_sample.h b/test/fuzztest/videohdrvividtohdr_fuzzer/video_sample.h index 37ba16a..bed94fe 100644 --- a/test/fuzztest/videohdrvividtohdr_fuzzer/video_sample.h +++ b/test/fuzztest/videohdrvividtohdr_fuzzer/video_sample.h @@ -12,7 +12,6 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - #ifndef VIDEO_SAMPLE_H #define VIDEO_SAMPLE_H diff --git a/test/fuzztest/videohdrvividtosdr_fuzzer/video_sample.h b/test/fuzztest/videohdrvividtosdr_fuzzer/video_sample.h index 37ba16a..bed94fe 100644 --- a/test/fuzztest/videohdrvividtosdr_fuzzer/video_sample.h +++ b/test/fuzztest/videohdrvividtosdr_fuzzer/video_sample.h @@ -12,7 +12,6 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - #ifndef VIDEO_SAMPLE_H #define VIDEO_SAMPLE_H diff --git a/test/fuzztest/videosdrtosdr_fuzzer/video_sample.h b/test/fuzztest/videosdrtosdr_fuzzer/video_sample.h index 2753f9e..ac58356 100644 --- a/test/fuzztest/videosdrtosdr_fuzzer/video_sample.h +++ b/test/fuzztest/videosdrtosdr_fuzzer/video_sample.h @@ -12,7 +12,6 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - #ifndef VIDEO_SDR2SDR_SAMPLE_H #define VIDEO_SDR2SDR_SAMPLE_H diff --git a/test/ndk/moduletest/image/BUILD.gn b/test/ndk/moduletest/image/BUILD.gn new file mode 100644 index 0000000..0de89f9 --- /dev/null +++ b/test/ndk/moduletest/image/BUILD.gn @@ -0,0 +1,84 @@ +# Copyright (c) 2024 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("//build/ohos.gni") +import("//foundation/multimedia/video_processing_engine/config.gni") + +module_output_path = MODULE_TEST_OUTPUT_PATH + +image_moduletest_native_include_dirs = [ + "$CAPI_DIR", + "$VIDEO_PROCESSING_ENGINE_ROOT_DIR/test/moduletest/common", + "$VIDEO_PROCESSING_ENGINE_ROOT_DIR/../../graphic/graphic_2d/interfaces/inner_api", + "$VIDEO_PROCESSING_ENGINE_ROOT_DIR/../../window/window_manager/interfaces/innerkits", + "$VIDEO_PROCESSING_ENGINE_ROOT_DIR/../../interface/sdk_c/multimedia/image_framework/include", + "$VIDEO_PROCESSING_ENGINE_ROOT_DIR/../image_framework/interfaces/kits/native/include", +] + +image_moduletest_cflags = [ + "-std=c++17", + "-fno-rtti", + "-fno-exceptions", + "-Wall", + "-fno-common", + "-fstack-protector-strong", + "-Wshadow", + "-FPIC", + "-FS", + "-O2", + "-D_FORTIFY_SOURCE=2", + "-fvisibility=hidden", + "-Wformat=2", + "-Wdate-time", + "-Werror", + "-Wextra", + "-Wimplicit-fallthrough", + "-Wsign-compare", + "-Wunused-parameter", +] + +################################################################################################################## +ohos_unittest("vpe_image_native_module_test") { + module_out_path = module_output_path + include_dirs = image_moduletest_native_include_dirs + include_dirs += [ "./" ] + cflags = image_moduletest_cflags + + sources = [ + "api_test.cpp", + "capability_test.cpp" + ] + + deps = [ + "$FRAMEWORK_DIR:image_processing", + "$VIDEO_PROCESSING_ENGINE_ROOT_DIR/../../arkui/napi:ace_napi", + "$VIDEO_PROCESSING_ENGINE_ROOT_DIR/../image_framework/frameworks/kits/js/common/pixelmap_ndk:pixelmap_ndk", + ] + + external_deps = [ + "c_utils:utils", + "graphic_2d:libgraphic_utils", + "graphic_2d:librender_service_client", + "graphic_surface:surface", + "hilog:libhilog", + "ipc:ipc_core", + "media_foundation:media_foundation", + "media_foundation:native_media_core", + "window_manager:libwm", + "image_framework:pixelmap", + ] + + resource_config_file = + "$VIDEO_PROCESSING_ENGINE_ROOT_DIR/test/ndk/moduletest/resources/ohos_test.xml" +} diff --git a/test/ndk/moduletest/image/api_test.cpp b/test/ndk/moduletest/image/api_test.cpp new file mode 100644 index 0000000..562b31f --- /dev/null +++ b/test/ndk/moduletest/image/api_test.cpp @@ -0,0 +1,1468 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include +#include +#include +#include +#include +#include +#include "gtest/gtest.h" +#include "image_processing.h" +#include "nocopyable.h" +#include "image/pixelmap_native.h" +#include "surface/native_buffer.h" +using namespace std; +using namespace OHOS; +using namespace testing::ext; +namespace { +constexpr uint32_t DEFAULT_WIDTH = 3840; +constexpr uint32_t DEFAULT_HEIGHT = 2160; +constexpr uint32_t PIX_SIZE = DEFAULT_WIDTH * DEFAULT_HEIGHT * 4; +uint8_t *g_pixData = nullptr; + +OH_Pixelmap_InitializationOptions *g_createOpts_RGBA = nullptr; +OH_Pixelmap_InitializationOptions *g_createOpts_BGRA = nullptr; +OH_PixelmapNative *pixelMap_RGBA = nullptr; +OH_PixelmapNative *pixelMap_BGRA = nullptr; +void InitCreatePixelmapParam_RGBA() +{ + if (g_createOpts_RGBA == nullptr) { + OH_PixelmapInitializationOptions_Create(&g_createOpts_RGBA); + OH_PixelmapInitializationOptions_SetWidth(g_createOpts_RGBA, DEFAULT_WIDTH); + OH_PixelmapInitializationOptions_SetHeight(g_createOpts_RGBA, DEFAULT_HEIGHT); + OH_PixelmapInitializationOptions_SetPixelFormat(g_createOpts_RGBA, NATIVEBUFFER_PIXEL_FMT_RGBA_8888); + } +} +void InitCreatePixelmapParam_BGRA() +{ + if (g_createOpts_BGRA == nullptr) { + OH_PixelmapInitializationOptions_Create(&g_createOpts_BGRA); + OH_PixelmapInitializationOptions_SetWidth(g_createOpts_BGRA, DEFAULT_WIDTH); + OH_PixelmapInitializationOptions_SetHeight(g_createOpts_BGRA, DEFAULT_HEIGHT); + OH_PixelmapInitializationOptions_SetPixelFormat(g_createOpts_BGRA, PIXEL_FORMAT_BGRA_8888); + } +} + + +class VpeImageApiTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); +}; + + +void VpeImageApiTest::SetUpTestCase() +{ + g_pixData = new uint8_t[PIX_SIZE]; + InitCreatePixelmapParam_RGBA(); + InitCreatePixelmapParam_BGRA(); + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &pixelMap_RGBA); + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_BGRA, &pixelMap_BGRA); +} +void VpeImageApiTest::TearDownTestCase() +{ + if (g_pixData) { + delete[] g_pixData; + } + if (g_createOpts_RGBA) { + OH_PixelmapInitializationOptions_Release(g_createOpts_RGBA); + g_createOpts_RGBA = nullptr; + } + if (g_createOpts_BGRA) { + OH_PixelmapInitializationOptions_Release(g_createOpts_BGRA); + g_createOpts_BGRA = nullptr; + } +} +void VpeImageApiTest::SetUp() +{ + +} +void VpeImageApiTest::TearDown() +{ + OH_ImageProcessing_DeinitializeEnvironment(); +} + + +const ImageProcessing_ColorSpaceInfo SRC_INFO = {0, + OH_COLORSPACE_SRGB_FULL, + NATIVEBUFFER_PIXEL_FMT_RGBA_8888}; +const ImageProcessing_ColorSpaceInfo DST_INFO = {0, + OH_COLORSPACE_P3_FULL, + NATIVEBUFFER_PIXEL_FMT_RGBA_8888}; +const ImageProcessing_ColorSpaceInfo SRC_GAIN_INFO = {0, + OH_COLORSPACE_SRGB_FULL, + NATIVEBUFFER_PIXEL_FMT_RGBA_8888}; +const ImageProcessing_ColorSpaceInfo DST_GAIN_INFO = {0, + OH_COLORSPACE_BT709_FULL, + NATIVEBUFFER_PIXEL_FMT_RGBA_8888}; +const ImageProcessing_ColorSpaceInfo UNSUPPORTED_INFO = {0, + OH_COLORSPACE_BT601_EBU_FULL, + NATIVEBUFFER_PIXEL_FMT_BGRX_8888}; + +} + +namespace { +/** + * @tc.number : VPE_IMAGE_API_TEST_0010 + * @tc.name : first call OH_ImageProcessing_InitializeEnvironment + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0010, TestSize.Level0) +{ + ImageProcessing_ErrorCode ret = OH_ImageProcessing_InitializeEnvironment(); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS); + } + OH_ImageProcessing_DeinitializeEnvironment(); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0020 + * @tc.name : first call OH_ImageProcessing_DeinitializeEnvironment + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0020, TestSize.Level0) +{ + ImageProcessing_ErrorCode ret = OH_ImageProcessing_DeinitializeEnvironment(); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_OPERATION_NOT_PERMITTED); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_OPERATION_NOT_PERMITTED); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0030 + * @tc.name : first call OH_ImageProcessing_DeinitializeEnvironment after initialize + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0030, TestSize.Level0) +{ + ImageProcessing_ErrorCode ret = OH_ImageProcessing_InitializeEnvironment(); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_ImageProcessing_DeinitializeEnvironment(); + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0040 + * @tc.name : call OH_ImageProcessing_IsColorSpaceConversionSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0040, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsColorSpaceConversionSupported(nullptr, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0050 + * @tc.name : call OH_ImageProcessing_IsColorSpaceConversionSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0050, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsColorSpaceConversionSupported(&SRC_INFO, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0060 + * @tc.name : call OH_ImageProcessing_IsColorSpaceConversionSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0060, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsColorSpaceConversionSupported(nullptr, &DST_INFO); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0070 + * @tc.name : call OH_ImageProcessing_IsColorSpaceConversionSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0070, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsColorSpaceConversionSupported(&SRC_INFO, &DST_INFO); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_TRUE(ret); + } else { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0080 + * @tc.name : call OH_ImageProcessing_IsCompositionSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0080, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsCompositionSupported(nullptr, nullptr, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0090 + * @tc.name : call OH_ImageProcessing_IsCompositionSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0090, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsCompositionSupported(&SRC_INFO, nullptr, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0100 + * @tc.name : call OH_ImageProcessing_IsCompositionSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0100, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsCompositionSupported(nullptr, nullptr, &DST_INFO); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0110 + * @tc.name : call OH_ImageProcessing_IsCompositionSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0110, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsCompositionSupported(nullptr, &SRC_GAIN_INFO, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0120 + * @tc.name : call OH_ImageProcessing_IsCompositionSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0120, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsCompositionSupported(&SRC_INFO, nullptr, &DST_INFO); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0130 + * @tc.name : call OH_ImageProcessing_IsCompositionSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0130, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsCompositionSupported(nullptr, &SRC_GAIN_INFO, &DST_INFO); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0131 + * @tc.name : call OH_ImageProcessing_IsCompositionSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0131, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsCompositionSupported(&SRC_INFO, &SRC_GAIN_INFO, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0140 + * @tc.name : call OH_ImageProcessing_IsCompositionSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0140, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsCompositionSupported(&SRC_INFO, &SRC_GAIN_INFO, &DST_INFO); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_TRUE(ret); + } else { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0150 + * @tc.name : call OH_ImageProcessing_IsDecompositionSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0150, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsDecompositionSupported(nullptr, nullptr, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0160 + * @tc.name : call OH_ImageProcessing_IsDecompositionSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0160, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsDecompositionSupported(&SRC_INFO, nullptr, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0170 + * @tc.name : call OH_ImageProcessing_IsDecompositionSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0170, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsDecompositionSupported(nullptr, &DST_INFO, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0180 + * @tc.name : call OH_ImageProcessing_IsDecompositionSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0180, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsDecompositionSupported(nullptr, nullptr, &DST_GAIN_INFO); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0190 + * @tc.name : call OH_ImageProcessing_IsDecompositionSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0190, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsDecompositionSupported(&SRC_INFO, nullptr, &DST_GAIN_INFO); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0200 + * @tc.name : call OH_ImageProcessing_IsDecompositionSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0200, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsDecompositionSupported(nullptr, &DST_INFO, &DST_GAIN_INFO); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0201 + * @tc.name : call OH_ImageProcessing_IsDecompositionSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0201, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsDecompositionSupported(&SRC_INFO, &DST_INFO, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0210 + * @tc.name : call OH_ImageProcessing_IsDecompositionSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0210, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsDecompositionSupported(&SRC_INFO, &DST_INFO, &DST_GAIN_INFO); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_TRUE(ret); + } else { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0220 + * @tc.name : call OH_ImageProcessing_IsMetadataGenerationSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0220, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsMetadataGenerationSupported(nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0230 + * @tc.name : call OH_ImageProcessing_IsMetadataGenerationSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0230, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + const ImageProcessing_ColorSpaceInfo HDR_INFO = {0, OH_COLORSPACE_BT2020_PQ_LIMIT, + NATIVEBUFFER_PIXEL_FMT_RGBA_1010102}; + bool ret = OH_ImageProcessing_IsMetadataGenerationSupported(&HDR_INFO); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_TRUE(ret); + } else { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0240 + * @tc.name : call OH_ImageProcessing_Create + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0240, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(nullptr, INT_MAX); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0250 + * @tc.name : call OH_ImageProcessing_Create + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0250, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(nullptr, + IMAGE_PROCESSING_TYPE_METADATA_GENERATION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0260 + * @tc.name : call OH_ImageProcessing_Create + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0260, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, INT_MAX); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + } + OH_ImageProcessing_Destroy(imageProcessor); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0270 + * @tc.name : call OH_ImageProcessing_Create + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0270, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_METADATA_GENERATION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS); + } + OH_ImageProcessing_Destroy(imageProcessor); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0280 + * @tc.name : call OH_ImageProcessing_Destroy + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0280, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Destroy(nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0290 + * @tc.name : call OH_ImageProcessing_Destroy + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0290, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_METADATA_GENERATION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + ret = OH_ImageProcessing_Destroy(imageProcessor); + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0450 + * @tc.name : call OH_ImageProcessing_ConvertColorSpace + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0450, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + ImageProcessing_ErrorCode ret = OH_ImageProcessing_ConvertColorSpace(nullptr, + nullptr, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0460 + * @tc.name : call OH_ImageProcessing_ConvertColorSpace + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0460, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_COLOR_SPACE_CONVERSION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + ret = OH_ImageProcessing_ConvertColorSpace(imageProcessor, nullptr, nullptr); + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + } + OH_ImageProcessing_Destroy(imageProcessor); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0470 + * @tc.name : call OH_ImageProcessing_ConvertColorSpace + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0470, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + ImageProcessing_ErrorCode ret = OH_ImageProcessing_ConvertColorSpace(nullptr, pixelMap_RGBA, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0480 + * @tc.name : call OH_ImageProcessing_ConvertColorSpace + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0480, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + ImageProcessing_ErrorCode ret = OH_ImageProcessing_ConvertColorSpace( + nullptr, nullptr, pixelMap_RGBA); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0490 + * @tc.name : call OH_ImageProcessing_ConvertColorSpace + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0490, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_COLOR_SPACE_CONVERSION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + ret = OH_ImageProcessing_ConvertColorSpace(imageProcessor, nullptr, pixelMap_RGBA); + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + } + OH_ImageProcessing_Destroy(imageProcessor); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0500 + * @tc.name : call OH_ImageProcessing_ConvertColorSpace + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0500, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_PixelmapNative *src_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA); + OH_PixelmapNative *dst_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA); + ImageProcessing_ErrorCode ret = OH_ImageProcessing_ConvertColorSpace( + nullptr, src_pixelMap_RGBA, dst_pixelMap_RGBA); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } + OH_PixelmapNative_Release(src_pixelMap_RGBA); + OH_PixelmapNative_Release(dst_pixelMap_RGBA); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0510 + * @tc.name : call OH_ImageProcessing_ConvertColorSpace with the color space + * of the image is unsupported. + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0510, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_COLOR_SPACE_CONVERSION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + ret = OH_ImageProcessing_ConvertColorSpace(imageProcessor, pixelMap_RGBA, pixelMap_BGRA); + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_UNSUPPORTED_PROCESSING); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS); + } + OH_ImageProcessing_Destroy(imageProcessor); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0520 + * @tc.name : call OH_ImageProcessing_ConvertColorSpace + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0520, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_COLOR_SPACE_CONVERSION); + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative *src_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA); + OH_PixelmapNative *dst_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA); + ret = OH_ImageProcessing_ConvertColorSpace(imageProcessor, src_pixelMap_RGBA, dst_pixelMap_RGBA); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_SUCCESS); + } + OH_ImageProcessing_Destroy(imageProcessor); + OH_PixelmapNative_Release(src_pixelMap_RGBA); + OH_PixelmapNative_Release(dst_pixelMap_RGBA); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0530 + * @tc.name : call OH_ImageProcessing_Compose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0530, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Compose(nullptr, nullptr, nullptr, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0540 + * @tc.name : call OH_ImageProcessing_Compose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0540, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_COMPOSITION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + ret = OH_ImageProcessing_Compose(imageProcessor, nullptr, nullptr, nullptr); + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + } + OH_ImageProcessing_Destroy(imageProcessor); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0550 + * @tc.name : call OH_ImageProcessing_Compose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0550, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_PixelmapNative *src_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA); + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Compose(nullptr, src_pixelMap_RGBA, nullptr, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } + OH_PixelmapNative_Release(src_pixelMap_RGBA); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0560 + * @tc.name : call OH_ImageProcessing_Compose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0560, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_PixelmapNative *src_gain_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_gain_pixelMap_RGBA); + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Compose(nullptr, nullptr, src_gain_pixelMap_RGBA, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } + OH_PixelmapNative_Release(src_gain_pixelMap_RGBA); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0570 + * @tc.name : call OH_ImageProcessing_Compose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0570, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_PixelmapNative *dst_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA); + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Compose(nullptr, nullptr, nullptr, dst_pixelMap_RGBA); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } + OH_PixelmapNative_Release(dst_pixelMap_RGBA); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0580 + * @tc.name : call OH_ImageProcessing_Compose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0580, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_COMPOSITION); + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative *src_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA); + ret = OH_ImageProcessing_Compose(imageProcessor, src_pixelMap_RGBA, nullptr, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + } + OH_ImageProcessing_Destroy(imageProcessor); + OH_PixelmapNative_Release(src_pixelMap_RGBA); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0590 + * @tc.name : call OH_ImageProcessing_Compose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0590, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_COMPOSITION); + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative *src_gain_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_gain_pixelMap_RGBA); + ret = OH_ImageProcessing_Compose(imageProcessor, nullptr, src_gain_pixelMap_RGBA, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + } + OH_ImageProcessing_Destroy(imageProcessor); + OH_PixelmapNative_Release(src_gain_pixelMap_RGBA); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0600 + * @tc.name : call OH_ImageProcessing_Compose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0600, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_COMPOSITION); + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative *dst_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA); + ret = OH_ImageProcessing_Compose(imageProcessor, nullptr, nullptr, dst_pixelMap_RGBA); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + } + OH_ImageProcessing_Destroy(imageProcessor); + OH_PixelmapNative_Release(dst_pixelMap_RGBA); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0610 + * @tc.name : call OH_ImageProcessing_Compose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0610, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_COMPOSITION); + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative *src_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA); + OH_PixelmapNative *src_gain_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_gain_pixelMap_RGBA); + ret = OH_ImageProcessing_Compose(imageProcessor, src_pixelMap_RGBA, src_gain_pixelMap_RGBA, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + } + OH_ImageProcessing_Destroy(imageProcessor); + OH_PixelmapNative_Release(src_pixelMap_RGBA); + OH_PixelmapNative_Release(src_gain_pixelMap_RGBA); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0620 + * @tc.name : call OH_ImageProcessing_Compose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0620, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_COMPOSITION); + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative *src_gain_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_gain_pixelMap_RGBA); + OH_PixelmapNative *dst_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA); + ret = OH_ImageProcessing_Compose(imageProcessor, nullptr, src_gain_pixelMap_RGBA, dst_pixelMap_RGBA); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + } + OH_ImageProcessing_Destroy(imageProcessor); + OH_PixelmapNative_Release(src_gain_pixelMap_RGBA); + OH_PixelmapNative_Release(dst_pixelMap_RGBA); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0630 + * @tc.name : call OH_ImageProcessing_Compose by the color space + * of the image is unsupported. + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0630, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_COMPOSITION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative *src_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA); + OH_PixelmapNative *src_gain_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_gain_pixelMap_RGBA); + OH_PixelmapNative *dst_pixelMap_BGRA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_BGRA, &dst_pixelMap_BGRA); + ret = OH_ImageProcessing_Compose(imageProcessor, src_pixelMap_RGBA, src_gain_pixelMap_RGBA, dst_pixelMap_BGRA); + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_UNSUPPORTED_PROCESSING); + OH_PixelmapNative_Release(src_pixelMap_RGBA); + OH_PixelmapNative_Release(src_gain_pixelMap_RGBA); + OH_PixelmapNative_Release(dst_pixelMap_BGRA); + } + OH_ImageProcessing_Destroy(imageProcessor); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0640 + * @tc.name : call OH_ImageProcessing_Compose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0640, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_COMPOSITION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative *src_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA); + OH_PixelmapNative *src_gain_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_gain_pixelMap_RGBA); + OH_PixelmapNative *dst_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA); + ret = OH_ImageProcessing_Compose(imageProcessor, src_pixelMap_RGBA, src_gain_pixelMap_RGBA, dst_pixelMap_RGBA); + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative_Release(src_pixelMap_RGBA); + OH_PixelmapNative_Release(src_gain_pixelMap_RGBA); + OH_PixelmapNative_Release(dst_pixelMap_RGBA); + } + OH_ImageProcessing_Destroy(imageProcessor); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0650 + * @tc.name : call OH_ImageProcessing_Decompose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0650, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Decompose(nullptr, nullptr, nullptr, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0660 + * @tc.name : call OH_ImageProcessing_Decompose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0660, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_DECOMPOSITION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + ret = OH_ImageProcessing_Decompose(imageProcessor, nullptr, nullptr, nullptr); + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + } + OH_ImageProcessing_Destroy(imageProcessor); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0670 + * @tc.name : call OH_ImageProcessing_Decompose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0670, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_PixelmapNative *src_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA); + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Decompose(nullptr, src_pixelMap_RGBA, nullptr, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } + OH_PixelmapNative_Release(src_pixelMap_RGBA); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0680 + * @tc.name : call OH_ImageProcessing_Decompose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0680, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_PixelmapNative *dst_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA); + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Decompose(nullptr, nullptr, dst_pixelMap_RGBA, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } + OH_PixelmapNative_Release(dst_pixelMap_RGBA); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0690 + * @tc.name : call OH_ImageProcessing_Decompose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0690, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_PixelmapNative *dst_gain_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_gain_pixelMap_RGBA); + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Decompose(nullptr, nullptr, nullptr, dst_gain_pixelMap_RGBA); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } + OH_PixelmapNative_Release(dst_gain_pixelMap_RGBA); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0700 + * @tc.name : call OH_ImageProcessing_Decompose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0700, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_DECOMPOSITION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative *src_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA); + ret = OH_ImageProcessing_Decompose(imageProcessor, src_pixelMap_RGBA, nullptr, nullptr); + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + OH_PixelmapNative_Release(src_pixelMap_RGBA); + } + OH_ImageProcessing_Destroy(imageProcessor); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0710 + * @tc.name : call OH_ImageProcessing_Decompose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0710, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_DECOMPOSITION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative *dst_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA); + ret = OH_ImageProcessing_Decompose(imageProcessor, nullptr, dst_pixelMap_RGBA, nullptr); + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + OH_PixelmapNative_Release(dst_pixelMap_RGBA); + } + OH_ImageProcessing_Destroy(imageProcessor); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0720 + * @tc.name : call OH_ImageProcessing_Decompose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0720, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_DECOMPOSITION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative *dst_gain_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_gain_pixelMap_RGBA); + ret = OH_ImageProcessing_Decompose(imageProcessor, nullptr, nullptr, dst_gain_pixelMap_RGBA); + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + OH_PixelmapNative_Release(dst_gain_pixelMap_RGBA); + } + OH_ImageProcessing_Destroy(imageProcessor); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0730 + * @tc.name : call OH_ImageProcessing_Decompose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0730, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_DECOMPOSITION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative *src_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA); + OH_PixelmapNative *dst_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA); + ret = OH_ImageProcessing_Decompose(imageProcessor, src_pixelMap_RGBA, dst_pixelMap_RGBA, nullptr); + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + OH_PixelmapNative_Release(src_pixelMap_RGBA); + OH_PixelmapNative_Release(dst_pixelMap_RGBA); + } + OH_ImageProcessing_Destroy(imageProcessor); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0740 + * @tc.name : call OH_ImageProcessing_Decompose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0740, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_DECOMPOSITION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative *dst_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA); + OH_PixelmapNative *dst_gain_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_gain_pixelMap_RGBA); + ret = OH_ImageProcessing_Decompose(imageProcessor, nullptr, + dst_pixelMap_RGBA, dst_gain_pixelMap_RGBA); + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + OH_PixelmapNative_Release(dst_pixelMap_RGBA); + OH_PixelmapNative_Release(dst_gain_pixelMap_RGBA); + } + OH_ImageProcessing_Destroy(imageProcessor); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0750 + * @tc.name : call OH_ImageProcessing_Decompose by the color space + * of the image is unsupported. + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0750, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_DECOMPOSITION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative *src_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA); + OH_PixelmapNative *dst_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA); + OH_PixelmapNative *dst_gain_pixelMap_BGRA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_BGRA, &dst_gain_pixelMap_BGRA); + ret = OH_ImageProcessing_Decompose(imageProcessor, src_pixelMap_RGBA, + dst_pixelMap_RGBA, dst_gain_pixelMap_BGRA); + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_UNSUPPORTED_PROCESSING); + OH_PixelmapNative_Release(src_pixelMap_RGBA); + OH_PixelmapNative_Release(dst_pixelMap_RGBA); + OH_PixelmapNative_Release(dst_gain_pixelMap_BGRA); + } + OH_ImageProcessing_Destroy(imageProcessor); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0760 + * @tc.name : call OH_ImageProcessing_Decompose + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0760, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_DECOMPOSITION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative *src_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA); + OH_PixelmapNative *dst_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA); + OH_PixelmapNative *dst_gain_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_gain_pixelMap_RGBA); + ret = OH_ImageProcessing_Decompose(imageProcessor, src_pixelMap_RGBA, + dst_pixelMap_RGBA, dst_gain_pixelMap_RGBA); + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative_Release(src_pixelMap_RGBA); + OH_PixelmapNative_Release(dst_pixelMap_RGBA); + OH_PixelmapNative_Release(dst_gain_pixelMap_RGBA); + } + OH_ImageProcessing_Destroy(imageProcessor); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0770 + * @tc.name : call OH_ImageProcessing_GenerateMetadata + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0770, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + ImageProcessing_ErrorCode ret = OH_ImageProcessing_GenerateMetadata(nullptr, nullptr); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } else { + EXPECT_NE(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0780 + * @tc.name : call OH_ImageProcessing_GenerateMetadata + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0780, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_METADATA_GENERATION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + ret = OH_ImageProcessing_GenerateMetadata(imageProcessor, nullptr); + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_PARAMETER); + } + OH_ImageProcessing_Destroy(imageProcessor); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0790 + * @tc.name : call OH_ImageProcessing_GenerateMetadata by the color space + * of the image is unsupported. + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0790, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_METADATA_GENERATION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative *src_pixelMap_BGRA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_BGRA, &src_pixelMap_BGRA); + ret = OH_ImageProcessing_GenerateMetadata(imageProcessor, src_pixelMap_BGRA); + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_UNSUPPORTED_PROCESSING); + OH_PixelmapNative_Release(src_pixelMap_BGRA); + } + OH_ImageProcessing_Destroy(imageProcessor); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0800 + * @tc.name : call OH_ImageProcessing_GenerateMetadata + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0800, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_ImageProcessing* imageProcessor = nullptr; + ImageProcessing_ErrorCode ret = OH_ImageProcessing_Create(&imageProcessor, + IMAGE_PROCESSING_TYPE_METADATA_GENERATION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative *src_pixelMap_RGBA = nullptr; + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA); + ret = OH_ImageProcessing_GenerateMetadata(imageProcessor, src_pixelMap_RGBA); + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative_Release(src_pixelMap_RGBA); + } + OH_ImageProcessing_Destroy(imageProcessor); +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0890 + * @tc.name : call OH_ImageProcessing_IsColorSpaceConversionSupported + * the the color space conversion is unsupported. + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0890, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsColorSpaceConversionSupported(&UNSUPPORTED_INFO, &DST_INFO); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0900 + * @tc.name : call OH_ImageProcessing_IsCompositionSupported + * the the color space conversion is unsupported. + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0900, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsCompositionSupported(&UNSUPPORTED_INFO, &SRC_GAIN_INFO, &DST_INFO); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0910 + * @tc.name : call OH_ImageProcessing_IsDecompositionSupported + * the the color space conversion is unsupported. + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0910, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsDecompositionSupported(&UNSUPPORTED_INFO, &DST_INFO, &DST_GAIN_INFO); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0920 + * @tc.name : call OH_ImageProcessing_IsMetadataGenerationSupported + * the the color space conversion is unsupported. + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0920, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + bool ret = OH_ImageProcessing_IsMetadataGenerationSupported(&UNSUPPORTED_INFO); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + ASSERT_FALSE(ret); + } +} + +/** + * @tc.number : VPE_IMAGE_API_TEST_0930 + * @tc.name : call OH_ImageProcessing_IsMetadataGenerationSupported + * @tc.desc : function test + */ +HWTEST_F(VpeImageApiTest, VPE_IMAGE_API_TEST_0930, TestSize.Level0) +{ + OH_ImageProcessing_InitializeEnvironment(); + OH_PixelmapNative *src_pixelMap_RGBA = nullptr; + OH_PixelmapNative *src_gain_pixelMap_RGBA = nullptr; + OH_PixelmapNative *dst_pixelMap_RGBA = nullptr; + OH_PixelmapNative *dst_gain_pixelMap_RGBA = nullptr; + OH_ImageProcessing* imageProcessor = nullptr; + int32_t ret = OH_ImageProcessing_Create(&imageProcessor, IMAGE_PROCESSING_TYPE_COLOR_SPACE_CONVERSION); + if (!access("/system/lib64/ndk/libvideo_processing_capi_impl.so", 0)) { + EXPECT_EQ(ret, IMAGE_PROCESSING_SUCCESS); + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_pixelMap_RGBA); + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_pixelMap_RGBA); + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &src_gain_pixelMap_RGBA); + ret = OH_ImageProcessing_Compose(imageProcessor, src_pixelMap_RGBA, + src_gain_pixelMap_RGBA, dst_pixelMap_RGBA); + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + OH_PixelmapNative_CreatePixelmap(g_pixData, PIX_SIZE, g_createOpts_RGBA, &dst_gain_pixelMap_RGBA); + ret = OH_ImageProcessing_Decompose(imageProcessor, src_pixelMap_RGBA, + dst_pixelMap_RGBA, dst_gain_pixelMap_RGBA); + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + ret = OH_ImageProcessing_GenerateMetadata(imageProcessor, src_pixelMap_RGBA); + EXPECT_EQ(ret, IMAGE_PROCESSING_ERROR_INVALID_INSTANCE); + } + OH_PixelmapNative_Release(src_pixelMap_RGBA); + OH_PixelmapNative_Release(src_gain_pixelMap_RGBA); + OH_PixelmapNative_Release(dst_pixelMap_RGBA); + OH_PixelmapNative_Release(dst_gain_pixelMap_RGBA); +} +} \ No newline at end of file diff --git a/test/ndk/moduletest/image/capability_test.cpp b/test/ndk/moduletest/image/capability_test.cpp new file mode 100644 index 0000000..1e8802b --- /dev/null +++ b/test/ndk/moduletest/image/capability_test.cpp @@ -0,0 +1,817 @@ +/* + * Copyright (C) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include +#include "gtest/gtest.h" +#include "video_processing.h" +#include "image_processing_types.h" +#include "image_processing.h" +#include "enum_list.h" +#include "image/pixelmap_native.h" + +using namespace std; +// using namespace OHOS; +// using namespace OHOS::Media; +using namespace testing::ext; +namespace { +class VpeVideoCapTest : public testing::Test { +public: + // SetUpTestCase: Called before all test cases + static void SetUpTestCase(void); + // TearDownTestCase: Called after all test case + static void TearDownTestCase(void); + // SetUp: Called before each test cases + void SetUp(void); + // TearDown: Called after each test cases + void TearDown(void); +}; +void VpeVideoCapTest::SetUpTestCase() +{ + OH_ImageProcessing_InitializeEnvironment(); +} +void VpeVideoCapTest::TearDownTestCase() +{ + OH_ImageProcessing_DeinitializeEnvironment(); +} +void VpeVideoCapTest::SetUp() {} +void VpeVideoCapTest::TearDown() {} +} +namespace { +/** + * @tc.number : COLORSPACE_SUPPORT_001 + * @tc.name : adobergb to srgb + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_SUPPORT_001, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + ImageProcessing_ColorSpaceInfo outputFormat; + inputFormat.metadataType = NONE; + inputFormat.colorSpace = ADOBE_RGB_1998; + inputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + outputFormat.metadataType = NONE; + outputFormat.colorSpace = SRGB; + outputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsColorSpaceConversionSupported(&inputFormat, &outputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsColorSpaceConversionSupported(&inputFormat, &outputFormat)); + } +} + + +/** + * @tc.number : COLORSPACE_SUPPORT_002 + * @tc.name : adobergb to display p3 + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_SUPPORT_002, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + ImageProcessing_ColorSpaceInfo outputFormat; + inputFormat.metadataType = NONE; + inputFormat.colorSpace = ADOBE_RGB_1998; + inputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + outputFormat.metadataType = NONE; + outputFormat.colorSpace = DISPLAY_P3; + outputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsColorSpaceConversionSupported(&inputFormat, &outputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsColorSpaceConversionSupported(&inputFormat, &outputFormat)); + } +} + +/** + * @tc.number : COLORSPACE_SUPPORT_003 + * @tc.name : srgb to display p3 + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_SUPPORT_003, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + ImageProcessing_ColorSpaceInfo outputFormat; + inputFormat.metadataType = NONE; + inputFormat.colorSpace = SRGB; + inputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + outputFormat.metadataType = NONE; + outputFormat.colorSpace = DISPLAY_P3; + outputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsColorSpaceConversionSupported(&inputFormat, &outputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsColorSpaceConversionSupported(&inputFormat, &outputFormat)); + } +} + +/** + * @tc.number : COLORSPACE_SUPPORT_004 + * @tc.name : display p3 to srgb + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_SUPPORT_004, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + ImageProcessing_ColorSpaceInfo outputFormat; + inputFormat.metadataType = NONE; + inputFormat.colorSpace = DISPLAY_P3; + inputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + outputFormat.metadataType = NONE; + outputFormat.colorSpace = SRGB; + outputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsColorSpaceConversionSupported(&inputFormat, &outputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsColorSpaceConversionSupported(&inputFormat, &outputFormat)); + } +} + +/** + * @tc.number : COLORSPACE_SUPPORT_005 + * @tc.name : srgb to hlg rgba + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_SUPPORT_005, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + ImageProcessing_ColorSpaceInfo outputFormat; + inputFormat.metadataType = NONE; + inputFormat.colorSpace = SRGB; + inputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + outputFormat.metadataType = ALTERNATE; + outputFormat.colorSpace = BT2020_HLG; + outputFormat.pixelFormat = PIXEL_FORMAT_RGBA_1010102; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsColorSpaceConversionSupported(&inputFormat, &outputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsColorSpaceConversionSupported(&inputFormat, &outputFormat)); + } +} + +/** + * @tc.number : COLORSPACE_SUPPORT_006 + * @tc.name : srgb to hlg p010 + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_SUPPORT_006, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + ImageProcessing_ColorSpaceInfo outputFormat; + inputFormat.metadataType = NONE; + inputFormat.colorSpace = SRGB; + inputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + outputFormat.metadataType = ALTERNATE; + outputFormat.colorSpace = BT2020_HLG; + outputFormat.pixelFormat = PIXEL_FORMAT_YCBCR_P010; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsColorSpaceConversionSupported(&inputFormat, &outputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsColorSpaceConversionSupported(&inputFormat, &outputFormat)); + } +} + + +/** + * @tc.number : COLORSPACE_SUPPORT_007 + * @tc.name : p3 to hlg rgba + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_SUPPORT_007, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + ImageProcessing_ColorSpaceInfo outputFormat; + inputFormat.metadataType = NONE; + inputFormat.colorSpace = DISPLAY_P3; + inputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + outputFormat.metadataType = ALTERNATE; + outputFormat.colorSpace = BT2020_HLG; + outputFormat.pixelFormat = PIXEL_FORMAT_RGBA_1010102; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsColorSpaceConversionSupported(&inputFormat, &outputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsColorSpaceConversionSupported(&inputFormat, &outputFormat)); + } +} + +/** + * @tc.number : COLORSPACE_SUPPORT_008 + * @tc.name : p3 to hlg p010 + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_SUPPORT_008, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + ImageProcessing_ColorSpaceInfo outputFormat; + inputFormat.metadataType = NONE; + inputFormat.colorSpace = DISPLAY_P3; + inputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + outputFormat.metadataType = ALTERNATE; + outputFormat.colorSpace = BT2020_HLG; + outputFormat.pixelFormat = PIXEL_FORMAT_YCBCR_P010; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsColorSpaceConversionSupported(&inputFormat, &outputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsColorSpaceConversionSupported(&inputFormat, &outputFormat)); + } +} + +/** + * @tc.number : COLORSPACE_DECOMPOSE_0010 + * @tc.name : hlg 10bit rgba to p3 8bit rgba + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_DECOMPOSE_0010, TestSize.Level0) +{ + ImageProcessing_ColorSpaceInfo sourceImageInfo = {ALTERNATE, + BT2020_HLG, + PIXEL_FORMAT_RGBA_1010102}; + ImageProcessing_ColorSpaceInfo destinationImageInfo = {BASE, + DISPLAY_P3, + PIXEL_FORMAT_RGBA_8888}; + ImageProcessing_ColorSpaceInfo destinationGainmapInfo = {GAINMAP, + DISPLAY_P3, + PIXEL_FORMAT_RGBA_8888}; + ASSERT_TRUE(OH_ImageProcessing_IsDecompositionSupported(&sourceImageInfo, &destinationImageInfo, &destinationGainmapInfo)); +} + +/** + * @tc.number : COLORSPACE_DECOMPOSE_0020 + * @tc.name : hlg 10bit rgba to srgb 8bit rgba + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_DECOMPOSE_0020, TestSize.Level1) +{ + ImageProcessing_ColorSpaceInfo sourceImageInfo = {ALTERNATE, + BT2020_HLG, + PIXEL_FORMAT_RGBA_1010102}; + ImageProcessing_ColorSpaceInfo destinationImageInfo = {BASE, + DISPLAY_SRGB, + PIXEL_FORMAT_RGBA_8888}; + ImageProcessing_ColorSpaceInfo destinationGainmapInfo = {GAINMAP, + DISPLAY_SRGB, + PIXEL_FORMAT_RGBA_8888}; + ASSERT_TRUE(OH_ImageProcessing_IsDecompositionSupported(&sourceImageInfo, &destinationImageInfo, &destinationGainmapInfo)); +} + +/** + * @tc.number : COLORSPACE_DECOMPOSE_0030 + * @tc.name : hlg 10bit nv12 to p3 8bit rgba + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_DECOMPOSE_0030, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo sourceImageInfo = {ALTERNATE, + BT2020_HLG, + PIXEL_FORMAT_YCBCR_P010}; + ImageProcessing_ColorSpaceInfo destinationImageInfo = {BASE, + DISPLAY_P3, + PIXEL_FORMAT_RGBA_8888}; + ImageProcessing_ColorSpaceInfo destinationGainmapInfo = {GAINMAP, + DISPLAY_P3, + PIXEL_FORMAT_RGBA_8888}; + ASSERT_TRUE(OH_ImageProcessing_IsDecompositionSupported(&sourceImageInfo, &destinationImageInfo, &destinationGainmapInfo)); +} + +/** + * @tc.number : COLORSPACE_DECOMPOSE_0040 + * @tc.name : hlg 10bit nv12 to hlg 8bit rgba + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_DECOMPOSE_0040, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo sourceImageInfo = {ALTERNATE, + BT2020_HLG, + PIXEL_FORMAT_YCBCR_P010}; + ImageProcessing_ColorSpaceInfo destinationImageInfo = {BASE, + DISPLAY_SRGB, + PIXEL_FORMAT_RGBA_8888}; + ImageProcessing_ColorSpaceInfo destinationGainmapInfo = {GAINMAP, + DISPLAY_SRGB, + PIXEL_FORMAT_RGBA_8888}; + ASSERT_TRUE(OH_ImageProcessing_IsDecompositionSupported(&sourceImageInfo, &destinationImageInfo, &destinationGainmapInfo)); +} + +/** + * @tc.number : COLORSPACE_DECOMPOSE_0050 + * @tc.name : hlg 10bit nv21 to P3 8bit rgba + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_DECOMPOSE_0050, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo sourceImageInfo = {ALTERNATE, + BT2020_HLG, + PIXEL_FORMAT_YCRCB_P010}; + ImageProcessing_ColorSpaceInfo destinationImageInfo = {BASE, + DISPLAY_P3, + PIXEL_FORMAT_RGBA_8888}; + ImageProcessing_ColorSpaceInfo destinationGainmapInfo = {GAINMAP, + DISPLAY_P3, + PIXEL_FORMAT_RGBA_8888}; + ASSERT_TRUE(OH_ImageProcessing_IsDecompositionSupported(&sourceImageInfo, &destinationImageInfo, &destinationGainmapInfo)); +} + +/** + * @tc.number : COLORSPACE_DECOMPOSE_0060 + * @tc.name : hlg 10bit nv21 to hlg 8bit rgba + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_DECOMPOSE_0060, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo sourceImageInfo = {ALTERNATE, + BT2020_HLG, + PIXEL_FORMAT_YCRCB_P010}; + ImageProcessing_ColorSpaceInfo destinationImageInfo = {BASE, + DISPLAY_SRGB, + PIXEL_FORMAT_RGBA_8888}; + ImageProcessing_ColorSpaceInfo destinationGainmapInfo = {GAINMAP, + DISPLAY_SRGB, + PIXEL_FORMAT_RGBA_8888}; + ASSERT_TRUE(OH_ImageProcessing_IsDecompositionSupported(&sourceImageInfo, &destinationImageInfo, &destinationGainmapInfo)); +} + +/** + * @tc.number : COLORSPACE_DECOMPOSE_0070 + * @tc.name : pq 10bit rgba to p3 8bit rgba + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_DECOMPOSE_0070, TestSize.Level0) +{ + ImageProcessing_ColorSpaceInfo sourceImageInfo = {ALTERNATE, + BT2020_PQ, + PIXEL_FORMAT_RGBA_1010102}; + ImageProcessing_ColorSpaceInfo destinationImageInfo = {BASE, + DISPLAY_P3, + PIXEL_FORMAT_RGBA_8888}; + ImageProcessing_ColorSpaceInfo destinationGainmapInfo = {GAINMAP, + DISPLAY_P3, + PIXEL_FORMAT_RGBA_8888}; + ASSERT_TRUE(OH_ImageProcessing_IsDecompositionSupported(&sourceImageInfo, &destinationImageInfo, &destinationGainmapInfo)); +} + +/** + * @tc.number : COLORSPACE_DECOMPOSE_0080 + * @tc.name : pq 10bit rgba to srgb 8bit rgba + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_DECOMPOSE_0080, TestSize.Level1) +{ + ImageProcessing_ColorSpaceInfo sourceImageInfo = {ALTERNATE, + BT2020_PQ, + PIXEL_FORMAT_RGBA_1010102}; + ImageProcessing_ColorSpaceInfo destinationImageInfo = {BASE, + DISPLAY_SRGB, + PIXEL_FORMAT_RGBA_8888}; + ImageProcessing_ColorSpaceInfo destinationGainmapInfo = {GAINMAP, + DISPLAY_SRGB, + PIXEL_FORMAT_RGBA_8888}; + ASSERT_TRUE(OH_ImageProcessing_IsDecompositionSupported(&sourceImageInfo, &destinationImageInfo, &destinationGainmapInfo)); +} + +/** + * @tc.number : COLORSPACE_DECOMPOSE_0090 + * @tc.name : pq 10bit nv12 to P3 8bit rgba + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_DECOMPOSE_0090, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo sourceImageInfo = {ALTERNATE, + BT2020_PQ, + PIXEL_FORMAT_YCBCR_P010}; + ImageProcessing_ColorSpaceInfo destinationImageInfo = {BASE, + DISPLAY_P3, + PIXEL_FORMAT_RGBA_8888}; + ImageProcessing_ColorSpaceInfo destinationGainmapInfo = {GAINMAP, + DISPLAY_P3, + PIXEL_FORMAT_RGBA_8888}; + ASSERT_TRUE(OH_ImageProcessing_IsDecompositionSupported(&sourceImageInfo, &destinationImageInfo, &destinationGainmapInfo)); +} + +/** + * @tc.number : COLORSPACE_DECOMPOSE_0100 + * @tc.name : pq 10bit nv12 to hlg 8bit rgba + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_DECOMPOSE_0100, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo sourceImageInfo = {ALTERNATE, + BT2020_PQ, + PIXEL_FORMAT_YCBCR_P010}; + ImageProcessing_ColorSpaceInfo destinationImageInfo = {BASE, + DISPLAY_SRGB, + PIXEL_FORMAT_RGBA_8888}; + ImageProcessing_ColorSpaceInfo destinationGainmapInfo = {GAINMAP, + DISPLAY_SRGB, + PIXEL_FORMAT_RGBA_8888}; + ASSERT_TRUE(OH_ImageProcessing_IsDecompositionSupported(&sourceImageInfo, &destinationImageInfo, &destinationGainmapInfo)); +} + +/** + * @tc.number : COLORSPACE_DECOMPOSE_0110 + * @tc.name : pq 10bit nv21 to p3 8bit rgba + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_DECOMPOSE_0110, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo sourceImageInfo = {ALTERNATE, + BT2020_PQ, + PIXEL_FORMAT_YCRCB_P010}; + ImageProcessing_ColorSpaceInfo destinationImageInfo = {BASE, + DISPLAY_P3, + PIXEL_FORMAT_RGBA_8888}; + ImageProcessing_ColorSpaceInfo destinationGainmapInfo = {GAINMAP, + DISPLAY_P3, + PIXEL_FORMAT_RGBA_8888}; + ASSERT_TRUE(OH_ImageProcessing_IsDecompositionSupported(&sourceImageInfo, &destinationImageInfo, &destinationGainmapInfo)); +} + +/** + * @tc.number : COLORSPACE_DECOMPOSE_0120 + * @tc.name : pq 10bit nv21 to hlg 8bit rgba + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_DECOMPOSE_0120, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo sourceImageInfo = {ALTERNATE, + BT2020_PQ, + PIXEL_FORMAT_YCRCB_P010}; + ImageProcessing_ColorSpaceInfo destinationImageInfo = {BASE, + DISPLAY_SRGB, + PIXEL_FORMAT_RGBA_8888}; + ImageProcessing_ColorSpaceInfo destinationGainmapInfo = {GAINMAP, + DISPLAY_SRGB, + PIXEL_FORMAT_RGBA_8888}; + ASSERT_TRUE(OH_ImageProcessing_IsDecompositionSupported(&sourceImageInfo, + &destinationImageInfo, &destinationGainmapInfo)); +} + +/** + * @tc.number : METADATAGENERATE_SUPPORT_001 + * @tc.name : hlg rgba1010102 metadata generate + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, METADATAGENERATE_SUPPORT_001, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + inputFormat.metadataType = ALTERNATE; + inputFormat.colorSpace = BT2020_HLG; + inputFormat.pixelFormat = PIXEL_FORMAT_RGBA_1010102; + if (!access("/system/lib64/media/", 0)) { + // ASSERT_EQ(true, OH_ImageProcessing_IsMetadataGenerationSupported(&inputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsMetadataGenerationSupported(&inputFormat)); + } +} + +/** + * @tc.number : METADATAGENERATE_SUPPORT_002 + * @tc.name : hlg p010 metadata generate + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, METADATAGENERATE_SUPPORT_002, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + inputFormat.metadataType = ALTERNATE; + inputFormat.colorSpace = BT2020_HLG; + inputFormat.pixelFormat = PIXEL_FORMAT_YCBCR_P010; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsMetadataGenerationSupported(&inputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsMetadataGenerationSupported(&inputFormat)); + } +} + +/** + * @tc.number : METADATAGENERATE_SUPPORT_003 + * @tc.name : hlg p010_NV21 metadata generate + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, METADATAGENERATE_SUPPORT_003, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + inputFormat.metadataType = ALTERNATE; + inputFormat.colorSpace = BT2020_HLG; + inputFormat.pixelFormat = PIXEL_FORMAT_YCRCB_P010; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsMetadataGenerationSupported(&inputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsMetadataGenerationSupported(&inputFormat)); + } +} + +/** + * @tc.number : METADATAGENERATE_SUPPORT_004 + * @tc.name : pq rgba1010102 metadata generate + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, METADATAGENERATE_SUPPORT_004, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + inputFormat.metadataType = ALTERNATE; + inputFormat.colorSpace = BT2020_PQ; + inputFormat.pixelFormat = PIXEL_FORMAT_RGBA_1010102; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsMetadataGenerationSupported(&inputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsMetadataGenerationSupported(&inputFormat)); + } +} + +/** + * @tc.number : METADATAGENERATE_SUPPORT_005 + * @tc.name : pq p010 metadata generate + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, METADATAGENERATE_SUPPORT_005, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + inputFormat.metadataType = ALTERNATE; + inputFormat.colorSpace = BT2020_PQ; + inputFormat.pixelFormat = PIXEL_FORMAT_YCBCR_P010; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsMetadataGenerationSupported(&inputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsMetadataGenerationSupported(&inputFormat)); + } +} + +/** + * @tc.number : METADATAGENERATE_SUPPORT_006 + * @tc.name : pq p010_NV21 metadata generate + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, METADATAGENERATE_SUPPORT_006, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + inputFormat.metadataType = ALTERNATE; + inputFormat.colorSpace = BT2020_PQ; + inputFormat.pixelFormat = PIXEL_FORMAT_YCRCB_P010; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsMetadataGenerationSupported(&inputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsMetadataGenerationSupported(&inputFormat)); + } +} + +/** + * @tc.number : Composition_SUPPORT_001 + * @tc.name : srgb + srgb gainmap to PQ P010 + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, Composition_SUPPORT_001, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + ImageProcessing_ColorSpaceInfo inputGainmapFormat; + ImageProcessing_ColorSpaceInfo outputFormat; + + inputFormat.metadataType = BASE; + inputFormat.colorSpace = SRGB; + inputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + + inputGainmapFormat.metadataType = GAINMAP; + inputGainmapFormat.colorSpace = SRGB; + inputGainmapFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + + outputFormat.metadataType = ALTERNATE; + outputFormat.colorSpace = BT2020_PQ; + outputFormat.pixelFormat = PIXEL_FORMAT_YCBCR_P010; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsCompositionSupported(&inputFormat, &inputGainmapFormat, &outputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsCompositionSupported(&inputFormat, &inputGainmapFormat, &outputFormat)); + } +} + +/** + * @tc.number : Composition_SUPPORT_002 + * @tc.name : p3 + p3 gainmap to PQ P010 + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, Composition_SUPPORT_002, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + ImageProcessing_ColorSpaceInfo inputGainmapFormat; + ImageProcessing_ColorSpaceInfo outputFormat; + + inputFormat.metadataType = BASE; + inputFormat.colorSpace = DISPLAY_P3; + inputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + + inputGainmapFormat.metadataType = GAINMAP; + inputGainmapFormat.colorSpace = DISPLAY_P3; + inputGainmapFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + + outputFormat.metadataType = ALTERNATE; + outputFormat.colorSpace = BT2020_PQ; + outputFormat.pixelFormat = PIXEL_FORMAT_YCBCR_P010; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsCompositionSupported(&inputFormat, &inputGainmapFormat, &outputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsCompositionSupported(&inputFormat, &inputGainmapFormat, &outputFormat)); + } +} + +/** + * @tc.number : Composition_SUPPORT_005 + * @tc.name : srgb + srgb gainmap to PQ rgba1010102 + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, Composition_SUPPORT_005, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + ImageProcessing_ColorSpaceInfo inputGainmapFormat; + ImageProcessing_ColorSpaceInfo outputFormat; + + inputFormat.metadataType = BASE; + inputFormat.colorSpace = SRGB; + inputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + + inputGainmapFormat.metadataType = GAINMAP; + inputGainmapFormat.colorSpace = SRGB; + inputGainmapFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + + outputFormat.metadataType = ALTERNATE; + outputFormat.colorSpace = BT2020_PQ; + outputFormat.pixelFormat = PIXEL_FORMAT_RGBA_1010102; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsCompositionSupported(&inputFormat, &inputGainmapFormat, &outputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsCompositionSupported(&inputFormat, &inputGainmapFormat, &outputFormat)); + } +} + +/** + * @tc.number : Composition_SUPPORT_006 + * @tc.name : p3 + p3 gainmap to PQ rgba1010102 + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, Composition_SUPPORT_006, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + ImageProcessing_ColorSpaceInfo inputGainmapFormat; + ImageProcessing_ColorSpaceInfo outputFormat; + + inputFormat.metadataType = BASE; + inputFormat.colorSpace = DISPLAY_P3; + inputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + + inputGainmapFormat.metadataType = GAINMAP; + inputGainmapFormat.colorSpace = DISPLAY_P3; + inputGainmapFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + + outputFormat.metadataType = ALTERNATE; + outputFormat.colorSpace = BT2020_PQ; + outputFormat.pixelFormat = PIXEL_FORMAT_RGBA_1010102; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsCompositionSupported(&inputFormat, &inputGainmapFormat, &outputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsCompositionSupported(&inputFormat, &inputGainmapFormat, &outputFormat)); + } +} + +/** + * @tc.number : Composition_SUPPORT_007 + * @tc.name : srgb + srgb gainmap to HLG P010 + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, Composition_SUPPORT_007, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + ImageProcessing_ColorSpaceInfo inputGainmapFormat; + ImageProcessing_ColorSpaceInfo outputFormat; + + inputFormat.metadataType = BASE; + inputFormat.colorSpace = SRGB; + inputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + + inputGainmapFormat.metadataType = GAINMAP; + inputGainmapFormat.colorSpace = SRGB; + inputGainmapFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + + outputFormat.metadataType = ALTERNATE; + outputFormat.colorSpace = BT2020_HLG; + outputFormat.pixelFormat = PIXEL_FORMAT_YCBCR_P010; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsCompositionSupported(&inputFormat, &inputGainmapFormat, &outputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsCompositionSupported(&inputFormat, &inputGainmapFormat, &outputFormat)); + } +} + +/** + * @tc.number : Composition_SUPPORT_008 + * @tc.name : p3 + p3 gainmap to HLG P010 + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, Composition_SUPPORT_008, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + ImageProcessing_ColorSpaceInfo inputGainmapFormat; + ImageProcessing_ColorSpaceInfo outputFormat; + + inputFormat.metadataType = BASE; + inputFormat.colorSpace = DISPLAY_P3; + inputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + + inputGainmapFormat.metadataType = GAINMAP; + inputGainmapFormat.colorSpace = DISPLAY_P3; + inputGainmapFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + + outputFormat.metadataType = ALTERNATE; + outputFormat.colorSpace = BT2020_HLG; + outputFormat.pixelFormat = PIXEL_FORMAT_YCBCR_P010; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsCompositionSupported(&inputFormat, &inputGainmapFormat, &outputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsCompositionSupported(&inputFormat, &inputGainmapFormat, &outputFormat)); + } +} + +/** + * @tc.number : Composition_SUPPORT_011 + * @tc.name : srgb + srgb gainmap to HLG rgba1010102 + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, Composition_SUPPORT_011, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + ImageProcessing_ColorSpaceInfo inputGainmapFormat; + ImageProcessing_ColorSpaceInfo outputFormat; + + inputFormat.metadataType = BASE; + inputFormat.colorSpace = SRGB; + inputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + + inputGainmapFormat.metadataType = GAINMAP; + inputGainmapFormat.colorSpace = SRGB; + inputGainmapFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + + outputFormat.metadataType = ALTERNATE; + outputFormat.colorSpace = BT2020_HLG; + outputFormat.pixelFormat = PIXEL_FORMAT_RGBA_1010102; + + ASSERT_EQ(true, OH_ImageProcessing_IsCompositionSupported(&inputFormat, &inputGainmapFormat, &outputFormat)); +} + +/** + * @tc.number : Composition_SUPPORT_012 + * @tc.name : p3 + p3 gainmap to HLG rgba1010102 + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, Composition_SUPPORT_012, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + ImageProcessing_ColorSpaceInfo inputGainmapFormat; + ImageProcessing_ColorSpaceInfo outputFormat; + + inputFormat.metadataType = BASE; + inputFormat.colorSpace = DISPLAY_P3; + inputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + + inputGainmapFormat.metadataType = GAINMAP; + inputGainmapFormat.colorSpace = DISPLAY_P3; + inputGainmapFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + + outputFormat.metadataType = ALTERNATE; + outputFormat.colorSpace = BT2020_HLG; + outputFormat.pixelFormat = PIXEL_FORMAT_RGBA_1010102; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsCompositionSupported(&inputFormat, &inputGainmapFormat, &outputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsCompositionSupported(&inputFormat, &inputGainmapFormat, &outputFormat)); + } +} + +/** + * @tc.number : COLORSPACE_SUPPORT_013 + * @tc.name : srgb to display p3 + * @tc.desc : api test + */ +HWTEST_F(VpeVideoCapTest, COLORSPACE_SUPPORT_013, TestSize.Level2) +{ + ImageProcessing_ColorSpaceInfo inputFormat; + ImageProcessing_ColorSpaceInfo outputFormat; + inputFormat.metadataType = NONE; + inputFormat.colorSpace = SRGB; + inputFormat.pixelFormat = PIXEL_FORMAT_NV21; + outputFormat.metadataType = NONE; + outputFormat.colorSpace = DISPLAY_P3; + outputFormat.pixelFormat = PIXEL_FORMAT_RGBA_8888; + if (!access("/system/lib64/media/", 0)) { + ASSERT_EQ(true, OH_ImageProcessing_IsColorSpaceConversionSupported(&inputFormat, &outputFormat)); + } else { + ASSERT_EQ(false, OH_ImageProcessing_IsColorSpaceConversionSupported(&inputFormat, &outputFormat)); + } +} + +} // namespace \ No newline at end of file diff --git a/test/ndk/moduletest/image/enum_list.h b/test/ndk/moduletest/image/enum_list.h new file mode 100644 index 0000000..971c31d --- /dev/null +++ b/test/ndk/moduletest/image/enum_list.h @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef VPE_IMAGE_TEST_ENUM_H +#define VPE_IMAGE_TEST_ENUM_H +enum COLORSPACE { + UNKNOWN = 0, + ADOBE_RGB_1998 = 1, + DCI_P3 = 2, + DISPLAY_P3 = 3, + SRGB = 4, + BT709 = 6, + BT601_EBU = 7, + BT601_SMPTE_C = 8, + BT2020_HLG = 9, + BT2020_PQ = 10, + P3_HLG = 11, + P3_PQ = 12, + ADOBE_RGB_1998_LIMIT = 13, + DISPLAY_P3_LIMIT = 14, + SRGB_LIMIT = 15, + BT709_LIMIT = 16, + BT601_EBU_LIMIT = 17, + BT601_SMPTE_C_LIMIT = 18, + BT2020_HLG_LIMIT = 19, + BT2020_PQ_LIMIT = 20, + P3_HLG_LIMIT = 21, + P3_PQ_LIMIT = 22, + LINEAR_P3 = 23, + LINEAR_SRGB = 24, + LINEAR_BT709 = LINEAR_SRGB, + LINEAR_BT2020 = 25, + DISPLAY_SRGB = SRGB, + DISPLAY_P3_SRGB = DISPLAY_P3, + DISPLAY_P3_HLG = P3_HLG, + DISPLAY_P3_PQ = P3_PQ, + CUSTOM = 5 +}; + +enum HdrMetadataType { + NONE = 0, + BASE = 1, + GAINMAP = 2, + ALTERNATE = 3 +}; +#endif \ No newline at end of file diff --git a/test/ndk/moduletest/video/video_sample.h b/test/ndk/moduletest/video/video_sample.h index 599f919..9a42b32 100644 --- a/test/ndk/moduletest/video/video_sample.h +++ b/test/ndk/moduletest/video/video_sample.h @@ -24,7 +24,8 @@ #include "surface/window.h" #include "native_buffer.h" -int CheckAndRet(bool cond, int ret, char* msg) { +int CheckAndRet(bool cond, int ret, char* msg) +{ if (!cond) { std::cout << msg <<" ErrCode:"<< ret << std::endl; return ret;