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