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 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 = 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_ = { __anonf138c2ac0202() 204 .setValue = [](OH_EffectFilter *filter, const char *key, const ImageEffect_Any *value) { return true; }, __anonf138c2ac0302() 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 }, __anonf138c2ac0402() 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 }, __anonf138c2ac0502() 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 = { __anonf138c2ac0602() 877 .setValue = [](OH_EffectFilter *filter, const char *key, const ImageEffect_Any *value) { return true; }, __anonf138c2ac0702() 878 .render = [](OH_EffectFilter *filter, OH_EffectBufferInfo *src, OH_EffectFilterDelegate_PushData pushData) { 879 pushData(filter, src); 880 return true; 881 }, __anonf138c2ac0802() 882 .save = [](OH_EffectFilter *filter, char **info) { return true; }, __anonf138c2ac0902() 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 = { __anonf138c2ac0a02() 918 .setValue = [](OH_EffectFilter *filter, const char *key, const ImageEffect_Any *value) { return true; }, __anonf138c2ac0b02() 919 .render = [](OH_EffectFilter *filter, OH_EffectBufferInfo *src, OH_EffectFilterDelegate_PushData pushData) { 920 pushData(filter, src); 921 return true; 922 }, __anonf138c2ac0c02() 923 .save = [](OH_EffectFilter *filter, char **info) { return true; }, __anonf138c2ac0d02() 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 std::vector<string> filterNamesVector; 1001 for (uint32_t i = 0; i < size; i++) { 1002 filterNamesVector.emplace_back(nameList[i]); 1003 } 1004 1005 auto brightnessIndex = std::find(filterNamesVector.begin(), filterNamesVector.end(), BRIGHTNESS_EFILTER); 1006 ASSERT_NE(brightnessIndex, filterNamesVector.end()); 1007 1008 auto contrastIndex = std::find(filterNamesVector.begin(), filterNamesVector.end(), CONTRAST_EFILTER); 1009 ASSERT_NE(contrastIndex, filterNamesVector.end()); 1010 } 1011 1012 /** 1013 * Feature: ImageEffect 1014 * Function: Test OH_EffectFilter_LookupFilters with empty parameter 1015 * SubFunction: NA 1016 * FunctionPoints: NA 1017 * EnvConditions: NA 1018 * CaseDescription: Test OH_EffectFilter_LookupFilters with empty parameter 1019 */ 1020 HWTEST_F(NativeImageEffectUnittest, OHEFilterLookupFilters002, TestSize.Level1) 1021 { 1022 ImageEffect_FilterNames *filterNames= OH_EffectFilter_LookupFilters(nullptr); 1023 ASSERT_EQ(filterNames, nullptr); 1024 } 1025 1026 /** 1027 * Feature: ImageEffect 1028 * Function: Test OH_EffectFilter_LookupFilters with not support parameter 1029 * SubFunction: NA 1030 * FunctionPoints: NA 1031 * EnvConditions: NA 1032 * CaseDescription: Test OH_EffectFilter_LookupFilters with not support parameter 1033 */ 1034 HWTEST_F(NativeImageEffectUnittest, OHEFilterLookupFilters003, TestSize.Level1) 1035 { 1036 bool result = OH_EffectFilter_LookupFilters("test"); 1037 ASSERT_EQ(result, true); 1038 } 1039 1040 /** 1041 * Feature: ImageEffect 1042 * Function: Test OH_EffectFilter_LookupFilters with not support key parameter 1043 * SubFunction: NA 1044 * FunctionPoints: NA 1045 * EnvConditions: NA 1046 * CaseDescription: Test OH_EffectFilter_LookupFilters with not support key parameter 1047 */ 1048 HWTEST_F(NativeImageEffectUnittest, OHEFilterLookupFilters004, TestSize.Level1) 1049 { 1050 bool result = OH_EffectFilter_LookupFilters("test:default"); 1051 ASSERT_EQ(result, true); 1052 } 1053 1054 /** 1055 * Feature: ImageEffect 1056 * Function: Test OH_EffectFilter_LookupFilters with not support value parameter 1057 * SubFunction: NA 1058 * FunctionPoints: NA 1059 * EnvConditions: NA 1060 * CaseDescription: Test OH_EffectFilter_LookupFilters with not support value parameter 1061 */ 1062 HWTEST_F(NativeImageEffectUnittest, OHEFilterLookupFilters005, TestSize.Level1) 1063 { 1064 bool result = OH_EffectFilter_LookupFilters("Category:test"); 1065 ASSERT_EQ(result, true); 1066 } 1067 1068 /** 1069 * Feature: ImageEffect 1070 * Function: Test CustomFilterAdjustmentSaveAndRestore with normal process 1071 * SubFunction: NA 1072 * FunctionPoints: NA 1073 * EnvConditions: NA 1074 * CaseDescription: Test CustomFilterAdjustmentSaveAndRestore with normal process 1075 */ 1076 HWTEST_F(NativeImageEffectUnittest, CustomFilterAdjustmentSaveAndRestore001, TestSize.Level1) 1077 { 1078 OH_EffectFilterInfo_SetFilterName(filterInfo_, CUSTOM_BRIGHTNESS_EFILTER); 1079 1080 ImageEffect_ErrorCode errorCode = OH_EffectFilter_Register(filterInfo_, &delegate_); 1081 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1082 1083 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1084 ASSERT_NE(imageEffect, nullptr); 1085 1086 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, CUSTOM_BRIGHTNESS_EFILTER); 1087 ASSERT_NE(filter, nullptr); 1088 1089 ImageEffect_Any value; 1090 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1091 value.dataValue.floatValue = 50.f; 1092 errorCode = OH_EffectFilter_SetValue(filter, BRIGHTNESS_EFILTER, &value); 1093 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1094 1095 char *imageEffectInfo = nullptr; 1096 errorCode = OH_ImageEffect_Save(imageEffect, &imageEffectInfo); 1097 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1098 ASSERT_NE(imageEffectInfo, nullptr); 1099 std::string saveInfo = imageEffectInfo; 1100 1101 errorCode = OH_ImageEffect_Release(imageEffect); 1102 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1103 1104 imageEffect = OH_ImageEffect_Restore(saveInfo.c_str()); 1105 ASSERT_NE(imageEffect, nullptr); 1106 1107 errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative_); 1108 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1109 1110 errorCode = OH_ImageEffect_Start(imageEffect); 1111 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1112 1113 errorCode = OH_ImageEffect_Release(imageEffect); 1114 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1115 } 1116 1117 /** 1118 * Feature: ImageEffect 1119 * Function: Test CustomTestFilterSave001 with non-utf-8 abnormal json object 1120 * SubFunction: NA 1121 * FunctionPoints: NA 1122 * EnvConditions: NA 1123 * CaseDescription: Test CustomTestFilterSave001 with non-utf-8 abnormal json object 1124 */ 1125 HWTEST_F(NativeImageEffectUnittest, CustomTestFilterSave001, TestSize.Level1) 1126 { 1127 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1128 ASSERT_NE(imageEffect, nullptr); 1129 1130 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, CUSTOM_TEST_EFILTER); 1131 ASSERT_NE(filter, nullptr); 1132 1133 char value[] = { static_cast<char>(0xb2), static_cast<char>(0xe2), static_cast<char>(0xca), 1134 static_cast<char>(0xd4), '\0' }; // ANSI encode data 1135 1136 ImageEffect_Any any = { 1137 .dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_PTR, 1138 .dataValue.ptrValue = static_cast<void *>(value), 1139 }; 1140 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &any); 1141 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1142 1143 char *info = nullptr; 1144 errorCode = OH_ImageEffect_Save(imageEffect, &info); 1145 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1146 ASSERT_NE(info, nullptr); 1147 1148 std::string data = info; 1149 EffectJsonPtr root = EffectJsonHelper::ParseJsonData(data); 1150 ASSERT_NE(root, nullptr); 1151 1152 EffectJsonPtr imageInfo = root->GetElement("imageEffect"); 1153 ASSERT_NE(imageInfo, nullptr); 1154 1155 std::vector<EffectJsonPtr> filters = imageInfo->GetArray("filters"); 1156 ASSERT_EQ(filters.size(), 1); 1157 1158 EffectJsonPtr values = filters[0]->GetElement("values"); 1159 ASSERT_NE(values, nullptr); 1160 1161 std::string parsedValue = values->GetString(KEY_FILTER_INTENSITY); 1162 ASSERT_STREQ(parsedValue.c_str(), value); 1163 } 1164 1165 HWTEST_F(NativeImageEffectUnittest, OHImageEffectDataTypeSurface001, TestSize.Level1) 1166 { 1167 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1168 ASSERT_NE(imageEffect, nullptr); 1169 1170 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 1171 ASSERT_NE(filter, nullptr); 1172 1173 ImageEffect_Any value; 1174 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1175 value.dataValue.floatValue = 100.f; 1176 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 1177 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1178 1179 errorCode = OH_ImageEffect_SetOutputSurface(imageEffect, g_nativeWindow); 1180 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1181 1182 NativeWindow *nativeWindow = nullptr; 1183 errorCode = OH_ImageEffect_GetInputSurface(imageEffect, &nativeWindow); 1184 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1185 ASSERT_NE(nativeWindow, nullptr); 1186 1187 errorCode = OH_ImageEffect_Start(imageEffect); 1188 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1189 1190 OH_ImageEffect_Release(imageEffect); 1191 OH_NativeWindow_DestroyNativeWindow(nativeWindow); 1192 } 1193 1194 /** 1195 * Feature: ImageEffect 1196 * Function: Test OH_ImageEffect_SetInputNativeBuffer with brightness yuv nv21 1197 * SubFunction: NA 1198 * FunctionPoints: NA 1199 * EnvConditions: NA 1200 * CaseDescription: Test OH_ImageEffect_SetInputNativeBuffer with brightness yuv nv21 1201 */ 1202 HWTEST_F(NativeImageEffectUnittest, OHImageEffectYuvUnittest001, TestSize.Level1) 1203 { 1204 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1205 ASSERT_NE(imageEffect, nullptr); 1206 1207 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 1208 ASSERT_NE(filter, nullptr); 1209 1210 ImageEffect_Any value; 1211 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1212 value.dataValue.floatValue = 50.f; 1213 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 1214 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1215 1216 OH_NativeBuffer *nativeBuffer = nativeBufferNV21_.get(); 1217 errorCode = OH_ImageEffect_SetInputNativeBuffer(imageEffect, nativeBuffer); 1218 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1219 1220 int32_t ipType = 2; 1221 ImageEffect_Any runningType; 1222 runningType.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32; 1223 runningType.dataValue.int32Value = ipType; 1224 errorCode = OH_ImageEffect_Configure(imageEffect, "runningType", &runningType); 1225 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1226 1227 errorCode = OH_ImageEffect_Start(imageEffect); 1228 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1229 1230 errorCode = OH_ImageEffect_Release(imageEffect); 1231 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1232 } 1233 1234 /** 1235 * Feature: ImageEffect 1236 * Function: Test OH_ImageEffect_SetInputNativeBuffer with yuv brightness yuv nv12 1237 * SubFunction: NA 1238 * FunctionPoints: NA 1239 * EnvConditions: NA 1240 * CaseDescription: Test OH_ImageEffect_SetInputNativeBuffer with yuv brightness yuv nv12 1241 */ 1242 HWTEST_F(NativeImageEffectUnittest, OHImageEffectYuvUnittest002, TestSize.Level1) 1243 { 1244 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1245 ASSERT_NE(imageEffect, nullptr); 1246 1247 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 1248 ASSERT_NE(filter, nullptr); 1249 1250 ImageEffect_Any value; 1251 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1252 value.dataValue.floatValue = 0.f; 1253 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 1254 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1255 1256 OH_EffectFilter *contrastFilter = OH_ImageEffect_AddFilter(imageEffect, CONTRAST_EFILTER); 1257 ASSERT_NE(contrastFilter, nullptr); 1258 1259 ImageEffect_Any contrastValue; 1260 contrastValue.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1261 contrastValue.dataValue.floatValue = 0.f; 1262 errorCode = OH_EffectFilter_SetValue(contrastFilter, KEY_FILTER_INTENSITY, &contrastValue); 1263 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1264 1265 OH_NativeBuffer *nativeBuffer = nativeBufferNV12_.get(); 1266 errorCode = OH_ImageEffect_SetInputNativeBuffer(imageEffect, nativeBuffer); 1267 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1268 1269 int32_t ipType = 2; 1270 ImageEffect_Any runningType; 1271 runningType.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32; 1272 runningType.dataValue.int32Value = ipType; 1273 errorCode = OH_ImageEffect_Configure(imageEffect, "runningType", &runningType); 1274 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1275 1276 errorCode = OH_ImageEffect_Start(imageEffect); 1277 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1278 1279 errorCode = OH_ImageEffect_Release(imageEffect); 1280 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1281 } 1282 1283 /** 1284 * Feature: ImageEffect 1285 * Function: Test OH_ImageEffect_SetInputNativeBuffer with brightness gpu yuv nv21 1286 * SubFunction: NA 1287 * FunctionPoints: NA 1288 * EnvConditions: NA 1289 * CaseDescription: Test OH_ImageEffect_SetInputNativeBuffer with brightness gpu yuv nv21 1290 */ 1291 HWTEST_F(NativeImageEffectUnittest, OHImageEffectYuvUnittest003, TestSize.Level1) 1292 { 1293 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1294 ASSERT_NE(imageEffect, nullptr); 1295 1296 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 1297 ASSERT_NE(filter, nullptr); 1298 1299 ImageEffect_Any value; 1300 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1301 value.dataValue.floatValue = 0.f; 1302 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 1303 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1304 1305 OH_EffectFilter *contrastFilter = OH_ImageEffect_AddFilter(imageEffect, CONTRAST_EFILTER); 1306 ASSERT_NE(contrastFilter, nullptr); 1307 1308 ImageEffect_Any contrastValue; 1309 contrastValue.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1310 contrastValue.dataValue.floatValue = 0.f; 1311 errorCode = OH_EffectFilter_SetValue(contrastFilter, KEY_FILTER_INTENSITY, &contrastValue); 1312 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1313 1314 OH_NativeBuffer *nativeBuffer = nativeBufferNV21_.get(); 1315 errorCode = OH_ImageEffect_SetInputNativeBuffer(imageEffect, nativeBuffer); 1316 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1317 1318 int32_t ipType = 1; 1319 ImageEffect_Any runningType; 1320 runningType.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32; 1321 runningType.dataValue.int32Value = ipType; 1322 errorCode = OH_ImageEffect_Configure(imageEffect, "runningType", &runningType); 1323 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1324 1325 errorCode = OH_ImageEffect_Start(imageEffect); 1326 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1327 1328 errorCode = OH_ImageEffect_Release(imageEffect); 1329 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1330 } 1331 1332 /** 1333 * Feature: ImageEffect 1334 * Function: Test OH_ImageEffect_SetInputNativeBuffer with contrast gpu yuv nv21 1335 * SubFunction: NA 1336 * FunctionPoints: NA 1337 * EnvConditions: NA 1338 * CaseDescription: Test OH_ImageEffect_SetInputNativeBuffer with contrast gpu yuv nv21 1339 */ 1340 HWTEST_F(NativeImageEffectUnittest, OHImageEffectYuvUnittest004, TestSize.Level1) 1341 { 1342 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1343 ASSERT_NE(imageEffect, nullptr); 1344 1345 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, CONTRAST_EFILTER); 1346 ASSERT_NE(filter, nullptr); 1347 1348 ImageEffect_Any value; 1349 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1350 value.dataValue.floatValue = 50.f; 1351 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 1352 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1353 1354 OH_NativeBuffer *nativeBuffer = nativeBufferNV21_.get(); 1355 errorCode = OH_ImageEffect_SetInputNativeBuffer(imageEffect, nativeBuffer); 1356 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1357 1358 int32_t ipType = 1; 1359 ImageEffect_Any runningType; 1360 runningType.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32; 1361 runningType.dataValue.int32Value = ipType; 1362 errorCode = OH_ImageEffect_Configure(imageEffect, "runningType", &runningType); 1363 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1364 1365 errorCode = OH_ImageEffect_Start(imageEffect); 1366 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1367 1368 errorCode = OH_ImageEffect_Release(imageEffect); 1369 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1370 } 1371 1372 /** 1373 * Feature: ImageEffect 1374 * Function: Test OH_ImageEffect_Hdr with BRIGHTNESS_EFILTER 1375 * SubFunction: NA 1376 * FunctionPoints: NA 1377 * EnvConditions: NA 1378 * CaseDescription: Test OH_ImageEffect_Hdr with BRIGHTNESS_EFILTER 1379 */ 1380 HWTEST_F(NativeImageEffectUnittest, OHImageEffectHdr001, TestSize.Level1) 1381 { 1382 std::shared_ptr<OH_PixelmapNative> pixelmapNative = std::make_shared<OH_PixelmapNative>(nullptr); 1383 std::unique_ptr<PixelMap> pixelMap = TestPixelMapUtils::ParsePixelMapByPath(g_jpgHdrPath); 1384 pixelmapNative->pixelmap_ = std::move(pixelMap); 1385 1386 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1387 ASSERT_NE(imageEffect, nullptr); 1388 1389 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 1390 ASSERT_NE(filter, nullptr); 1391 1392 ImageEffect_Any value; 1393 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1394 value.dataValue.floatValue = 100.f; 1395 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 1396 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1397 1398 errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative_); 1399 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1400 1401 int32_t ipType = 2; 1402 ImageEffect_Any runningType; 1403 runningType.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32; 1404 runningType.dataValue.int32Value = ipType; 1405 errorCode = OH_ImageEffect_Configure(imageEffect, "runningType", &runningType); 1406 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1407 1408 errorCode = OH_ImageEffect_Start(imageEffect); 1409 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1410 1411 errorCode = OH_ImageEffect_Release(imageEffect); 1412 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1413 } 1414 1415 /** 1416 * Feature: ImageEffect 1417 * Function: Test OH_ImageEffect_Hdr with CROP_EFILTER 1418 * SubFunction: NA 1419 * FunctionPoints: NA 1420 * EnvConditions: NA 1421 * CaseDescription: Test OH_ImageEffect_Hdr with CROP_EFILTER 1422 */ 1423 HWTEST_F(NativeImageEffectUnittest, OHImageEffectHdr002, TestSize.Level1) 1424 { 1425 std::shared_ptr<OH_PixelmapNative> pixelmapNative = std::make_shared<OH_PixelmapNative>(nullptr); 1426 std::unique_ptr<PixelMap> pixelMap = TestPixelMapUtils::ParsePixelMapByPath(g_jpgHdrPath); 1427 pixelmapNative->pixelmap_ = std::move(pixelMap); 1428 1429 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1430 ASSERT_NE(imageEffect, nullptr); 1431 1432 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, CROP_EFILTER); 1433 ASSERT_NE(filter, nullptr); 1434 1435 uint32_t x1 = static_cast<uint32_t>(pixelmapNative->pixelmap_->GetWidth() / CROP_FACTOR); 1436 uint32_t y1 = static_cast<uint32_t>(pixelmapNative->pixelmap_->GetHeight() / CROP_FACTOR); 1437 uint32_t areaInfo[] = { 0, 0, x1, y1}; 1438 ImageEffect_Any value; 1439 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_PTR; 1440 value.dataValue.ptrValue = static_cast<void *>(areaInfo); 1441 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_REGION, &value); 1442 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1443 1444 errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative.get()); 1445 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1446 1447 errorCode = OH_ImageEffect_Start(imageEffect); 1448 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1449 1450 errorCode = OH_ImageEffect_Release(imageEffect); 1451 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1452 } 1453 1454 /** 1455 * Feature: ImageEffect 1456 * Function: Test OH_ImageEffect_Hdr with SetOutputPixelmap 1457 * SubFunction: NA 1458 * FunctionPoints: NA 1459 * EnvConditions: NA 1460 * CaseDescription: Test OH_ImageEffect_Hdr with SetOutputPixelmap 1461 */ 1462 HWTEST_F(NativeImageEffectUnittest, OHImageEffectHdr003, TestSize.Level1) 1463 { 1464 std::shared_ptr<OH_PixelmapNative> pixelmapNative = std::make_shared<OH_PixelmapNative>(nullptr); 1465 std::unique_ptr<PixelMap> pixelMap = TestPixelMapUtils::ParsePixelMapByPath(g_jpgHdrPath); 1466 ASSERT_NE(pixelMap, nullptr); 1467 pixelmapNative->pixelmap_ = std::move(pixelMap); 1468 1469 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1470 ASSERT_NE(imageEffect, nullptr); 1471 1472 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 1473 ASSERT_NE(filter, nullptr); 1474 1475 ImageEffect_Any value; 1476 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1477 value.dataValue.floatValue = 100.f; 1478 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 1479 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1480 1481 errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative.get()); 1482 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1483 1484 errorCode = OH_ImageEffect_SetOutputPixelmap(imageEffect, pixelmapNative_); 1485 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1486 1487 int32_t ipType = 2; 1488 ImageEffect_Any runningType; 1489 runningType.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32; 1490 runningType.dataValue.int32Value = ipType; 1491 errorCode = OH_ImageEffect_Configure(imageEffect, "runningType", &runningType); 1492 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1493 1494 errorCode = OH_ImageEffect_Start(imageEffect); 1495 if (pixelmapNative->pixelmap_->IsHdr()) { 1496 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1497 } else { 1498 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1499 } 1500 1501 errorCode = OH_ImageEffect_Release(imageEffect); 1502 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1503 } 1504 1505 /** 1506 * Feature: ImageEffect 1507 * Function: Test OH_ImageEffect_Hdr with ConverCPU2GPU and ConverGPU2CPU 1508 * SubFunction: NA 1509 * FunctionPoints: NA 1510 * EnvConditions: NA 1511 * CaseDescription: Test OH_ImageEffect_Hdr with ConverCPU2GPU and ConverGPU2CPU 1512 */ 1513 HWTEST_F(NativeImageEffectUnittest, OHImageEffectHdr004, TestSize.Level1) 1514 { 1515 std::shared_ptr<OH_PixelmapNative> pixelmapNative = std::make_shared<OH_PixelmapNative>(nullptr); 1516 std::unique_ptr<PixelMap> pixelMap = TestPixelMapUtils::ParsePixelMapByPath(g_jpgHdrPath); 1517 ASSERT_NE(pixelMap, nullptr); 1518 pixelmapNative->pixelmap_ = std::move(pixelMap); 1519 1520 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1521 ASSERT_NE(imageEffect, nullptr); 1522 1523 OH_EffectFilter *customfilter = OH_ImageEffect_AddFilter(imageEffect, CUSTOM_TEST_EFILTER); 1524 ASSERT_NE(customfilter, nullptr); 1525 1526 customfilter = OH_ImageEffect_AddFilter(imageEffect, CUSTOM_TEST_EFILTER2); 1527 ASSERT_NE(customfilter, nullptr); 1528 1529 customfilter = OH_ImageEffect_AddFilter(imageEffect, CUSTOM_TEST_EFILTER); 1530 ASSERT_NE(customfilter, nullptr); 1531 1532 ImageEffect_ErrorCode errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative.get()); 1533 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1534 1535 int32_t ipType = 1; 1536 ImageEffect_Any runningType; 1537 runningType.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32; 1538 runningType.dataValue.int32Value = ipType; 1539 errorCode = OH_ImageEffect_Configure(imageEffect, "runningType", &runningType); 1540 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1541 1542 errorCode = OH_ImageEffect_Start(imageEffect); 1543 if (pixelmapNative->pixelmap_->IsHdr()) { 1544 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1545 } else { 1546 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1547 } 1548 1549 errorCode = OH_ImageEffect_Stop(imageEffect); 1550 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1551 1552 errorCode = OH_ImageEffect_Release(imageEffect); 1553 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1554 } 1555 1556 /** 1557 * Feature: ImageEffect 1558 * Function: Test OH_ImageEffect_Hdr with Adobe 1559 * SubFunction: NA 1560 * FunctionPoints: NA 1561 * EnvConditions: NA 1562 * CaseDescription: Test OH_ImageEffect_Hdr with Adobe 1563 */ 1564 HWTEST_F(NativeImageEffectUnittest, OHImageEffectAdobe001, TestSize.Level1) 1565 { 1566 std::shared_ptr<OH_PixelmapNative> pixelmapNative = std::make_shared<OH_PixelmapNative>(nullptr); 1567 std::unique_ptr<PixelMap> pixelMap = TestPixelMapUtils::ParsePixelMapByPath(g_adobeHdrPath); 1568 pixelmapNative->pixelmap_ = std::move(pixelMap); 1569 1570 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1571 ASSERT_NE(imageEffect, nullptr); 1572 1573 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, BRIGHTNESS_EFILTER); 1574 ASSERT_NE(filter, nullptr); 1575 1576 ImageEffect_Any value; 1577 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1578 value.dataValue.floatValue = 100.f; 1579 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 1580 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1581 1582 errorCode = OH_ImageEffect_SetInputPixelmap(imageEffect, pixelmapNative.get()); 1583 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1584 1585 int32_t ipType = 2; 1586 ImageEffect_Any runningType; 1587 runningType.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_INT32; 1588 runningType.dataValue.int32Value = ipType; 1589 errorCode = OH_ImageEffect_Configure(imageEffect, "runningType", &runningType); 1590 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1591 1592 errorCode = OH_ImageEffect_Start(imageEffect); 1593 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1594 1595 errorCode = OH_ImageEffect_Release(imageEffect); 1596 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1597 } 1598 1599 /** 1600 * Feature: ImageEffect 1601 * Function: Test OH_ImageEffect with picture 1602 * SubFunction: NA 1603 * FunctionPoints: NA 1604 * EnvConditions: NA 1605 * CaseDescription: Test OH_ImageEffect with picture 1606 */ 1607 HWTEST_F(NativeImageEffectUnittest, OHImageEffectPicture001, TestSize.Level1) 1608 { 1609 std::shared_ptr<Picture> picture = std::make_shared<MockPicture>(); 1610 std::shared_ptr<OH_PictureNative> pictureNative = std::make_shared<OH_PictureNative>(picture); 1611 1612 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1613 ASSERT_NE(imageEffect, nullptr); 1614 1615 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_CONTRAST_FILTER); 1616 ASSERT_NE(filter, nullptr); 1617 1618 ImageEffect_Any value; 1619 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1620 value.dataValue.floatValue = 100.f; 1621 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 1622 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1623 1624 errorCode = OH_ImageEffect_SetInputPicture(imageEffect, pictureNative.get()); 1625 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1626 1627 // start with input 1628 errorCode = OH_ImageEffect_Start(imageEffect); 1629 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1630 1631 // start with in and out(input equal to output) 1632 errorCode = OH_ImageEffect_SetOutputPicture(imageEffect, pictureNative.get()); 1633 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1634 errorCode = OH_ImageEffect_Start(imageEffect); 1635 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1636 1637 // start with in and out 1638 std::shared_ptr<Picture> outputPicture = std::make_shared<MockPicture>(); 1639 std::shared_ptr<OH_PictureNative> outputPictureNative = std::make_shared<OH_PictureNative>(outputPicture); 1640 errorCode = OH_ImageEffect_SetOutputPicture(imageEffect, outputPictureNative.get()); 1641 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1642 errorCode = OH_ImageEffect_Start(imageEffect); 1643 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1644 1645 errorCode = OH_ImageEffect_Release(imageEffect); 1646 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1647 } 1648 1649 /** 1650 * Feature: ImageEffect 1651 * Function: Test OH_ImageEffect with picture for abnormal input parameters. 1652 * SubFunction: NA 1653 * FunctionPoints: NA 1654 * EnvConditions: NA 1655 * CaseDescription: Test OH_ImageEffect with picture for abnormal input parameters. 1656 */ 1657 HWTEST_F(NativeImageEffectUnittest, OHImageEffectPicture002, TestSize.Level1) 1658 { 1659 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); __anonf138c2ac0e02(OH_ImageEffect *imageEffect) 1660 std::shared_ptr<OH_ImageEffect> imageEffectPtr(imageEffect, [](OH_ImageEffect *imageEffect) { 1661 if (imageEffect != nullptr) { 1662 OH_ImageEffect_Release(imageEffect); 1663 } 1664 }); 1665 std::shared_ptr<Picture> picture = std::make_shared<MockPicture>(); 1666 std::shared_ptr<OH_PictureNative> pictureNative = std::make_shared<OH_PictureNative>(picture); 1667 std::shared_ptr<Picture> defaultPicture; 1668 std::shared_ptr<OH_PictureNative> abnormalPictureNative = std::make_shared<OH_PictureNative>(defaultPicture); 1669 1670 ASSERT_NE(OH_ImageEffect_SetInputPicture(nullptr, pictureNative.get()), ImageEffect_ErrorCode::EFFECT_SUCCESS); 1671 ASSERT_NE(OH_ImageEffect_SetInputPicture(imageEffectPtr.get(), nullptr), ImageEffect_ErrorCode::EFFECT_SUCCESS); 1672 ASSERT_NE(OH_ImageEffect_SetInputPicture(imageEffectPtr.get(), abnormalPictureNative.get()), 1673 ImageEffect_ErrorCode::EFFECT_SUCCESS); 1674 ASSERT_EQ(OH_ImageEffect_SetInputPicture(imageEffectPtr.get(), pictureNative.get()), 1675 ImageEffect_ErrorCode::EFFECT_SUCCESS); 1676 1677 ASSERT_NE(OH_ImageEffect_SetOutputPicture(nullptr, pictureNative.get()), ImageEffect_ErrorCode::EFFECT_SUCCESS); 1678 ASSERT_EQ(OH_ImageEffect_SetOutputPicture(imageEffectPtr.get(), nullptr), ImageEffect_ErrorCode::EFFECT_SUCCESS); 1679 ASSERT_EQ(OH_ImageEffect_SetOutputPicture(imageEffectPtr.get(), abnormalPictureNative.get()), 1680 ImageEffect_ErrorCode::EFFECT_SUCCESS); 1681 ASSERT_EQ(OH_ImageEffect_SetOutputPicture(imageEffectPtr.get(), pictureNative.get()), 1682 ImageEffect_ErrorCode::EFFECT_SUCCESS); 1683 } 1684 1685 /** 1686 * Feature: ImageEffect 1687 * Function: Test OH_ImageEffect with texture 1688 * SubFunction: NA 1689 * FunctionPoints: NA 1690 * EnvConditions: NA 1691 * CaseDescription: Test OH_ImageEffect with texture 1692 */ 1693 HWTEST_F(NativeImageEffectUnittest, OHImageEffectTexture001, TestSize.Level1) 1694 { 1695 std::shared_ptr<RenderEnvironment> renderEnv = std::make_shared<RenderEnvironment>(); 1696 renderEnv->Init(); 1697 renderEnv->BeginFrame(); 1698 1699 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1700 ASSERT_NE(imageEffect, nullptr); __anonf138c2ac0f02(OH_ImageEffect *imageEffect) 1701 std::shared_ptr<OH_ImageEffect> imageEffectPtr(imageEffect, [](OH_ImageEffect *imageEffect) { 1702 if (imageEffect != nullptr) { 1703 OH_ImageEffect_Release(imageEffect); 1704 } 1705 }); 1706 1707 std::shared_ptr<RenderTexture> input = renderEnv->RequestBuffer(1920, 1080, GL_RGBA8); 1708 ASSERT_NE(OH_ImageEffect_SetInputTextureId(nullptr, input->GetName(), ColorManager::ColorSpaceName::SRGB), 1709 ImageEffect_ErrorCode::EFFECT_SUCCESS); 1710 ASSERT_NE(OH_ImageEffect_SetInputTextureId(imageEffect, 0, ColorManager::ColorSpaceName::SRGB), 1711 ImageEffect_ErrorCode::EFFECT_SUCCESS); 1712 1713 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_CONTRAST_FILTER); 1714 ASSERT_NE(filter, nullptr); 1715 1716 ImageEffect_Any value; 1717 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1718 value.dataValue.floatValue = 100.f; 1719 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 1720 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1721 1722 ASSERT_EQ(OH_ImageEffect_SetInputTextureId(imageEffectPtr.get(), input->GetName(), 1723 ColorManager::ColorSpaceName::SRGB), ImageEffect_ErrorCode::EFFECT_SUCCESS); 1724 1725 // start with input 1726 errorCode = OH_ImageEffect_Start(imageEffect); 1727 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1728 1729 // start with in and out(input equal to output) 1730 errorCode = OH_ImageEffect_SetOutputTextureId(imageEffect, input->GetName()); 1731 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1732 errorCode = OH_ImageEffect_Start(imageEffect); 1733 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1734 1735 // start with in and out 1736 std::shared_ptr<RenderTexture> output = renderEnv->RequestBuffer(1920, 1080, GL_RGBA8); 1737 errorCode = OH_ImageEffect_SetOutputTextureId(imageEffect, output->GetName()); 1738 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1739 errorCode = OH_ImageEffect_Start(imageEffect); 1740 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1741 renderEnv->Release(); 1742 renderEnv->ReleaseParam(); 1743 renderEnv = nullptr; 1744 } 1745 1746 /** 1747 * Feature: ImageEffect 1748 * Function: Test OH_ImageEffect with texture for abnormal input paramters. 1749 * SubFunction: NA 1750 * FunctionPoints: NA 1751 * EnvConditions: NA 1752 * CaseDescription: Test OH_ImageEffect with texture for abnormal input paramters 1753 */ 1754 1755 HWTEST_F(NativeImageEffectUnittest, OHImageEffectTexture002, TestSize.Level1) 1756 { 1757 std::shared_ptr<RenderEnvironment> renderEnv = std::make_shared<RenderEnvironment>(); 1758 renderEnv->Init(); 1759 renderEnv->BeginFrame(); 1760 1761 OH_ImageEffect *imageEffect = OH_ImageEffect_Create(IMAGE_EFFECT_NAME); 1762 ASSERT_NE(imageEffect, nullptr); __anonf138c2ac1002(OH_ImageEffect *imageEffect) 1763 std::shared_ptr<OH_ImageEffect> imageEffectPtr(imageEffect, [](OH_ImageEffect *imageEffect) { 1764 if (imageEffect != nullptr) { 1765 OH_ImageEffect_Release(imageEffect); 1766 } 1767 }); 1768 1769 OH_EffectFilter *filter = OH_ImageEffect_AddFilter(imageEffect, OH_EFFECT_CONTRAST_FILTER); 1770 ASSERT_NE(filter, nullptr); 1771 1772 ImageEffect_Any value; 1773 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1774 value.dataValue.floatValue = 100.f; 1775 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 1776 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1777 1778 std::shared_ptr<RenderTexture> output = renderEnv->RequestBuffer(1920, 1080, GL_RGBA8); 1779 errorCode = OH_ImageEffect_SetOutputTextureId(imageEffect, output->GetName()); 1780 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1781 errorCode = OH_ImageEffect_Start(imageEffect); 1782 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1783 1784 std::shared_ptr<RenderTexture> input = renderEnv->RequestBuffer(1920, 1080, GL_RGBA8); 1785 ASSERT_EQ(OH_ImageEffect_SetInputTextureId(imageEffectPtr.get(), input->GetName(), 1786 ColorManager::ColorSpaceName::ADOBE_RGB), ImageEffect_ErrorCode::EFFECT_SUCCESS); 1787 errorCode = OH_ImageEffect_Start(imageEffect); 1788 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1789 1790 std::shared_ptr<RenderTexture> input_err = renderEnv->RequestBuffer(1920, 1080, GL_RGB16F); 1791 ASSERT_EQ(OH_ImageEffect_SetInputTextureId(imageEffectPtr.get(), input_err->GetName(), 1792 ColorManager::ColorSpaceName::SRGB), ImageEffect_ErrorCode::EFFECT_SUCCESS); 1793 errorCode = OH_ImageEffect_Start(imageEffect); 1794 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1795 renderEnv->Release(); 1796 renderEnv->ReleaseParam(); 1797 renderEnv = nullptr; 1798 } 1799 1800 /** 1801 * Feature: ImageEffect 1802 * Function: Test OH_EFilter with texture. 1803 * SubFunction: NA 1804 * FunctionPoints: NA 1805 * EnvConditions: NA 1806 * CaseDescription: Test OH_EFilter with texture 1807 */ 1808 1809 HWTEST_F(NativeImageEffectUnittest, OHEffectFilterRenderWithTexture001, TestSize.Level1) 1810 { 1811 std::shared_ptr<RenderEnvironment> renderEnv = std::make_shared<RenderEnvironment>(); 1812 renderEnv->Init(); 1813 renderEnv->BeginFrame(); 1814 OH_EffectFilter *filter = OH_EffectFilter_Create(OH_EFFECT_CONTRAST_FILTER); 1815 ASSERT_NE(filter, nullptr); 1816 ImageEffect_Any value; 1817 value.dataType = ImageEffect_DataType::EFFECT_DATA_TYPE_FLOAT; 1818 value.dataValue.floatValue = 100.f; 1819 ImageEffect_ErrorCode errorCode = OH_EffectFilter_SetValue(filter, KEY_FILTER_INTENSITY, &value); 1820 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1821 1822 errorCode = OH_EffectFilter_RenderWithTextureId(filter, 0, 0, ColorManager::ColorSpaceName::SRGB); 1823 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1824 1825 std::shared_ptr<RenderTexture> input = renderEnv->RequestBuffer(1920, 1080, GL_RGBA8); 1826 std::shared_ptr<RenderTexture> output = renderEnv->RequestBuffer(1920, 1080, GL_RGBA8); 1827 errorCode = OH_EffectFilter_RenderWithTextureId(filter, input->GetName(), input->GetName(), 1828 ColorManager::ColorSpaceName::SRGB); 1829 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1830 1831 errorCode = OH_EffectFilter_RenderWithTextureId(filter, input->GetName(), output->GetName(), 1832 ColorManager::ColorSpaceName::ADOBE_RGB); 1833 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1834 1835 std::shared_ptr<RenderTexture> input_error = renderEnv->RequestBuffer(1920, 1080, GL_RGB16F); 1836 errorCode = OH_EffectFilter_RenderWithTextureId(filter, input_error->GetName(), output->GetName(), 1837 ColorManager::ColorSpaceName::SRGB); 1838 ASSERT_NE(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1839 1840 errorCode = OH_EffectFilter_RenderWithTextureId(filter, input->GetName(), output->GetName(), 1841 ColorManager::ColorSpaceName::SRGB); 1842 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1843 errorCode = OH_EffectFilter_Release(filter); 1844 ASSERT_EQ(errorCode, ImageEffect_ErrorCode::EFFECT_SUCCESS); 1845 renderEnv->Release(); 1846 renderEnv->ReleaseParam(); 1847 renderEnv = nullptr; 1848 } 1849 1850 } // namespace Test 1851 } // namespace Effect 1852 } // namespace Media 1853 } // namespace OHOS 1854
