1 /* 2 * Copyright (C) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <vector> 17 #include "gtest/gtest.h" 18 19 #include "image_effect_errors.h" 20 #include "image_effect.h" 21 #include "image_effect_filter.h" 22 #include "image_type.h" 23 #include "efilter_factory.h" 24 #include "brightness_efilter.h" 25 #include "contrast_efilter.h" 26 #include "test_common.h" 27 #include "external_loader.h" 28 #include "native_effect_base.h" 29 #include "native_window.h" 30 #include "mock_pixel_map.h" 31 #include "pixelmap_native_impl.h" 32 #include "test_native_buffer_utils.h" 33 #include "test_pixel_map_utils.h" 34 #include "crop_efilter.h" 35 #include "mock_producer_surface.h" 36 #include "surface_utils.h" 37 #include "mock_picture.h" 38 #include "picture_native_impl.h" 39 40 using namespace testing::ext; 41 using namespace OHOS::Media; 42 using namespace OHOS::Media::Effect::Test; 43 using ::testing::InSequence; 44 using ::testing::Mock; 45 46 static std::string g_jpgPath; 47 static std::string g_notJpgPath; 48 static std::string g_jpgUri; 49 static std::string g_notJpgUri; 50 static std::string g_jpgHdrPath; 51 static OHNativeWindow *g_nativeWindow = nullptr; 52 53 namespace { 54 constexpr uint32_t CROP_FACTOR = 2; 55 } 56 57 namespace OHOS { 58 namespace Media { 59 namespace Effect { 60 class CustomTestEFilter : public EFilter { 61 public: CustomTestEFilter(const std::string & name)62 explicit CustomTestEFilter(const std::string &name) : EFilter(name) {} ~CustomTestEFilter()63 ~CustomTestEFilter() {} 64 Render(EffectBuffer * buffer,std::shared_ptr<EffectContext> & context)65 ErrorCode Render(EffectBuffer *buffer, std::shared_ptr<EffectContext> &context) override 66 { 67 return PushData(buffer, context); 68 } 69 Render(EffectBuffer * src,EffectBuffer * dst,std::shared_ptr<EffectContext> & context)70 ErrorCode Render(EffectBuffer *src, EffectBuffer *dst, std::shared_ptr<EffectContext> &context) override 71 { 72 return ErrorCode::SUCCESS; 73 } 74 Restore(const EffectJsonPtr & values)75 ErrorCode Restore(const EffectJsonPtr &values) override 76 { 77 return ErrorCode::SUCCESS; 78 } 79 GetEffectInfo(const std::string & name)80 static std::shared_ptr<EffectInfo> GetEffectInfo(const std::string &name) 81 { 82 std::shared_ptr<EffectInfo> effectInfo = std::make_shared<EffectInfo>(); 83 effectInfo->formats_.emplace(IEffectFormat::RGBA8888, std::vector<IPType>{ IPType::GPU }); 84 return effectInfo; 85 } 86 Save(EffectJsonPtr & res)87 ErrorCode Save(EffectJsonPtr &res) override 88 { 89 res->Put("name", name_); 90 EffectJsonPtr jsonValues = JsonHelper::CreateObject(); 91 Plugin::Any any; 92 auto it = values_.find(Test::KEY_FILTER_INTENSITY); 93 if (it == values_.end()) { 94 return ErrorCode::ERR_UNKNOWN; 95 } 96 97 auto value = Plugin::AnyCast<void *>(&it->second); 98 if (value == nullptr) { 99 return ErrorCode::ERR_UNKNOWN; 100 } 101 102 std::string jsonValue = *reinterpret_cast<char **>(value); 103 jsonValues->Put(it->first, jsonValue); 104 res->Put("values", jsonValues); 105 return ErrorCode::SUCCESS; 106 } 107 }; 108 109 class CustomTestEFilter2 : public CustomTestEFilter { 110 public: CustomTestEFilter2(const std::string & name)111 explicit CustomTestEFilter2(const std::string &name) : CustomTestEFilter(name) {} ~CustomTestEFilter2()112 ~CustomTestEFilter2() {} GetEffectInfo(const std::string & name)113 static std::shared_ptr<EffectInfo> GetEffectInfo(const std::string &name) 114 { 115 std::shared_ptr<EffectInfo> effectInfo = std::make_shared<EffectInfo>(); 116 effectInfo->formats_.emplace(IEffectFormat::RGBA8888, std::vector<IPType>{ IPType::CPU }); 117 return effectInfo; 118 } 119 }; 120 121 namespace Test { 122 class NativeImageEffectUnittest : public testing::Test { 123 public: 124 NativeImageEffectUnittest() = default; 125 126 ~NativeImageEffectUnittest() override = default; 127 SetUpTestCase()128 static void SetUpTestCase() 129 { 130 g_jpgPath = std::string("/data/test/resource/image_effect_1k_test1.jpg"); 131 g_notJpgPath = std::string("/data/test/resource/image_effect_1k_test1.png"); 132 g_jpgUri = std::string("file:///data/test/resource/image_effect_1k_test1.jpg"); 133 g_notJpgUri = std::string("file:///data/test/resource/image_effect_1k_test1.png"); 134 g_jpgHdrPath = std::string("/data/test/resource/image_effect_hdr_test1.jpg"); 135 consumerSurface_ = Surface::CreateSurfaceAsConsumer("UnitTest"); 136 sptr<IBufferProducer> producer = consumerSurface_->GetProducer(); 137 sptr<ProducerSurface> surf = new(std::nothrow) MockProducerSurface(producer); 138 surf->Init(); 139 auto utils = SurfaceUtils::GetInstance(); 140 utils->Add(surf->GetUniqueId(), surf); 141 ohSurface_ = surf; 142 g_nativeWindow = CreateNativeWindowFromSurface(&ohSurface_); 143 144 nativeBufferRgba_ = TestNativeBufferUtils::CreateNativeBuffer(GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888); 145 nativeBufferNV12_ = 146 TestNativeBufferUtils::CreateNativeBuffer(GraphicPixelFormat::GRAPHIC_PIXEL_FMT_YCBCR_420_SP); 147 nativeBufferNV21_ = 148 TestNativeBufferUtils::CreateNativeBuffer(GraphicPixelFormat::GRAPHIC_PIXEL_FMT_YCRCB_420_SP); 149 } 150 TearDownTestCase()151 static void TearDownTestCase() 152 { 153 if (g_nativeWindow != nullptr) { 154 DestoryNativeWindow(g_nativeWindow); 155 g_nativeWindow = nullptr; 156 } 157 consumerSurface_ = nullptr; 158 ohSurface_ = nullptr; 159 nativeBufferRgba_ = nullptr; 160 nativeBufferNV12_ = nullptr; 161 nativeBufferNV21_ = nullptr; 162 } 163 SetUp()164 void SetUp() override 165 { 166 mockPixelMap_ = std::make_shared<MockPixelMap>(); 167 pixelmapNative_ = new OH_PixelmapNative(mockPixelMap_); 168 ExternLoader::Instance()->InitExt(); 169 EFilterFactory::Instance()->functions_.clear(); 170 EFilterFactory::Instance()->RegisterEFilter<BrightnessEFilter>(BRIGHTNESS_EFILTER); 171 EFilterFactory::Instance()->RegisterEFilter<ContrastEFilter>(CONTRAST_EFILTER); 172 EFilterFactory::Instance()->RegisterEFilter<CustomTestEFilter>(CUSTOM_TEST_EFILTER); 173 EFilterFactory::Instance()->RegisterEFilter<CustomTestEFilter2>(CUSTOM_TEST_EFILTER2); 174 EFilterFactory::Instance()->RegisterEFilter<CropEFilter>(CROP_EFILTER); 175 EFilterFactory::Instance()->delegates_.clear(); 176 filterInfo_ = OH_EffectFilterInfo_Create(); 177 OH_EffectFilterInfo_SetFilterName(filterInfo_, BRIGHTNESS_EFILTER); 178 ImageEffect_BufferType bufferTypes[] = { ImageEffect_BufferType::EFFECT_BUFFER_TYPE_PIXEL }; 179 OH_EffectFilterInfo_SetSupportedBufferTypes(filterInfo_, sizeof(bufferTypes) / sizeof(ImageEffect_BufferType), 180 bufferTypes); 181 ImageEffect_Format formats[] = { ImageEffect_Format::EFFECT_PIXEL_FORMAT_RGBA8888, 182 ImageEffect_Format::EFFECT_PIXEL_FORMAT_NV12, ImageEffect_Format::EFFECT_PIXEL_FORMAT_NV21}; 183 OH_EffectFilterInfo_SetSupportedFormats(filterInfo_, sizeof(formats) / sizeof(ImageEffect_Format), formats); 184 } 185 TearDown()186 void TearDown() override 187 { 188 delete pixelmapNative_; 189 mockPixelMap_ = nullptr; 190 191 pixelmapNative_ = nullptr; 192 if (filterInfo_ != nullptr) { 193 OH_EffectFilterInfo_Release(filterInfo_); 194 filterInfo_ = nullptr; 195 } 196 } 197 198 std::shared_ptr<PixelMap> mockPixelMap_; 199 OH_PixelmapNative *pixelmapNative_ = nullptr; 200 201 ImageEffect_FilterDelegate delegate_ = { __anon6e3194820202(OH_EffectFilter *filter, const char *key, const ImageEffect_Any *value) 202 .setValue = [](OH_EffectFilter *filter, const char *key, const ImageEffect_Any *value) { return true; }, __anon6e3194820302(OH_EffectFilter *filter, OH_EffectBufferInfo *src, OH_EffectFilterDelegate_PushData pushData) 203 .render = [](OH_EffectFilter *filter, OH_EffectBufferInfo *src, OH_EffectFilterDelegate_PushData pushData) { 204 void *addr = nullptr; 205 (void)OH_EffectBufferInfo_GetAddr(src, &addr); 206 int32_t width = 0; 207 (void)OH_EffectBufferInfo_GetWidth(src, &width); 208 int32_t height = 0; 209 (void)OH_EffectBufferInfo_GetHeight(src, &height); 210 int32_t rowSize = 0; 211 (void)OH_EffectBufferInfo_GetRowSize(src, &rowSize); 212 ImageEffect_Format format = ImageEffect_Format::EFFECT_PIXEL_FORMAT_UNKNOWN; 213 (void)OH_EffectBufferInfo_GetEffectFormat(src, &format); 214 int64_t timestamp = 0; 215 (void)OH_EffectBufferInfo_GetTimestamp(src, ×tamp); 216 217 (void)OH_EffectBufferInfo_SetAddr(src, addr); 218 (void)OH_EffectBufferInfo_SetWidth(src, width); 219 (void)OH_EffectBufferInfo_SetHeight(src, height); 220 (void)OH_EffectBufferInfo_SetRowSize(src, rowSize); 221 (void)OH_EffectBufferInfo_SetEffectFormat(src, format); 222 (void)OH_EffectBufferInfo_SetTimestamp(src, timestamp); 223 224 pushData(filter, src); 225 return true; 226 }, __anon6e3194820402(OH_EffectFilter *filter, char **info) 227 .save = [](OH_EffectFilter *filter, char **info) { 228 EffectJsonPtr root = JsonHelper::CreateObject(); 229 root->Put("name", std::string(CUSTOM_BRIGHTNESS_EFILTER)); 230 std::string infoStr = root->ToString(); 231 char *infoChar = static_cast<char *>(malloc(infoStr.length() + 1)); 232 infoChar[infoStr.length()] = '\0'; 233 auto res = strcpy_s(infoChar, infoStr.length() + 1, infoStr.c_str()); 234 if (res != 0) { 235 return false; 236 } 237 *info = infoChar; 238 return true; 239 }, __anon6e3194820502(const char *info) 240 .restore = [](const char *info) { 241 OH_EffectFilter *filter = OH_EffectFilter_Create(CUSTOM_BRIGHTNESS_EFILTER); 242 ImageEffect_Any value; 243 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 244 value.dataValue.floatValue = 50.f; 245 OH_EffectFilter_SetValue(filter, BRIGHTNESS_EFILTER, &value); 246 return filter; 247 } 248 }; 249 250 OH_EffectFilterInfo *filterInfo_ = nullptr; 251 static inline sptr<Surface> consumerSurface_; 252 static inline sptr<Surface> ohSurface_; 253 static inline std::shared_ptr<OH_NativeBuffer> nativeBufferRgba_; 254 static inline std::shared_ptr<OH_NativeBuffer> nativeBufferNV12_; 255 static inline std::shared_ptr<OH_NativeBuffer> nativeBufferNV21_; 256 }; 257 258 /** 259 * Feature: ImageEffect 260 * Function: Test OH_ImageEffect_SetInputUri with normal parameter 261 * SubFunction: NA 262 * FunctionPoints: NA 263 * EnvConditions: NA 264 * CaseDescription: Test OH_ImageEffect_SetInputUri with normal parameter 265 */ 266 HWTEST_F(NativeImageEffectUnittest, OHImageEffectSetInputUri001, TestSize.Level1) 267 { 268 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 269 ASSERT_NE(imageEffect, nullptr); 270 271 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 272 ASSERT_NE(filter, nullptr); 273 274 ImageEffect_Any value; 275 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 276 value.dataValue.floatValue = 100.f; 277 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 278 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 279 280 errorCode = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str()); 281 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 282 283 errorCode = OH_ImageEffect_Start(imageEffect); 284 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 285 286 errorCode = OH_ImageEffect_Release(imageEffect); 287 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 288 } 289 290 /** 291 * Feature: ImageEffect 292 * Function: Test OH_ImageEffect_SetInputUri with all empty parameter 293 * SubFunction: NA 294 * FunctionPoints: NA 295 * EnvConditions: NA 296 * CaseDescription: Test OH_ImageEffect_SetInputUri with all empty parameter 297 */ 298 HWTEST_F(NativeImageEffectUnittest, OHImageEffectSetInputUri002, TestSize.Level1) 299 { 300 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 301 ASSERT_NE(imageEffect, nullptr); 302 303 ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetInputUri(nullptr, nullptr); 304 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 305 306 errorCode = OH_ImageEffect_Start(imageEffect); 307 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 308 309 errorCode = OH_ImageEffect_Release(imageEffect); 310 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 311 } 312 313 /** 314 * Feature: ImageEffect 315 * Function: Test OH_ImageEffect_SetInputUri with empty OH_ImageEffect 316 * SubFunction: NA 317 * FunctionPoints: NA 318 * EnvConditions: NA 319 * CaseDescription: Test OH_ImageEffect_SetInputUri with empty OH_ImageEffect 320 */ 321 HWTEST_F(NativeImageEffectUnittest, OHImageEffectSetInputUri003, TestSize.Level1) 322 { 323 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 324 ASSERT_NE(imageEffect, nullptr); 325 326 ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetInputUri(nullptr, g_jpgUri.c_str()); 327 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 328 329 errorCode = OH_ImageEffect_Start(imageEffect); 330 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 331 332 errorCode = OH_ImageEffect_Release(imageEffect); 333 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 334 } 335 336 /** 337 * Feature: ImageEffect 338 * Function: Test OH_ImageEffect_SetInputUri with empty path 339 * SubFunction: NA 340 * FunctionPoints: NA 341 * EnvConditions: NA 342 * CaseDescription: Test OH_ImageEffect_SetInputUri with empty path 343 */ 344 HWTEST_F(NativeImageEffectUnittest, OHImageEffectSetInputUri004, TestSize.Level1) 345 { 346 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 347 ASSERT_NE(imageEffect, nullptr); 348 349 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 350 ASSERT_NE(filter, nullptr); 351 352 ImageEffect_Any value; 353 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 354 value.dataValue.floatValue = 100.f; 355 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 356 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 357 358 errorCode = OH_ImageEffect_SetInputUri(imageEffect, nullptr); 359 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 360 361 errorCode = OH_ImageEffect_Start(imageEffect); 362 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 363 364 errorCode = OH_ImageEffect_Release(imageEffect); 365 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 366 } 367 368 /** 369 * Feature: ImageEffect 370 * Function: Test OH_ImageEffect_SetInputUri with unsupport path 371 * SubFunction: NA 372 * FunctionPoints: NA 373 * EnvConditions: NA 374 * CaseDescription: Test OH_ImageEffect_SetInputUri with unsupport path 375 */ 376 HWTEST_F(NativeImageEffectUnittest, OHImageEffectSetInputUri005, TestSize.Level1) 377 { 378 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 379 ASSERT_NE(imageEffect, nullptr); 380 381 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 382 ASSERT_NE(filter, nullptr); 383 384 ImageEffect_Any value; 385 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 386 value.dataValue.floatValue = 100.f; 387 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 388 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 389 390 errorCode = OH_ImageEffect_SetInputUri(imageEffect, g_notJpgUri.c_str()); 391 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 392 393 errorCode = OH_ImageEffect_Start(imageEffect); 394 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 395 396 errorCode = OH_ImageEffect_Release(imageEffect); 397 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 398 } 399 400 /** 401 * Feature: ImageEffect 402 * Function: Test OH_ImageEffect_SetOutputUri with normal parameter 403 * SubFunction: NA 404 * FunctionPoints: NA 405 * EnvConditions: NA 406 * CaseDescription: Test OH_ImageEffect_SetOutputUri with normal parameter 407 */ 408 HWTEST_F(NativeImageEffectUnittest, OHImageEffectSetOutputUri001, TestSize.Level1) 409 { 410 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 411 ASSERT_NE(imageEffect, nullptr); 412 413 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 414 ASSERT_NE(filter, nullptr); 415 416 ImageEffect_Any value; 417 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 418 value.dataValue.floatValue = 100.f; 419 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 420 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 421 422 errorCode = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str()); 423 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 424 425 errorCode = OH_ImageEffect_SetOutputUri(imageEffect, g_jpgUri.c_str()); 426 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 427 428 errorCode = OH_ImageEffect_Start(imageEffect); 429 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 430 431 errorCode = OH_ImageEffect_Release(imageEffect); 432 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 433 } 434 435 /** 436 * Feature: ImageEffect 437 * Function: Test OH_ImageEffect_SetOutputUri with all empty parameter 438 * SubFunction: NA 439 * FunctionPoints: NA 440 * EnvConditions: NA 441 * CaseDescription: Test OH_ImageEffect_SetOutputUri with all empty parameter 442 */ 443 HWTEST_F(NativeImageEffectUnittest, OHImageEffectSetOutputUri002, TestSize.Level1) 444 { 445 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 446 ASSERT_NE(imageEffect, nullptr); 447 448 ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str()); 449 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 450 451 errorCode = OH_ImageEffect_SetOutputUri(nullptr, nullptr); 452 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 453 454 errorCode = OH_ImageEffect_Start(imageEffect); 455 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 456 457 errorCode = OH_ImageEffect_Release(imageEffect); 458 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 459 } 460 461 /** 462 * Feature: ImageEffect 463 * Function: Test OH_ImageEffect_SetOutputUri with empty OH_ImageEffect 464 * SubFunction: NA 465 * FunctionPoints: NA 466 * EnvConditions: NA 467 * CaseDescription: Test OH_ImageEffect_SetOutputUri with empty OH_ImageEffect 468 */ 469 HWTEST_F(NativeImageEffectUnittest, OHImageEffectSetOutputUri003, TestSize.Level1) 470 { 471 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 472 ASSERT_NE(imageEffect, nullptr); 473 474 ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str()); 475 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 476 477 errorCode = OH_ImageEffect_SetOutputUri(nullptr, g_jpgUri.c_str()); 478 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 479 480 errorCode = OH_ImageEffect_Start(imageEffect); 481 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 482 483 errorCode = OH_ImageEffect_Release(imageEffect); 484 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 485 } 486 487 /** 488 * Feature: ImageEffect 489 * Function: Test OH_ImageEffect_SetOutputUri with empty path 490 * SubFunction: NA 491 * FunctionPoints: NA 492 * EnvConditions: NA 493 * CaseDescription: Test OH_ImageEffect_SetOutputUri with empty path 494 */ 495 HWTEST_F(NativeImageEffectUnittest, OHImageEffectSetOutputUri004, TestSize.Level1) 496 { 497 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 498 ASSERT_NE(imageEffect, nullptr); 499 500 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 501 ASSERT_NE(filter, nullptr); 502 503 ImageEffect_Any value; 504 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 505 value.dataValue.floatValue = 100.f; 506 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 507 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 508 509 errorCode = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str()); 510 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 511 512 errorCode = OH_ImageEffect_SetOutputUri(imageEffect, nullptr); 513 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 514 515 errorCode = OH_ImageEffect_Start(imageEffect); 516 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 517 518 errorCode = OH_ImageEffect_Release(imageEffect); 519 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 520 } 521 522 /** 523 * Feature: ImageEffect 524 * Function: Test OH_ImageEffect_SetOutputUri with unsupport path 525 * SubFunction: NA 526 * FunctionPoints: NA 527 * EnvConditions: NA 528 * CaseDescription: Test OH_ImageEffect_SetOutputUri with unsupport path 529 */ 530 HWTEST_F(NativeImageEffectUnittest, OHImageEffectSetOutputUri005, TestSize.Level1) 531 { 532 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 533 ASSERT_NE(imageEffect, nullptr); 534 535 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 536 ASSERT_NE(filter, nullptr); 537 538 ImageEffect_Any value; 539 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 540 value.dataValue.floatValue = 100.f; 541 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 542 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 543 544 errorCode = OH_ImageEffect_SetInputUri(imageEffect, g_jpgUri.c_str()); 545 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 546 547 errorCode = OH_ImageEffect_SetOutputUri(imageEffect, g_notJpgUri.c_str()); 548 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 549 550 errorCode = OH_ImageEffect_Start(imageEffect); 551 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 552 553 errorCode = OH_ImageEffect_Release(imageEffect); 554 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 555 } 556 557 /** 558 * Feature: ImageEffect 559 * Function: Test OH_ImageEffect_SetOutputUri with no OH_ImageEffect_SetInputUri 560 * SubFunction: NA 561 * FunctionPoints: NA 562 * EnvConditions: NA 563 * CaseDescription: Test OH_ImageEffect_SetOutputUri with no OH_ImageEffect_SetInputUri 564 */ 565 HWTEST_F(NativeImageEffectUnittest, OHImageEffectSetOutputUri006, TestSize.Level1) 566 { 567 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 568 ASSERT_NE(imageEffect, nullptr); 569 570 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 571 ASSERT_NE(filter, nullptr); 572 573 ImageEffect_Any value; 574 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 575 value.dataValue.floatValue = 100.f; 576 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 577 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 578 579 errorCode = OH_ImageEffect_SetOutputUri(imageEffect, g_jpgUri.c_str()); 580 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 581 582 errorCode = OH_ImageEffect_Start(imageEffect); 583 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); // not set input data 584 585 errorCode = OH_ImageEffect_Release(imageEffect); 586 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 587 } 588 589 /** 590 * Feature: ImageEffect 591 * Function: Test OH_ImageEffect_SetInputNativeBuffer with normal parameter 592 * SubFunction: NA 593 * FunctionPoints: NA 594 * EnvConditions: NA 595 * CaseDescription: Test OH_ImageEffect_SetInputNativeBuffer with normal parameter 596 */ 597 HWTEST_F(NativeImageEffectUnittest, OHImageEffectSetInputNativeBufferUnittest001, TestSize.Level1) 598 { 599 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 600 ASSERT_NE(imageEffect, nullptr); 601 602 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 603 ASSERT_NE(filter, nullptr); 604 605 ImageEffect_Any value; 606 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 607 value.dataValue.floatValue = 100.f; 608 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 609 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 610 611 errorCode = OH_ImageEffect_SetInputNativeBuffer(imageEffect, nativeBufferRgba_.get()); 612 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 613 614 errorCode = OH_ImageEffect_Start(imageEffect); 615 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 616 617 errorCode = OH_ImageEffect_Release(imageEffect); 618 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 619 } 620 621 /** 622 * Feature: ImageEffect 623 * Function: Test OH_ImageEffect_SetInputNativeBuffer with all empty parameter 624 * SubFunction: NA 625 * FunctionPoints: NA 626 * EnvConditions: NA 627 * CaseDescription: Test OH_ImageEffect_SetInputNativeBuffer with all empty parameter 628 */ 629 HWTEST_F(NativeImageEffectUnittest, OHImageEffectSetInputNativeBufferUnittest002, TestSize.Level1) 630 { 631 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 632 ASSERT_NE(imageEffect, nullptr); 633 634 ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetInputNativeBuffer(nullptr, nullptr); 635 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 636 637 errorCode = OH_ImageEffect_Start(imageEffect); 638 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 639 640 errorCode = OH_ImageEffect_Release(imageEffect); 641 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 642 } 643 644 /** 645 * Feature: ImageEffect 646 * Function: Test OH_ImageEffect_SetInputNativeBuffer with empty OH_ImageEffect 647 * SubFunction: NA 648 * FunctionPoints: NA 649 * EnvConditions: NA 650 * CaseDescription: Test OH_ImageEffect_SetInputNativeBuffer with empty OH_ImageEffect 651 */ 652 HWTEST_F(NativeImageEffectUnittest, OHImageEffectSetInputNativeBufferUnittest003, TestSize.Level1) 653 { 654 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 655 ASSERT_NE(imageEffect, nullptr); 656 657 OH_NativeBuffer *nativeBuffer = nativeBufferRgba_.get(); 658 ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetInputNativeBuffer(nullptr, nativeBuffer); 659 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 660 661 errorCode = OH_ImageEffect_Start(imageEffect); 662 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 663 664 errorCode = OH_ImageEffect_Release(imageEffect); 665 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 666 } 667 668 /** 669 * Feature: ImageEffect 670 * Function: Test OH_ImageEffect_SetInputNativeBuffer with empty OH_NativeBuffer 671 * SubFunction: NA 672 * FunctionPoints: NA 673 * EnvConditions: NA 674 * CaseDescription: Test OH_ImageEffect_SetInputNativeBuffer with empty OH_NativeBuffer 675 */ 676 HWTEST_F(NativeImageEffectUnittest, OHImageEffectSetInputNativeBufferUnittest004, TestSize.Level1) 677 { 678 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 679 ASSERT_NE(imageEffect, nullptr); 680 681 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 682 ASSERT_NE(filter, nullptr); 683 684 ImageEffect_Any value; 685 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 686 value.dataValue.floatValue = 100.f; 687 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 688 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 689 690 errorCode = OH_ImageEffect_SetInputNativeBuffer(imageEffect, nullptr); 691 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 692 693 errorCode = OH_ImageEffect_Start(imageEffect); 694 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 695 696 errorCode = OH_ImageEffect_Release(imageEffect); 697 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 698 } 699 700 /** 701 * Feature: ImageEffect 702 * Function: Test OH_ImageEffect_SetOutputNativeBuffer with normal parameter 703 * SubFunction: NA 704 * FunctionPoints: NA 705 * EnvConditions: NA 706 * CaseDescription: Test OH_ImageEffect_SetOutputNativeBuffer with normal parameter 707 */ 708 HWTEST_F(NativeImageEffectUnittest, OHImageEffectSetOutputNativeBuffer001, TestSize.Level1) 709 { 710 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 711 ASSERT_NE(imageEffect, nullptr); 712 713 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 714 ASSERT_NE(filter, nullptr); 715 716 ImageEffect_Any value; 717 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 718 value.dataValue.floatValue = 100.f; 719 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 720 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 721 722 OH_NativeBuffer *inNativeBuffer = nativeBufferRgba_.get(); 723 errorCode = OH_ImageEffect_SetInputNativeBuffer(imageEffect, inNativeBuffer); 724 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 725 726 OH_NativeBuffer *outNativeBuffer = nativeBufferRgba_.get(); 727 errorCode = OH_ImageEffect_SetOutputNativeBuffer(imageEffect, outNativeBuffer); 728 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 729 730 errorCode = OH_ImageEffect_Start(imageEffect); 731 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 732 733 errorCode = OH_ImageEffect_Release(imageEffect); 734 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 735 } 736 737 /** 738 * Feature: ImageEffect 739 * Function: Test OH_ImageEffect_SetOutputNativeBuffer with all empty parameter 740 * SubFunction: NA 741 * FunctionPoints: NA 742 * EnvConditions: NA 743 * CaseDescription: Test OH_ImageEffect_SetOutputNativeBuffer with all empty parameter 744 */ 745 HWTEST_F(NativeImageEffectUnittest, OHImageEffectSetOutputNativeBuffer002, TestSize.Level1) 746 { 747 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 748 ASSERT_NE(imageEffect, nullptr); 749 750 OH_NativeBuffer *inNativeBuffer = nativeBufferRgba_.get(); 751 ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetInputNativeBuffer(imageEffect, inNativeBuffer); 752 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 753 754 errorCode = OH_ImageEffect_SetOutputNativeBuffer(nullptr, nullptr); 755 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 756 757 errorCode = OH_ImageEffect_Start(imageEffect); 758 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 759 760 errorCode = OH_ImageEffect_Release(imageEffect); 761 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 762 } 763 764 /** 765 * Feature: ImageEffect 766 * Function: Test OH_ImageEffect_SetOutputNativeBuffer with empty OH_ImageEffect 767 * SubFunction: NA 768 * FunctionPoints: NA 769 * EnvConditions: NA 770 * CaseDescription: Test OH_ImageEffect_SetOutputNativeBuffer with empty OH_ImageEffect 771 */ 772 HWTEST_F(NativeImageEffectUnittest, OHImageEffectSetOutputNativeBuffer003, TestSize.Level1) 773 { 774 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 775 ASSERT_NE(imageEffect, nullptr); 776 777 OH_NativeBuffer *inNativeBuffer = nativeBufferRgba_.get(); 778 ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetInputNativeBuffer(imageEffect, inNativeBuffer); 779 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 780 781 OH_NativeBuffer *outNativeBuffer = nativeBufferRgba_.get(); 782 errorCode = OH_ImageEffect_SetOutputNativeBuffer(nullptr, outNativeBuffer); 783 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 784 785 errorCode = OH_ImageEffect_Start(imageEffect); 786 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 787 788 errorCode = OH_ImageEffect_Release(imageEffect); 789 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 790 } 791 792 /** 793 * Feature: ImageEffect 794 * Function: Test OH_ImageEffect_SetOutputNativeBuffer with empty OH_NativeBuffer 795 * SubFunction: NA 796 * FunctionPoints: NA 797 * EnvConditions: NA 798 * CaseDescription: Test OH_ImageEffect_SetOutputNativeBuffer with empty OH_NativeBuffer 799 */ 800 HWTEST_F(NativeImageEffectUnittest, OHImageEffectSetOutputNativeBuffer004, TestSize.Level1) 801 { 802 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 803 ASSERT_NE(imageEffect, nullptr); 804 805 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 806 ASSERT_NE(filter, nullptr); 807 808 ImageEffect_Any value; 809 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 810 value.dataValue.floatValue = 100.f; 811 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 812 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 813 814 OH_NativeBuffer *inNativeBuffer = nativeBufferRgba_.get(); 815 errorCode = OH_ImageEffect_SetInputNativeBuffer(imageEffect, inNativeBuffer); 816 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 817 818 errorCode = OH_ImageEffect_SetOutputNativeBuffer(imageEffect, nullptr); 819 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 820 821 errorCode = OH_ImageEffect_Start(imageEffect); 822 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 823 824 errorCode = OH_ImageEffect_Release(imageEffect); 825 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 826 } 827 828 /** 829 * Feature: ImageEffect 830 * Function: Test OH_ImageEffect_SetOutputNativeBuffer with no OH_ImageEffect_SetInputNativeBuffer 831 * SubFunction: NA 832 * FunctionPoints: NA 833 * EnvConditions: NA 834 * CaseDescription: Test OH_ImageEffect_SetOutputNativeBuffer with no OH_ImageEffect_SetInputNativeBuffer 835 */ 836 HWTEST_F(NativeImageEffectUnittest, OHImageEffectSetOutputNativeBuffer005, TestSize.Level1) 837 { 838 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 839 ASSERT_NE(imageEffect, nullptr); 840 841 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 842 ASSERT_NE(filter, nullptr); 843 844 ImageEffect_Any value; 845 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 846 value.dataValue.floatValue = 100.f; 847 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 848 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 849 850 OH_NativeBuffer *outNativeBuffer = nativeBufferRgba_.get(); 851 errorCode = OH_ImageEffect_SetOutputNativeBuffer(imageEffect, outNativeBuffer); 852 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 853 854 errorCode = OH_ImageEffect_Start(imageEffect); 855 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); // not set input data 856 857 errorCode = OH_ImageEffect_Release(imageEffect); 858 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 859 } 860 861 /** 862 * Feature: ImageEffect 863 * Function: Test OH_EffectFilter_LookupFilters with normal parameter 864 * SubFunction: NA 865 * FunctionPoints: NA 866 * EnvConditions: NA 867 * CaseDescription: Test OH_EffectFilter_LookupFilters with normal parameter 868 */ 869 HWTEST_F(NativeImageEffectUnittest, OHEFilterLookupFilterInfo001, TestSize.Level1) 870 { 871 ImageEffect_Format formats[] = { ImageEffect_Format::EFFECT_PIXEL_FORMAT_NV12, 872 ImageEffect_Format::EFFECT_PIXEL_FORMAT_NV21}; 873 OH_EffectFilterInfo_SetSupportedFormats(filterInfo_, sizeof(formats) / sizeof(ImageEffect_Format), formats); 874 ImageEffect_FilterDelegate delegate = { __anon6e3194820602() 875 .setValue = [](OH_EffectFilter *filter, const char *key, const ImageEffect_Any *value) { return true; }, __anon6e3194820702() 876 .render = [](OH_EffectFilter *filter, OH_EffectBufferInfo *src, OH_EffectFilterDelegate_PushData pushData) { 877 pushData(filter, src); 878 return true; 879 }, __anon6e3194820802() 880 .save = [](OH_EffectFilter *filter, char **info) { return true; }, __anon6e3194820902() 881 .restore = [](const char *info) { return OH_EffectFilter_Create(BRIGHTNESS_EFILTER); } 882 }; 883 884 ImageEffect_ErrorCode errorCode = OH_EffectFilter_Register(filterInfo_, &delegate); 885 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 886 887 const char *name = BRIGHTNESS_EFILTER; 888 OH_EffectFilterInfo *info = OH_EffectFilterInfo_Create(); 889 errorCode = OH_EffectFilter_LookupFilterInfo(name, info); 890 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 891 char *filterName = nullptr; 892 OH_EffectFilterInfo_GetFilterName(info, &filterName); 893 ASSERT_STREQ(filterName, BRIGHTNESS_EFILTER); 894 uint32_t bufferTypeSize = 0; 895 ImageEffect_BufferType *bufferTypeArray = nullptr; 896 OH_EffectFilterInfo_GetSupportedBufferTypes(info, &bufferTypeSize, &bufferTypeArray); 897 ASSERT_EQ(bufferTypeSize, 1); 898 uint32_t formatSize = 0; 899 ImageEffect_Format *formatArray = nullptr; 900 OH_EffectFilterInfo_GetSupportedFormats(info, &formatSize, &formatArray); 901 ASSERT_EQ(formatSize, 2); 902 OH_EffectFilterInfo_Release(info); 903 } 904 905 /** 906 * Feature: ImageEffect 907 * Function: Test OH_EffectFilter_LookupFilters with not support name 908 * SubFunction: NA 909 * FunctionPoints: NA 910 * EnvConditions: NA 911 * CaseDescription: Test OH_EffectFilter_LookupFilters with not support name 912 */ 913 HWTEST_F(NativeImageEffectUnittest, OHEFilterLookupFilterInfo002, TestSize.Level1) 914 { 915 ImageEffect_FilterDelegate delegate = { __anon6e3194820a02() 916 .setValue = [](OH_EffectFilter *filter, const char *key, const ImageEffect_Any *value) { return true; }, __anon6e3194820b02() 917 .render = [](OH_EffectFilter *filter, OH_EffectBufferInfo *src, OH_EffectFilterDelegate_PushData pushData) { 918 pushData(filter, src); 919 return true; 920 }, __anon6e3194820c02() 921 .save = [](OH_EffectFilter *filter, char **info) { return true; }, __anon6e3194820d02() 922 .restore = [](const char *info) { return OH_EffectFilter_Create(BRIGHTNESS_EFILTER); } 923 }; 924 925 ImageEffect_ErrorCode errorCode = OH_EffectFilter_Register(filterInfo_, &delegate); 926 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 927 928 const char *name = "TestEFilter"; 929 OH_EffectFilterInfo *info = OH_EffectFilterInfo_Create(); 930 errorCode = OH_EffectFilter_LookupFilterInfo(name, info); 931 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 932 OH_EffectFilterInfo_Release(info); 933 } 934 935 /** 936 * Feature: ImageEffect 937 * Function: Test OH_EffectFilter_LookupFilters with not OH_EFilter_Register 938 * SubFunction: NA 939 * FunctionPoints: NA 940 * EnvConditions: NA 941 * CaseDescription: Test OH_EffectFilter_LookupFilters with not OH_EFilter_Register 942 */ 943 HWTEST_F(NativeImageEffectUnittest, OHEFilterLookupFilterInfo003, TestSize.Level1) 944 { 945 const char *name = "TestEFilter"; 946 OH_EffectFilterInfo *info = OH_EffectFilterInfo_Create(); 947 ImageEffect_ErrorCode errorCode = OH_EffectFilter_LookupFilterInfo(name, info); 948 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 949 OH_EffectFilterInfo_Release(info); 950 } 951 952 /** 953 * Feature: ImageEffect 954 * Function: Test OH_EffectFilter_LookupFilters with all empty parameter 955 * SubFunction: NA 956 * FunctionPoints: NA 957 * EnvConditions: NA 958 * CaseDescription: Test OH_EffectFilter_LookupFilters with all empty parameter 959 */ 960 HWTEST_F(NativeImageEffectUnittest, OHEFilterLookupFilterInfo004, TestSize.Level1) 961 { 962 ImageEffect_ErrorCode errorCode = OH_EffectFilter_LookupFilterInfo(nullptr, nullptr); 963 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 964 } 965 966 /** 967 * Feature: ImageEffect 968 * Function: Test OH_EffectFilter_LookupFilters with empty name 969 * SubFunction: NA 970 * FunctionPoints: NA 971 * EnvConditions: NA 972 * CaseDescription: Test OH_EffectFilter_LookupFilters with empty name 973 */ 974 HWTEST_F(NativeImageEffectUnittest, OHEFilterLookupFilterInfo005, TestSize.Level1) 975 { 976 OH_EffectFilterInfo *info = OH_EffectFilterInfo_Create(); 977 ImageEffect_ErrorCode errorCode = OH_EffectFilter_LookupFilterInfo(nullptr, info); 978 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 979 OH_EffectFilterInfo_Release(info); 980 } 981 982 /** 983 * Feature: ImageEffect 984 * Function: Test OH_EffectFilter_LookupFilters with normal parameter 985 * SubFunction: NA 986 * FunctionPoints: NA 987 * EnvConditions: NA 988 * CaseDescription: Test OH_EffectFilter_LookupFilters with normal parameter 989 */ 990 HWTEST_F(NativeImageEffectUnittest, OHEFilterLookupFilters001, TestSize.Level1) 991 { 992 ImageEffect_FilterNames *filterNames = OH_EffectFilter_LookupFilters("Format:default"); 993 const char **nameList = filterNames->nameList; 994 uint32_t size = filterNames->size; 995 996 ASSERT_NE(filterNames, nullptr); 997 ASSERT_EQ(size, static_cast<uint32_t>(5)); 998 999 std::vector<string> filterNamesVector; 1000 for (uint32_t i = 0; i < size; i++) { 1001 filterNamesVector.emplace_back(nameList[i]); 1002 } 1003 1004 auto brightnessIndex = std::find(filterNamesVector.begin(), filterNamesVector.end(), BRIGHTNESS_EFILTER); 1005 ASSERT_NE(brightnessIndex, filterNamesVector.end()); 1006 1007 auto contrastIndex = std::find(filterNamesVector.begin(), filterNamesVector.end(), CONTRAST_EFILTER); 1008 ASSERT_NE(contrastIndex, filterNamesVector.end()); 1009 } 1010 1011 /** 1012 * Feature: ImageEffect 1013 * Function: Test OH_EffectFilter_LookupFilters with empty parameter 1014 * SubFunction: NA 1015 * FunctionPoints: NA 1016 * EnvConditions: NA 1017 * CaseDescription: Test OH_EffectFilter_LookupFilters with empty parameter 1018 */ 1019 HWTEST_F(NativeImageEffectUnittest, OHEFilterLookupFilters002, TestSize.Level1) 1020 { 1021 ImageEffect_FilterNames *filterNames= OH_EffectFilter_LookupFilters(nullptr); 1022 ASSERT_EQ(filterNames, nullptr); 1023 } 1024 1025 /** 1026 * Feature: ImageEffect 1027 * Function: Test OH_EffectFilter_LookupFilters with not support parameter 1028 * SubFunction: NA 1029 * FunctionPoints: NA 1030 * EnvConditions: NA 1031 * CaseDescription: Test OH_EffectFilter_LookupFilters with not support parameter 1032 */ 1033 HWTEST_F(NativeImageEffectUnittest, OHEFilterLookupFilters003, TestSize.Level1) 1034 { 1035 bool result = OH_EffectFilter_LookupFilters("test"); 1036 ASSERT_EQ(result, true); 1037 } 1038 1039 /** 1040 * Feature: ImageEffect 1041 * Function: Test OH_EffectFilter_LookupFilters with not support key parameter 1042 * SubFunction: NA 1043 * FunctionPoints: NA 1044 * EnvConditions: NA 1045 * CaseDescription: Test OH_EffectFilter_LookupFilters with not support key parameter 1046 */ 1047 HWTEST_F(NativeImageEffectUnittest, OHEFilterLookupFilters004, TestSize.Level1) 1048 { 1049 bool result = OH_EffectFilter_LookupFilters("test:default"); 1050 ASSERT_EQ(result, true); 1051 } 1052 1053 /** 1054 * Feature: ImageEffect 1055 * Function: Test OH_EffectFilter_LookupFilters with not support value parameter 1056 * SubFunction: NA 1057 * FunctionPoints: NA 1058 * EnvConditions: NA 1059 * CaseDescription: Test OH_EffectFilter_LookupFilters with not support value parameter 1060 */ 1061 HWTEST_F(NativeImageEffectUnittest, OHEFilterLookupFilters005, TestSize.Level1) 1062 { 1063 bool result = OH_EffectFilter_LookupFilters("Category:test"); 1064 ASSERT_EQ(result, true); 1065 } 1066 1067 /** 1068 * Feature: ImageEffect 1069 * Function: Test CustomFilterAdjustmentSaveAndRestore with normal process 1070 * SubFunction: NA 1071 * FunctionPoints: NA 1072 * EnvConditions: NA 1073 * CaseDescription: Test CustomFilterAdjustmentSaveAndRestore with normal process 1074 */ 1075 HWTEST_F(NativeImageEffectUnittest, CustomFilterAdjustmentSaveAndRestore001, TestSize.Level1) 1076 { 1077 OH_EffectFilterInfo_SetFilterName(filterInfo_, CUSTOM_BRIGHTNESS_EFILTER); 1078 1079 ImageEffect_ErrorCode errorCode = OH_EffectFilter_Register(filterInfo_, &delegate_); 1080 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1081 1082 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1083 ASSERT_NE(imageEffect, nullptr); 1084 1085 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, CUSTOM_BRIGHTNESS_EFILTER); 1086 ASSERT_NE(filter, nullptr); 1087 1088 ImageEffect_Any value; 1089 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1090 value.dataValue.floatValue = 50.f; 1091 errorCode = OH_EffectFilter_SetValue(filter, BRIGHTNESS_EFILTER, &value); 1092 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1093 1094 char *imageEffectInfo = nullptr; 1095 errorCode = OH_ImageEffect_Save(imageEffect, &imageEffectInfo); 1096 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1097 ASSERT_NE(imageEffectInfo, nullptr); 1098 std::string saveInfo = imageEffectInfo; 1099 1100 errorCode = OH_ImageEffect_Release(imageEffect); 1101 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1102 1103 imageEffect = OH_ImageEffect_Restore(saveInfo.c_str()); 1104 ASSERT_NE(imageEffect, nullptr); 1105 1106 errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative_); 1107 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1108 1109 std::shared_ptr<OH_PixelmapNative> pixelmapNative = std::make_shared<OH_PixelmapNative>(nullptr); 1110 std::unique_ptr<PixelMap> pixelMap = TestPixelMapUtils::ParsePixelMapByPath(g_jpgPath); 1111 pixelmapNative->pixelmap_ = std::move(pixelMap); 1112 errorCode = OH_ImageEffect_SetOutputPixelmap(imageEffect, pixelmapNative.get()); 1113 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1114 1115 errorCode = OH_ImageEffect_Start(imageEffect); 1116 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1117 1118 errorCode = OH_ImageEffect_Release(imageEffect); 1119 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1120 } 1121 1122 /** 1123 * Feature: ImageEffect 1124 * Function: Test CustomTestFilterSave001 with non-utf-8 abnormal json object 1125 * SubFunction: NA 1126 * FunctionPoints: NA 1127 * EnvConditions: NA 1128 * CaseDescription: Test CustomTestFilterSave001 with non-utf-8 abnormal json object 1129 */ 1130 HWTEST_F(NativeImageEffectUnittest, CustomTestFilterSave001, TestSize.Level1) 1131 { 1132 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1133 ASSERT_NE(imageEffect, nullptr); 1134 1135 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, CUSTOM_TEST_EFILTER); 1136 ASSERT_NE(filter, nullptr); 1137 1138 char value[] = { static_cast<char>(0xb2), static_cast<char>(0xe2), static_cast<char>(0xca), 1139 static_cast<char>(0xd4), '\0' }; // ANSI encode data 1140 1141 ImageEffect_Any any = { 1142 .dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_PTR, 1143 .dataValue.ptrValue = static_cast<void *>(value), 1144 }; 1145 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &any); 1146 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1147 1148 char *info = nullptr; 1149 errorCode = OH_ImageEffect_Save(imageEffect, &info); 1150 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1151 ASSERT_NE(info, nullptr); 1152 1153 std::string data = info; 1154 EffectJsonPtr root = JsonHelper::ParseJsonData(data); 1155 ASSERT_NE(root, nullptr); 1156 1157 EffectJsonPtr imageInfo = root->GetElement("imageEffect"); 1158 ASSERT_NE(imageInfo, nullptr); 1159 1160 std::vector<EffectJsonPtr> filters = imageInfo->GetArray("filters"); 1161 ASSERT_EQ(filters.size(), 1); 1162 1163 EffectJsonPtr values = filters[0]->GetElement("values"); 1164 ASSERT_NE(values, nullptr); 1165 1166 std::string parsedValue = values->GetString(KEY_FILTER_INTENSITY); 1167 ASSERT_STREQ(parsedValue.c_str(), value); 1168 } 1169 1170 HWTEST_F(NativeImageEffectUnittest, OHImageEffectDataTypeSurface001, TestSize.Level1) 1171 { 1172 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1173 ASSERT_NE(imageEffect, nullptr); 1174 1175 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 1176 ASSERT_NE(filter, nullptr); 1177 1178 ImageEffect_Any value; 1179 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1180 value.dataValue.floatValue = 100.f; 1181 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 1182 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1183 1184 errorCode = OH_ImageEffect_SetOutputSurface(imageEffect, g_nativeWindow); 1185 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1186 1187 NativeWindow *nativeWindow = nullptr; 1188 errorCode = OH_ImageEffect_GetInputSurface(imageEffect, &nativeWindow); 1189 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1190 ASSERT_NE(nativeWindow, nullptr); 1191 1192 errorCode = OH_ImageEffect_Start(imageEffect); 1193 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1194 1195 OH_ImageEffect_Release(imageEffect); 1196 OH_NativeWindow_DestroyNativeWindow(nativeWindow); 1197 } 1198 1199 /** 1200 * Feature: ImageEffect 1201 * Function: Test OH_ImageEffect_SetInputNativeBuffer with brightness yuv nv21 1202 * SubFunction: NA 1203 * FunctionPoints: NA 1204 * EnvConditions: NA 1205 * CaseDescription: Test OH_ImageEffect_SetInputNativeBuffer with brightness yuv nv21 1206 */ 1207 HWTEST_F(NativeImageEffectUnittest, OHImageEffectYuvUnittest001, TestSize.Level1) 1208 { 1209 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1210 ASSERT_NE(imageEffect, nullptr); 1211 1212 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 1213 ASSERT_NE(filter, nullptr); 1214 1215 ImageEffect_Any value; 1216 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1217 value.dataValue.floatValue = 50.f; 1218 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 1219 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1220 1221 OH_NativeBuffer *nativeBuffer = nativeBufferNV21_.get(); 1222 errorCode = OH_ImageEffect_SetInputNativeBuffer(imageEffect, nativeBuffer); 1223 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1224 1225 std::shared_ptr<OH_NativeBuffer> nativeBufferNV21 = 1226 TestNativeBufferUtils::CreateNativeBuffer(GraphicPixelFormat::GRAPHIC_PIXEL_FMT_YCRCB_420_SP); 1227 errorCode = OH_ImageEffect_SetOutputNativeBuffer(imageEffect, nativeBufferNV21.get()); 1228 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1229 1230 int32_t ipType = 2; 1231 ImageEffect_Any runningType; 1232 runningType.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32; 1233 runningType.dataValue.int32Value = ipType; 1234 errorCode = OH_ImageEffect_Configure(imageEffect, "runningType", &runningType); 1235 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1236 1237 errorCode = OH_ImageEffect_Start(imageEffect); 1238 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1239 1240 errorCode = OH_ImageEffect_Release(imageEffect); 1241 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1242 } 1243 1244 /** 1245 * Feature: ImageEffect 1246 * Function: Test OH_ImageEffect_SetInputNativeBuffer with yuv brightness yuv nv12 1247 * SubFunction: NA 1248 * FunctionPoints: NA 1249 * EnvConditions: NA 1250 * CaseDescription: Test OH_ImageEffect_SetInputNativeBuffer with yuv brightness yuv nv12 1251 */ 1252 HWTEST_F(NativeImageEffectUnittest, OHImageEffectYuvUnittest002, TestSize.Level1) 1253 { 1254 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1255 ASSERT_NE(imageEffect, nullptr); 1256 1257 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 1258 ASSERT_NE(filter, nullptr); 1259 1260 ImageEffect_Any value; 1261 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1262 value.dataValue.floatValue = 0.f; 1263 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 1264 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1265 1266 OH_EffectFilter *contrastFilter = OH_ImageEffect_AddFilter(imageEffect, CONTRAST_EFILTER); 1267 ASSERT_NE(contrastFilter, nullptr); 1268 1269 ImageEffect_Any contrastValue; 1270 contrastValue.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1271 contrastValue.dataValue.floatValue = 0.f; 1272 errorCode = OH_EffectFilter_SetValue(contrastFilter, KEY_FILTER_INTENSITY, &contrastValue); 1273 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1274 1275 OH_NativeBuffer *nativeBuffer = nativeBufferNV12_.get(); 1276 errorCode = OH_ImageEffect_SetInputNativeBuffer(imageEffect, nativeBuffer); 1277 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1278 1279 std::shared_ptr<OH_NativeBuffer> nativeBufferNV12 = 1280 TestNativeBufferUtils::CreateNativeBuffer(GraphicPixelFormat::GRAPHIC_PIXEL_FMT_YCBCR_420_SP); 1281 errorCode = OH_ImageEffect_SetOutputNativeBuffer(imageEffect, nativeBufferNV12.get()); 1282 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1283 1284 int32_t ipType = 2; 1285 ImageEffect_Any runningType; 1286 runningType.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32; 1287 runningType.dataValue.int32Value = ipType; 1288 errorCode = OH_ImageEffect_Configure(imageEffect, "runningType", &runningType); 1289 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1290 1291 errorCode = OH_ImageEffect_Start(imageEffect); 1292 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1293 1294 errorCode = OH_ImageEffect_Release(imageEffect); 1295 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1296 } 1297 1298 /** 1299 * Feature: ImageEffect 1300 * Function: Test OH_ImageEffect_SetInputNativeBuffer with brightness gpu yuv nv21 1301 * SubFunction: NA 1302 * FunctionPoints: NA 1303 * EnvConditions: NA 1304 * CaseDescription: Test OH_ImageEffect_SetInputNativeBuffer with brightness gpu yuv nv21 1305 */ 1306 HWTEST_F(NativeImageEffectUnittest, OHImageEffectYuvUnittest003, TestSize.Level1) 1307 { 1308 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1309 ASSERT_NE(imageEffect, nullptr); 1310 1311 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 1312 ASSERT_NE(filter, nullptr); 1313 1314 ImageEffect_Any value; 1315 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1316 value.dataValue.floatValue = 0.f; 1317 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 1318 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1319 1320 OH_EffectFilter *contrastFilter = OH_ImageEffect_AddFilter(imageEffect, CONTRAST_EFILTER); 1321 ASSERT_NE(contrastFilter, nullptr); 1322 1323 ImageEffect_Any contrastValue; 1324 contrastValue.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1325 contrastValue.dataValue.floatValue = 0.f; 1326 errorCode = OH_EffectFilter_SetValue(contrastFilter, KEY_FILTER_INTENSITY, &contrastValue); 1327 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1328 1329 OH_NativeBuffer *nativeBuffer = nativeBufferNV21_.get(); 1330 errorCode = OH_ImageEffect_SetInputNativeBuffer(imageEffect, nativeBuffer); 1331 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1332 1333 std::shared_ptr<OH_NativeBuffer> nativeBufferNV21 = 1334 TestNativeBufferUtils::CreateNativeBuffer(GraphicPixelFormat::GRAPHIC_PIXEL_FMT_YCRCB_420_SP); 1335 errorCode = OH_ImageEffect_SetOutputNativeBuffer(imageEffect, nativeBufferNV21.get()); 1336 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1337 1338 int32_t ipType = 1; 1339 ImageEffect_Any runningType; 1340 runningType.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32; 1341 runningType.dataValue.int32Value = ipType; 1342 errorCode = OH_ImageEffect_Configure(imageEffect, "runningType", &runningType); 1343 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1344 1345 errorCode = OH_ImageEffect_Start(imageEffect); 1346 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1347 1348 errorCode = OH_ImageEffect_Release(imageEffect); 1349 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1350 } 1351 1352 /** 1353 * Feature: ImageEffect 1354 * Function: Test OH_ImageEffect_SetInputNativeBuffer with contrast gpu yuv nv21 1355 * SubFunction: NA 1356 * FunctionPoints: NA 1357 * EnvConditions: NA 1358 * CaseDescription: Test OH_ImageEffect_SetInputNativeBuffer with contrast gpu yuv nv21 1359 */ 1360 HWTEST_F(NativeImageEffectUnittest, OHImageEffectYuvUnittest004, TestSize.Level1) 1361 { 1362 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1363 ASSERT_NE(imageEffect, nullptr); 1364 1365 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, CONTRAST_EFILTER); 1366 ASSERT_NE(filter, nullptr); 1367 1368 ImageEffect_Any value; 1369 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1370 value.dataValue.floatValue = 50.f; 1371 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 1372 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1373 1374 OH_NativeBuffer *nativeBuffer = nativeBufferNV21_.get(); 1375 errorCode = OH_ImageEffect_SetInputNativeBuffer(imageEffect, nativeBuffer); 1376 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1377 1378 std::shared_ptr<OH_NativeBuffer> nativeBufferNV21 = 1379 TestNativeBufferUtils::CreateNativeBuffer(GraphicPixelFormat::GRAPHIC_PIXEL_FMT_YCRCB_420_SP); 1380 errorCode = OH_ImageEffect_SetOutputNativeBuffer(imageEffect, nativeBufferNV21.get()); 1381 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1382 1383 int32_t ipType = 1; 1384 ImageEffect_Any runningType; 1385 runningType.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32; 1386 runningType.dataValue.int32Value = ipType; 1387 errorCode = OH_ImageEffect_Configure(imageEffect, "runningType", &runningType); 1388 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1389 1390 errorCode = OH_ImageEffect_Start(imageEffect); 1391 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1392 1393 errorCode = OH_ImageEffect_Release(imageEffect); 1394 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1395 } 1396 1397 /** 1398 * Feature: ImageEffect 1399 * Function: Test OH_ImageEffect_Hdr with BRIGHTNESS_EFILTER 1400 * SubFunction: NA 1401 * FunctionPoints: NA 1402 * EnvConditions: NA 1403 * CaseDescription: Test OH_ImageEffect_Hdr with BRIGHTNESS_EFILTER 1404 */ 1405 HWTEST_F(NativeImageEffectUnittest, OHImageEffectHdr001, TestSize.Level1) 1406 { 1407 std::shared_ptr<OH_PixelmapNative> pixelmapNative = std::make_shared<OH_PixelmapNative>(nullptr); 1408 std::unique_ptr<PixelMap> pixelMap = TestPixelMapUtils::ParsePixelMapByPath(g_jpgHdrPath); 1409 pixelmapNative->pixelmap_ = std::move(pixelMap); 1410 1411 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1412 ASSERT_NE(imageEffect, nullptr); 1413 1414 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 1415 ASSERT_NE(filter, nullptr); 1416 1417 ImageEffect_Any value; 1418 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1419 value.dataValue.floatValue = 100.f; 1420 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 1421 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1422 1423 errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative.get()); 1424 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1425 1426 int32_t ipType = 2; 1427 ImageEffect_Any runningType; 1428 runningType.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32; 1429 runningType.dataValue.int32Value = ipType; 1430 errorCode = OH_ImageEffect_Configure(imageEffect, "runningType", &runningType); 1431 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1432 1433 errorCode = OH_ImageEffect_Start(imageEffect); 1434 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1435 1436 errorCode = OH_ImageEffect_Release(imageEffect); 1437 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1438 } 1439 1440 /** 1441 * Feature: ImageEffect 1442 * Function: Test OH_ImageEffect_Hdr with CROP_EFILTER 1443 * SubFunction: NA 1444 * FunctionPoints: NA 1445 * EnvConditions: NA 1446 * CaseDescription: Test OH_ImageEffect_Hdr with CROP_EFILTER 1447 */ 1448 HWTEST_F(NativeImageEffectUnittest, OHImageEffectHdr002, TestSize.Level1) 1449 { 1450 std::shared_ptr<OH_PixelmapNative> pixelmapNative = std::make_shared<OH_PixelmapNative>(nullptr); 1451 std::unique_ptr<PixelMap> pixelMap = TestPixelMapUtils::ParsePixelMapByPath(g_jpgHdrPath); 1452 pixelmapNative->pixelmap_ = std::move(pixelMap); 1453 1454 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1455 ASSERT_NE(imageEffect, nullptr); 1456 1457 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, CROP_EFILTER); 1458 ASSERT_NE(filter, nullptr); 1459 1460 uint32_t x1 = static_cast<uint32_t>(pixelmapNative->pixelmap_->GetWidth() / CROP_FACTOR); 1461 uint32_t y1 = static_cast<uint32_t>(pixelmapNative->pixelmap_->GetHeight() / CROP_FACTOR); 1462 uint32_t areaInfo[] = { 0, 0, x1, y1}; 1463 ImageEffect_Any value; 1464 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_PTR; 1465 value.dataValue.ptrValue = static_cast<void *>(areaInfo); 1466 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_REGION, &value); 1467 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1468 1469 errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative.get()); 1470 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1471 1472 errorCode = OH_ImageEffect_Start(imageEffect); 1473 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1474 1475 errorCode = OH_ImageEffect_Release(imageEffect); 1476 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1477 } 1478 1479 /** 1480 * Feature: ImageEffect 1481 * Function: Test OH_ImageEffect_Hdr with SetOutputPixelmap 1482 * SubFunction: NA 1483 * FunctionPoints: NA 1484 * EnvConditions: NA 1485 * CaseDescription: Test OH_ImageEffect_Hdr with SetOutputPixelmap 1486 */ 1487 HWTEST_F(NativeImageEffectUnittest, OHImageEffectHdr003, TestSize.Level1) 1488 { 1489 std::shared_ptr<OH_PixelmapNative> pixelmapNative = std::make_shared<OH_PixelmapNative>(nullptr); 1490 std::unique_ptr<PixelMap> pixelMap = TestPixelMapUtils::ParsePixelMapByPath(g_jpgHdrPath); 1491 ASSERT_NE(pixelMap, nullptr); 1492 pixelmapNative->pixelmap_ = std::move(pixelMap); 1493 1494 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1495 ASSERT_NE(imageEffect, nullptr); 1496 1497 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 1498 ASSERT_NE(filter, nullptr); 1499 1500 ImageEffect_Any value; 1501 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1502 value.dataValue.floatValue = 100.f; 1503 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 1504 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1505 1506 errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative.get()); 1507 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1508 1509 errorCode = OH_ImageEffect_SetOutputPixelmap(imageEffect, pixelmapNative_); 1510 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1511 1512 int32_t ipType = 2; 1513 ImageEffect_Any runningType; 1514 runningType.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32; 1515 runningType.dataValue.int32Value = ipType; 1516 errorCode = OH_ImageEffect_Configure(imageEffect, "runningType", &runningType); 1517 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1518 1519 errorCode = OH_ImageEffect_Start(imageEffect); 1520 if (pixelmapNative->pixelmap_->IsHdr()) { 1521 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1522 } else { 1523 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1524 } 1525 1526 errorCode = OH_ImageEffect_Release(imageEffect); 1527 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1528 } 1529 1530 /** 1531 * Feature: ImageEffect 1532 * Function: Test OH_ImageEffect_Hdr with ConverCPU2GPU and ConverGPU2CPU 1533 * SubFunction: NA 1534 * FunctionPoints: NA 1535 * EnvConditions: NA 1536 * CaseDescription: Test OH_ImageEffect_Hdr with ConverCPU2GPU and ConverGPU2CPU 1537 */ 1538 HWTEST_F(NativeImageEffectUnittest, OHImageEffectHdr004, TestSize.Level1) 1539 { 1540 std::shared_ptr<OH_PixelmapNative> pixelmapNative = std::make_shared<OH_PixelmapNative>(nullptr); 1541 std::unique_ptr<PixelMap> pixelMap = TestPixelMapUtils::ParsePixelMapByPath(g_jpgHdrPath); 1542 ASSERT_NE(pixelMap, nullptr); 1543 pixelmapNative->pixelmap_ = std::move(pixelMap); 1544 1545 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1546 ASSERT_NE(imageEffect, nullptr); 1547 1548 OH_EffectFilter *customfilter = OH_ImageEffect_AddFilter(imageEffect, CUSTOM_TEST_EFILTER); 1549 ASSERT_NE(customfilter, nullptr); 1550 1551 customfilter = OH_ImageEffect_AddFilter(imageEffect, CUSTOM_TEST_EFILTER2); 1552 ASSERT_NE(customfilter, nullptr); 1553 1554 customfilter = OH_ImageEffect_AddFilter(imageEffect, CUSTOM_TEST_EFILTER); 1555 ASSERT_NE(customfilter, nullptr); 1556 1557 ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative.get()); 1558 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1559 1560 int32_t ipType = 1; 1561 ImageEffect_Any runningType; 1562 runningType.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32; 1563 runningType.dataValue.int32Value = ipType; 1564 errorCode = OH_ImageEffect_Configure(imageEffect, "runningType", &runningType); 1565 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1566 1567 errorCode = OH_ImageEffect_Start(imageEffect); 1568 if (pixelmapNative->pixelmap_->IsHdr()) { 1569 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1570 } else { 1571 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1572 } 1573 1574 errorCode = OH_ImageEffect_Stop(imageEffect); 1575 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1576 1577 errorCode = OH_ImageEffect_Release(imageEffect); 1578 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1579 } 1580 1581 /** 1582 * Feature: ImageEffect 1583 * Function: Test OH_ImageEffect with picture 1584 * SubFunction: NA 1585 * FunctionPoints: NA 1586 * EnvConditions: NA 1587 * CaseDescription: Test OH_ImageEffect with picture 1588 */ 1589 HWTEST_F(NativeImageEffectUnittest, OHImageEffectPicture001, TestSize.Level1) 1590 { 1591 std::shared_ptr<Picture> picture = std::make_shared<MockPicture>(); 1592 std::shared_ptr<OH_PictureNative> pictureNative = std::make_shared<OH_PictureNative>(picture); 1593 1594 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1595 ASSERT_NE(imageEffect, nullptr); 1596 1597 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_CONTRAST_FILTER); 1598 ASSERT_NE(filter, nullptr); 1599 1600 ImageEffect_Any value; 1601 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1602 value.dataValue.floatValue = 100.f; 1603 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 1604 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1605 1606 errorCode = OH_ImageEffect_SetInputPicture(imageEffect, pictureNative.get()); 1607 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1608 1609 // start with input 1610 errorCode = OH_ImageEffect_Start(imageEffect); 1611 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1612 1613 // start with in and out(input equal to output) 1614 errorCode = OH_ImageEffect_SetOutputPicture(imageEffect, pictureNative.get()); 1615 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1616 errorCode = OH_ImageEffect_Start(imageEffect); 1617 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1618 1619 // start with in and out 1620 std::shared_ptr<Picture> outputPicture = std::make_shared<MockPicture>(); 1621 std::shared_ptr<OH_PictureNative> outputPictureNative = std::make_shared<OH_PictureNative>(outputPicture); 1622 errorCode = OH_ImageEffect_SetOutputPicture(imageEffect, outputPictureNative.get()); 1623 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1624 errorCode = OH_ImageEffect_Start(imageEffect); 1625 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1626 1627 errorCode = OH_ImageEffect_Release(imageEffect); 1628 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1629 } 1630 1631 /** 1632 * Feature: ImageEffect 1633 * Function: Test OH_ImageEffect with picture for abnormal input parameters. 1634 * SubFunction: NA 1635 * FunctionPoints: NA 1636 * EnvConditions: NA 1637 * CaseDescription: Test OH_ImageEffect with picture for abnormal input parameters. 1638 */ 1639 HWTEST_F(NativeImageEffectUnittest, OHImageEffectPicture002, TestSize.Level1) 1640 { 1641 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); __anon6e3194820e02(OH_ImageEffect *imageEffect) 1642 std::shared_ptr<OH_ImageEffect> imageEffectPtr(imageEffect, [](OH_ImageEffect *imageEffect) { 1643 if (imageEffect != nullptr) { 1644 OH_ImageEffect_Release(imageEffect); 1645 } 1646 }); 1647 std::shared_ptr<Picture> picture = std::make_shared<MockPicture>(); 1648 std::shared_ptr<OH_PictureNative> pictureNative = std::make_shared<OH_PictureNative>(picture); 1649 std::shared_ptr<Picture> defaultPicture; 1650 std::shared_ptr<OH_PictureNative> abnormalPictureNative = std::make_shared<OH_PictureNative>(defaultPicture); 1651 1652 ASSERT_NE(OH_ImageEffect_SetInputPicture(nullptr, pictureNative.get()), ImageEffect_ErrorCode::EFFECT_SUCCESS); 1653 ASSERT_NE(OH_ImageEffect_SetInputPicture(imageEffectPtr.get(), nullptr), ImageEffect_ErrorCode::EFFECT_SUCCESS); 1654 ASSERT_NE(OH_ImageEffect_SetInputPicture(imageEffectPtr.get(), abnormalPictureNative.get()), 1655 ImageEffect_ErrorCode::EFFECT_SUCCESS); 1656 ASSERT_EQ(OH_ImageEffect_SetInputPicture(imageEffectPtr.get(), pictureNative.get()), 1657 ImageEffect_ErrorCode::EFFECT_SUCCESS); 1658 1659 ASSERT_NE(OH_ImageEffect_SetOutputPicture(nullptr, pictureNative.get()), ImageEffect_ErrorCode::EFFECT_SUCCESS); 1660 ASSERT_EQ(OH_ImageEffect_SetOutputPicture(imageEffectPtr.get(), nullptr), ImageEffect_ErrorCode::EFFECT_SUCCESS); 1661 ASSERT_EQ(OH_ImageEffect_SetOutputPicture(imageEffectPtr.get(), abnormalPictureNative.get()), 1662 ImageEffect_ErrorCode::EFFECT_SUCCESS); 1663 ASSERT_EQ(OH_ImageEffect_SetOutputPicture(imageEffectPtr.get(), pictureNative.get()), 1664 ImageEffect_ErrorCode::EFFECT_SUCCESS); 1665 } 1666 } // namespace Test 1667 } // namespace Effect 1668 } // namespace Media 1669 } // namespace OHOS
