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 <gtest/gtest.h>
17
18 #include "ge_render.h"
19 #include "ge_visual_effect_impl.h"
20
21 using namespace testing;
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace GraphicsEffectEngine {
26
27 using namespace Rosen;
28
29 class GERenderTest : public testing::Test {
30 public:
31 static void SetUpTestCase();
32 static void TearDownTestCase();
33 void SetUp() override;
34 void TearDown() override;
35
36 std::shared_ptr<Drawing::Image> MakeImage(Drawing::Canvas& canvas);
37
38 static inline Drawing::Canvas canvas_;
39
40 private:
41 std::shared_ptr<Drawing::RuntimeEffect> MakeGreyAdjustmentEffect();
42
43 std::shared_ptr<Drawing::RuntimeEffect> greyAdjustEffect_;
44 };
45
SetUpTestCase(void)46 void GERenderTest::SetUpTestCase(void) {}
47
TearDownTestCase(void)48 void GERenderTest::TearDownTestCase(void) {}
49
SetUp()50 void GERenderTest::SetUp() {}
51
TearDown()52 void GERenderTest::TearDown() {}
53
MakeGreyAdjustmentEffect()54 std::shared_ptr<Drawing::RuntimeEffect> GERenderTest::MakeGreyAdjustmentEffect()
55 {
56 static const std::string GreyGradationString(R"(
57 uniform shader imageShader;
58 uniform float coefficient1;
59 uniform float coefficient2;
60
61 float poww(float x, float y) {
62 return (x < 0) ? -pow(-x, y) : pow(x, y);
63 }
64
65 float calculateT_y(float rgb) {
66 if (rgb > 127.5) { rgb = 255 - rgb; }
67 float b = 38.0;
68 float c = 45.0;
69 float d = 127.5;
70 float A = 106.5; // 3 * b - 3 * c + d;
71 float B = -93; // 3 * (c - 2 * b);
72 float C = 114; // 3 * b;
73 float p = 0.816240163988; // (3 * A * C - pow(B, 2)) / (3 * pow(A, 2));
74 float q = -rgb / 106.5 + 0.262253485943; // -rgb/A - B*C/(3*pow(A,2)) + 2*pow(B,3)/(27*pow(A,3))
75 float s1 = -(q / 2.0);
76 float s2 = sqrt(pow(s1, 2) + pow(p / 3, 3));
77 return poww((s1 + s2), 1.0 / 3) + poww((s1 - s2), 1.0 / 3) - (B / (3 * A));
78 }
79
80 float calculateGreyAdjustY(float rgb) {
81 float t_r = calculateT_y(rgb);
82 return (rgb < 127.5) ? (rgb + coefficient1 * pow((1 - t_r), 3)) : (rgb - coefficient2 * pow((1 - t_r), 3));
83 }
84
85 vec4 main(vec2 drawing_coord) {
86 vec3 color = vec3(imageShader(drawing_coord).r, imageShader(drawing_coord).g, imageShader(drawing_coord).b);
87 float Y = (0.299 * color.r + 0.587 * color.g + 0.114 * color.b) * 255;
88 float U = (-0.147 * color.r - 0.289 * color.g + 0.436 * color.b) * 255;
89 float V = (0.615 * color.r - 0.515 * color.g - 0.100 * color.b) * 255;
90 Y = calculateGreyAdjustY(Y);
91 color.r = (Y + 1.14 * V) / 255.0;
92 color.g = (Y - 0.39 * U - 0.58 * V) / 255.0;
93 color.b = (Y + 2.03 * U) / 255.0;
94
95 return vec4(color, 1.0);
96 }
97 )");
98 if (!greyAdjustEffect_) {
99 std::shared_ptr<Drawing::RuntimeEffect> greyAdjustEffect =
100 Drawing::RuntimeEffect::CreateForShader(GreyGradationString);
101 if (!greyAdjustEffect) {
102 return nullptr;
103 }
104 greyAdjustEffect_ = std::move(greyAdjustEffect);
105 }
106
107 return greyAdjustEffect_;
108 }
109
MakeImage(Drawing::Canvas & canvas)110 std::shared_ptr<Drawing::Image> GERenderTest::MakeImage(Drawing::Canvas& canvas)
111 {
112 auto image = std::make_shared<Drawing::Image>();
113 if (image == nullptr) {
114 GTEST_LOG_(ERROR) << "GERenderTest::MakeImage image is null";
115 return nullptr;
116 }
117 float greyX = 0.0f;
118 float greyY = 1.0f;
119
120 auto greyAdjustEffect = MakeGreyAdjustmentEffect();
121 if (!greyAdjustEffect) {
122 GTEST_LOG_(ERROR) << "GERenderTest::MakeImage greyAdjustEffect is null";
123 return nullptr;
124 }
125 auto builder = std::make_shared<Drawing::RuntimeShaderBuilder>(greyAdjustEffect);
126 Drawing::Matrix matrix;
127 auto imageShader = Drawing::ShaderEffect::CreateImageShader(*image, Drawing::TileMode::CLAMP,
128 Drawing::TileMode::CLAMP, Drawing::SamplingOptions(Drawing::FilterMode::LINEAR), matrix);
129 builder->SetChild("imageShader", imageShader);
130 builder->SetUniform("coefficient1", greyX);
131 builder->SetUniform("coefficient2", greyY);
132 return builder->MakeImage(canvas.GetGPUContext().get(), nullptr, image->GetImageInfo(), false);
133 }
134
135 /**
136 * @tc.name: DrawImageEffect_001
137 * @tc.desc: Verify the DrawImageEffect
138 * @tc.type: FUNC
139 */
140 HWTEST_F(GERenderTest, DrawImageEffect_001, TestSize.Level1)
141 {
142 GTEST_LOG_(INFO) << "GERenderTest DrawImageEffect_001 start";
143
144 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_KAWASE_BLUR);
145 visualEffect->SetParam(Drawing::GE_FILTER_KAWASE_BLUR_RADIUS, 1);
146
147 auto veContainer = std::make_shared<Drawing::GEVisualEffectContainer>();
148 veContainer->AddToChainedFilter(visualEffect);
149
150 const std::shared_ptr<Drawing::Image> image = nullptr;
151 const Drawing::Rect src(1.0f, 1.0f, 1.0f, 1.0f);
152 const Drawing::Rect dst(1.0f, 1.0f, 1.0f, 1.0f);
153 const Drawing::SamplingOptions sampling;
154 auto geRender = std::make_shared<GERender>();
155 if (!geRender) {
156 GTEST_LOG_(INFO) << "GERenderTest geRender is null";
157 return;
158 }
159 geRender->DrawImageEffect(canvas_, *veContainer, image, src, dst, sampling);
160
161 GTEST_LOG_(INFO) << "GERenderTest DrawImageEffect_001 end";
162 }
163
164 /**
165 * @tc.name: DrawImageEffect_002
166 * @tc.desc: Verify the DrawImageEffect
167 * @tc.type: FUNC
168 */
169 HWTEST_F(GERenderTest, DrawImageEffect_002, TestSize.Level1)
170 {
171 GTEST_LOG_(INFO) << "GERenderTest DrawImageEffect_002 start";
172
173 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_KAWASE_BLUR);
174 visualEffect->SetParam(Drawing::GE_FILTER_KAWASE_BLUR_RADIUS, 0);
175
176 auto veContainer = std::make_shared<Drawing::GEVisualEffectContainer>();
177 veContainer->AddToChainedFilter(visualEffect);
178
179 auto image = std::make_shared<Drawing::Image>();
180 if (!image) {
181 GTEST_LOG_(INFO) << "GERenderTest image is null";
182 return;
183 }
184 const Drawing::Rect src(1.0f, 1.0f, 1.0f, 1.0f);
185 const Drawing::Rect dst(1.0f, 1.0f, 1.0f, 1.0f);
186 const Drawing::SamplingOptions sampling;
187 auto geRender = std::make_shared<GERender>();
188 if (!geRender) {
189 GTEST_LOG_(INFO) << "GERenderTest geRender is null";
190 return;
191 }
192 geRender->DrawImageEffect(canvas_, *veContainer, image, src, dst, sampling);
193
194 GTEST_LOG_(INFO) << "GERenderTest DrawImageEffect_002 end";
195 }
196
197 /**
198 * @tc.name: DrawImageEffect_003
199 * @tc.desc: Verify the DrawImageEffect
200 * @tc.type: FUNC
201 */
202 HWTEST_F(GERenderTest, DrawImageEffect_003, TestSize.Level1)
203 {
204 GTEST_LOG_(INFO) << "GERenderTest DrawImageEffect_003 start";
205
206 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_KAWASE_BLUR);
207 visualEffect->SetParam(Drawing::GE_FILTER_KAWASE_BLUR_RADIUS, 1);
208
209 auto veContainer = std::make_shared<Drawing::GEVisualEffectContainer>();
210 veContainer->AddToChainedFilter(visualEffect);
211
212 auto image = MakeImage(canvas_);
213 if (!image) {
214 GTEST_LOG_(INFO) << "GERenderTest image is null";
215 return;
216 }
217 const Drawing::Rect src(1.0f, 1.0f, 1.0f, 1.0f);
218 const Drawing::Rect dst(1.0f, 1.0f, 1.0f, 1.0f);
219 const Drawing::SamplingOptions sampling;
220 auto geRender = std::make_shared<GERender>();
221 if (!geRender) {
222 GTEST_LOG_(INFO) << "GERenderTest geRender is null";
223 return;
224 }
225 geRender->DrawImageEffect(canvas_, *veContainer, image, src, dst, sampling);
226
227 GTEST_LOG_(INFO) << "GERenderTest DrawImageEffect_003 end";
228 }
229
230 /**
231 * @tc.name: ApplyImageEffect_001
232 * @tc.desc: Verify the ApplyImageEffect
233 * @tc.type: FUNC
234 */
235 HWTEST_F(GERenderTest, ApplyImageEffect001, TestSize.Level0)
236 {
237 GTEST_LOG_(INFO) << "GERenderTest ApplyImageEffect_001 start";
238
239 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_KAWASE_BLUR);
240 visualEffect->SetParam(Drawing::GE_FILTER_KAWASE_BLUR_RADIUS, 1);
241
242 auto veContainer = std::make_shared<Drawing::GEVisualEffectContainer>();
243 veContainer->AddToChainedFilter(visualEffect);
244
245 const std::shared_ptr<Drawing::Image> image = nullptr;
246 const Drawing::Rect src(1.0f, 1.0f, 1.0f, 1.0f);
247 const Drawing::Rect dst(1.0f, 1.0f, 1.0f, 1.0f);
248 const Drawing::SamplingOptions sampling;
249 auto geRender = std::make_shared<GERender>();
250 if (!geRender) {
251 GTEST_LOG_(INFO) << "GERenderTest geRender is null";
252 return;
253 }
254 auto outImage = geRender->ApplyImageEffect(canvas_, *veContainer, image, src, dst, sampling);
255 EXPECT_TRUE(outImage == image);
256
257 GTEST_LOG_(INFO) << "GERenderTest ApplyImageEffect_001 end";
258 }
259
260 /**
261 * @tc.name: ApplyGEEffects001
262 * @tc.desc: Verify the ApplyGEEffects
263 * @tc.type: FUNC
264 */
265 HWTEST_F(GERenderTest, ApplyGEEffects001, TestSize.Level1)
266 {
267 GTEST_LOG_(INFO) << "GERenderTest ApplyGEEffects001 start";
268
269 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_KAWASE_BLUR);
270 visualEffect->SetParam(Drawing::GE_FILTER_KAWASE_BLUR_RADIUS, 1);
271
272 std::vector<std::shared_ptr<Drawing::GEVisualEffect>> visualEffects;
273 visualEffects.push_back(visualEffect);
274
275 auto image = MakeImage(canvas_);
276 if (!image) {
277 GTEST_LOG_(INFO) << "GERenderTest image is null";
278 return;
279 }
280 const Drawing::Rect src(1.0f, 1.0f, 1.0f, 1.0f);
281 const Drawing::Rect dst(1.0f, 1.0f, 1.0f, 1.0f);
282 const Drawing::SamplingOptions sampling;
283 auto geRender = std::make_shared<GERender>();
284 if (!geRender) {
285 GTEST_LOG_(INFO) << "GERenderTest geRender is null";
286 return;
287 }
288 std::shared_ptr<Drawing::Image> outImage;
289 GERender::HpsGEImageEffectContext context { image, src, src, Drawing::SamplingOptions(), false };
290 geRender->ApplyGEEffects(canvas_, visualEffects, context, outImage);
291 EXPECT_NE(outImage, image);
292
293 GTEST_LOG_(INFO) << "GERenderTest ApplyGEEffects001 end";
294 }
295
296 /**
297 * @tc.name: ApplyGEEffects002
298 * @tc.desc: Verify the ApplyGEEffects
299 * @tc.type: FUNC
300 */
301 HWTEST_F(GERenderTest, ApplyGEEffects002, TestSize.Level1)
302 {
303 GTEST_LOG_(INFO) << "GERenderTest ApplyGEEffects002 start";
304 std::vector<std::shared_ptr<Drawing::GEVisualEffect>> visualEffects;
305 auto image = MakeImage(canvas_);
306 if (!image) {
307 GTEST_LOG_(INFO) << "GERenderTest image is null";
308 return;
309 }
310 const Drawing::Rect src(1.0f, 1.0f, 1.0f, 1.0f);
311 const Drawing::Rect dst(1.0f, 1.0f, 1.0f, 1.0f);
312 const Drawing::SamplingOptions sampling;
313 auto geRender = std::make_shared<GERender>();
314 if (!geRender) {
315 GTEST_LOG_(INFO) << "GERenderTest geRender is null";
316 return;
317 }
318 std::shared_ptr<Drawing::Image> outImage;
319 GERender::HpsGEImageEffectContext context { image, src, src, Drawing::SamplingOptions(), false };
320 geRender->ApplyGEEffects(canvas_, visualEffects, context, outImage);
321 EXPECT_EQ(outImage, image);
322
323 GTEST_LOG_(INFO) << "GERenderTest ApplyGEEffects002 end";
324 }
325
326 /**
327 * @tc.name: ApplyGEEffects003
328 * @tc.desc: Verify the ApplyGEEffects
329 * @tc.type: FUNC
330 */
331 HWTEST_F(GERenderTest, ApplyGEEffects003, TestSize.Level1)
332 {
333 GTEST_LOG_(INFO) << "GERenderTest ApplyGEEffects003 start";
334
335 std::shared_ptr<Drawing::GEVisualEffect> visualEffect = nullptr;
336 std::vector<std::shared_ptr<Drawing::GEVisualEffect>> visualEffects;
337 visualEffects.push_back(visualEffect);
338
339 auto image = MakeImage(canvas_);
340 if (!image) {
341 GTEST_LOG_(INFO) << "GERenderTest image is null";
342 return;
343 }
344 const Drawing::Rect src(1.0f, 1.0f, 1.0f, 1.0f);
345 const Drawing::Rect dst(1.0f, 1.0f, 1.0f, 1.0f);
346 const Drawing::SamplingOptions sampling;
347 auto geRender = std::make_shared<GERender>();
348 if (!geRender) {
349 GTEST_LOG_(INFO) << "GERenderTest geRender is null";
350 return;
351 }
352 std::shared_ptr<Drawing::Image> outImage;
353 GERender::HpsGEImageEffectContext context { image, src, src, Drawing::SamplingOptions(), false };
354 geRender->ApplyGEEffects(canvas_, visualEffects, context, outImage);
355 EXPECT_EQ(outImage, image);
356
357 GTEST_LOG_(INFO) << "GERenderTest ApplyGEEffects003 end";
358 }
359
360 /**
361 * @tc.name: ApplyGEEffects004
362 * @tc.desc: Verify the ApplyGEEffects
363 * @tc.type: FUNC
364 */
365 HWTEST_F(GERenderTest, ApplyGEEffects004, TestSize.Level1)
366 {
367 GTEST_LOG_(INFO) << "GERenderTest ApplyGEEffects004 start";
368
369 auto visualEffect1 = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_GREY);
370 visualEffect1->SetParam(Drawing::GE_FILTER_GREY_COEF_1, 1.0f);
371 visualEffect1->SetParam(Drawing::GE_FILTER_GREY_COEF_2, 1.0f);
372
373 auto visualEffect2 = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_KAWASE_BLUR);
374 visualEffect2->SetParam(Drawing::GE_FILTER_KAWASE_BLUR_RADIUS, 1);
375
376 std::vector<std::shared_ptr<Drawing::GEVisualEffect>> visualEffects;
377 visualEffects.push_back(visualEffect1);
378 visualEffects.push_back(visualEffect2);
379
380 auto image = MakeImage(canvas_);
381 if (!image) {
382 GTEST_LOG_(INFO) << "GERenderTest image is null";
383 return;
384 }
385 const Drawing::Rect src(1.0f, 1.0f, 1.0f, 1.0f);
386 const Drawing::Rect dst(1.0f, 1.0f, 1.0f, 1.0f);
387 const Drawing::SamplingOptions sampling;
388 auto geRender = std::make_shared<GERender>();
389 if (!geRender) {
390 GTEST_LOG_(INFO) << "GERenderTest geRender is null";
391 return;
392 }
393 std::shared_ptr<Drawing::Image> outImage;
394 GERender::HpsGEImageEffectContext context { image, src, src, Drawing::SamplingOptions(), false };
395 geRender->ApplyGEEffects(canvas_, visualEffects, context, outImage);
396 EXPECT_NE(outImage, image);
397
398 GTEST_LOG_(INFO) << "GERenderTest ApplyGEEffects004 end";
399 }
400
401 using IndexRange = GERender::IndexRange;
402
403 /**
404 * @tc.name: CategorizeRanges001
405 * @tc.desc: Verify the CategorizeRanges
406 * @tc.type: FUNC
407 */
408 HWTEST_F(GERenderTest, CategorizeRanges001, TestSize.Level1)
409 {
410 GTEST_LOG_(INFO) << "GERenderTest CategorizeRanges001 start";
411
412 auto geRender = std::make_shared<GERender>();
413 if (!geRender) {
414 GTEST_LOG_(INFO) << "GERenderTest geRender is null";
415 return;
416 }
417 vector<IndexRange> hpsRanges = { { 3, 5 } };
418 int32_t veSize = 10;
419 auto result = geRender->CategorizeRanges(hpsRanges, veSize);
420 EXPECT_EQ(result.size(), 3);
421
422 EXPECT_EQ(result[0].mode, GERender::EffectMode::GE);
423 EXPECT_EQ(result[0].range[0], 0);
424 EXPECT_EQ(result[0].range[1], 2);
425
426 EXPECT_EQ(result[1].mode, GERender::EffectMode::HPS);
427 EXPECT_EQ(result[1].range[0], 3);
428 EXPECT_EQ(result[1].range[1], 5);
429
430 EXPECT_EQ(result[2].mode, GERender::EffectMode::GE);
431 EXPECT_EQ(result[2].range[0], 6);
432 EXPECT_EQ(result[2].range[1], 9);
433
434 GTEST_LOG_(INFO) << "GERenderTest CategorizeRanges001 end";
435 }
436
437 /**
438 * @tc.name: CategorizeRanges002
439 * @tc.desc: Verify the CategorizeRanges
440 * @tc.type: FUNC
441 */
442 HWTEST_F(GERenderTest, CategorizeRanges002, TestSize.Level1)
443 {
444 GTEST_LOG_(INFO) << "GERenderTest CategorizeRanges002 start";
445
446 auto geRender = std::make_shared<GERender>();
447 if (!geRender) {
448 GTEST_LOG_(INFO) << "GERenderTest geRender is null";
449 return;
450 }
451 vector<IndexRange> hpsRanges = { { 2, 4 }, { 7, 9 } };
452 int32_t veSize = 10;
453 auto result = geRender->CategorizeRanges(hpsRanges, veSize);
454 EXPECT_EQ(result.size(), 4);
455
456 EXPECT_EQ(result[0].mode, GERender::EffectMode::GE);
457 EXPECT_EQ(result[0].range[0], 0);
458 EXPECT_EQ(result[0].range[1], 1);
459
460 EXPECT_EQ(result[1].mode, GERender::EffectMode::HPS);
461 EXPECT_EQ(result[1].range[0], 2);
462 EXPECT_EQ(result[1].range[1], 4);
463
464 EXPECT_EQ(result[2].mode, GERender::EffectMode::GE);
465 EXPECT_EQ(result[2].range[0], 5);
466 EXPECT_EQ(result[2].range[1], 6);
467
468 EXPECT_EQ(result[3].mode, GERender::EffectMode::HPS);
469 EXPECT_EQ(result[3].range[0], 7);
470 EXPECT_EQ(result[3].range[1], 9);
471
472 GTEST_LOG_(INFO) << "GERenderTest CategorizeRanges002 end";
473 }
474
475 /**
476 * @tc.name: CategorizeRanges003
477 * @tc.desc: Verify the CategorizeRanges
478 * @tc.type: FUNC
479 */
480 HWTEST_F(GERenderTest, CategorizeRanges003, TestSize.Level1)
481 {
482 GTEST_LOG_(INFO) << "GERenderTest CategorizeRanges003 start";
483
484 auto geRender = std::make_shared<GERender>();
485 if (!geRender) {
486 GTEST_LOG_(INFO) << "GERenderTest geRender is null";
487 return;
488 }
489 vector<IndexRange> hpsRanges = { { 2, 5 }, { 6, 8 } };
490 int32_t veSize = 10;
491 auto result = geRender->CategorizeRanges(hpsRanges, veSize);
492 EXPECT_EQ(result.size(), 4);
493
494 EXPECT_EQ(result[0].mode, GERender::EffectMode::GE);
495 EXPECT_EQ(result[0].range[0], 0);
496 EXPECT_EQ(result[0].range[1], 1);
497
498 EXPECT_EQ(result[1].mode, GERender::EffectMode::HPS);
499 EXPECT_EQ(result[1].range[0], 2);
500 EXPECT_EQ(result[1].range[1], 5);
501
502 EXPECT_EQ(result[2].mode, GERender::EffectMode::HPS);
503 EXPECT_EQ(result[2].range[0], 6);
504 EXPECT_EQ(result[2].range[1], 8);
505
506 EXPECT_EQ(result[3].mode, GERender::EffectMode::GE);
507 EXPECT_EQ(result[3].range[0], 9);
508 EXPECT_EQ(result[3].range[1], 9);
509
510 GTEST_LOG_(INFO) << "GERenderTest CategorizeRanges003 end";
511 }
512
513 /**
514 * @tc.name: CategorizeRanges004
515 * @tc.desc: Verify the CategorizeRanges
516 * @tc.type: FUNC
517 */
518 HWTEST_F(GERenderTest, CategorizeRanges004, TestSize.Level1)
519 {
520 GTEST_LOG_(INFO) << "GERenderTest CategorizeRanges004 start";
521
522 auto geRender = std::make_shared<GERender>();
523 if (!geRender) {
524 GTEST_LOG_(INFO) << "GERenderTest geRender is null";
525 return;
526 }
527 vector<IndexRange> hpsRanges = { { 0, 0 } };
528 int32_t veSize = 1;
529 auto result = geRender->CategorizeRanges(hpsRanges, veSize);
530 EXPECT_EQ(result.size(), 1);
531
532 EXPECT_EQ(result[0].mode, GERender::EffectMode::HPS);
533 EXPECT_EQ(result[0].range[0], 0);
534 EXPECT_EQ(result[0].range[1], 0);
535
536 GTEST_LOG_(INFO) << "GERenderTest CategorizeRanges004 end";
537 }
538
539 /**
540 * @tc.name: GenerateShaderFilters_001
541 * @tc.desc: Verify the GenerateShaderFilters
542 * @tc.type: FUNC
543 */
544 HWTEST_F(GERenderTest, GenerateShaderFilters_001, TestSize.Level1)
545 {
546 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFilters_001 start";
547
548 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_AI_BAR);
549 visualEffect->SetParam(Drawing::GE_FILTER_AI_BAR_LOW, 1.0f); // 1.0 AI bar blur low
550 visualEffect->SetParam(Drawing::GE_FILTER_AI_BAR_HIGH, 1.0f); // 1.0 AI bar blur high
551 visualEffect->SetParam(Drawing::GE_FILTER_AI_BAR_THRESHOLD, 1.0f); // 1.0 AI bar blur threshold
552 visualEffect->SetParam(Drawing::GE_FILTER_AI_BAR_OPACITY, 1.0f); // 1.0 AI bar blur opacity
553 visualEffect->SetParam(Drawing::GE_FILTER_AI_BAR_SATURATION, 1.0f); // 1.0 AI bar blur saturation
554 Drawing::GEVisualEffectContainer veContainer;
555 veContainer.AddToChainedFilter(visualEffect);
556 auto geRender = std::make_shared<GERender>();
557 auto shaderFilters = geRender->GenerateShaderFilters(veContainer);
558 EXPECT_NE(shaderFilters[0], nullptr);
559
560 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFilters_001 end";
561 }
562
563 /**
564 * @tc.name: GenerateShaderFilters_002
565 * @tc.desc: Verify the GenerateShaderFilters
566 * @tc.type: FUNC
567 */
568 HWTEST_F(GERenderTest, GenerateShaderFilters_002, TestSize.Level1)
569 {
570 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFilters_002 start";
571
572 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_GREY);
573 visualEffect->SetParam(Drawing::GE_FILTER_GREY_COEF_1, 1.0f); // 1.0 grey blur coff
574 visualEffect->SetParam(Drawing::GE_FILTER_GREY_COEF_2, 1.0f); // 1.0 grey blur coff
575 Drawing::GEVisualEffectContainer veContainer;
576 veContainer.AddToChainedFilter(visualEffect);
577 auto geRender = std::make_shared<GERender>();
578 auto shaderFilters = geRender->GenerateShaderFilters(veContainer);
579 EXPECT_NE(shaderFilters[0], nullptr);
580
581 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFilters_002 end";
582 }
583
584 /**
585 * @tc.name: GenerateShaderFilters_003
586 * @tc.desc: Verify the GenerateShaderFilters
587 * @tc.type: FUNC
588 */
589 HWTEST_F(GERenderTest, GenerateShaderFilters_003, TestSize.Level1)
590 {
591 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFilters_003 start";
592
593 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR);
594 visualEffect->SetParam(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR_DIRECTION, 1); // 1 blur directon
595 Drawing::GEVisualEffectContainer veContainer;
596 veContainer.AddToChainedFilter(visualEffect);
597 auto geRender = std::make_shared<GERender>();
598 auto shaderFilters = geRender->GenerateShaderFilters(veContainer);
599 EXPECT_NE(shaderFilters[0], nullptr);
600
601 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFilters_003 end";
602 }
603
604 /**
605 * @tc.name: GenerateShaderFilters_004
606 * @tc.desc: Verify the GenerateShaderFilters
607 * @tc.type: FUNC
608 */
609 HWTEST_F(GERenderTest, GenerateShaderFilters_004, TestSize.Level1)
610 {
611 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFilters_004 start";
612
613 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>("");
614 visualEffect->SetParam(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR_DIRECTION, 1); // 1 blur directon
615 Drawing::GEVisualEffectContainer veContainer;
616 veContainer.AddToChainedFilter(visualEffect);
617 auto geRender = std::make_shared<GERender>();
618 auto shaderFilters = geRender->GenerateShaderFilters(veContainer);
619 EXPECT_EQ(shaderFilters[0], nullptr);
620
621 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFilters_004 end";
622 }
623
624 /**
625 * @tc.name: GenerateShaderFilters_008
626 * @tc.desc: Verify the GenerateShaderFilters
627 * @tc.type: FUNC
628 */
629 HWTEST_F(GERenderTest, GenerateShaderFilters_008, TestSize.Level1)
630 {
631 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFilters_008 start";
632
633 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>("");
634 std::pair<float, float> factor = {1.0f, 1.0f};
635 visualEffect->SetParam(Drawing::GE_FILTER_DISPLACEMENT_DISTORT_FACTOR, factor); // 1 blur directon
636 Drawing::GEVisualEffectContainer veContainer;
637 veContainer.AddToChainedFilter(visualEffect);
638 auto geRender = std::make_shared<GERender>();
639 auto shaderFilters = geRender->GenerateShaderFilters(veContainer);
640 EXPECT_EQ(shaderFilters[0], nullptr);
641
642 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFilters_008 end";
643 }
644
645 /**
646 * @tc.name: GenerateShaderFiltersMESA_001
647 * @tc.desc: Verify the GenerateShaderFilters
648 * @tc.type: FUNC
649 */
650 HWTEST_F(GERenderTest, GenerateShaderFiltersMESA_001, TestSize.Level1)
651 {
652 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFiltersMESA_001 start";
653
654 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_MESA_BLUR);
655 visualEffect->SetParam(Drawing::GE_FILTER_MESA_BLUR_RADIUS, 1); // 1 blur directon
656 visualEffect->SetParam(Drawing::GE_FILTER_MESA_BLUR_GREY_COEF_1, 1.0f); // 1.0 grey blur coff
657 visualEffect->SetParam(Drawing::GE_FILTER_MESA_BLUR_GREY_COEF_2, 1.0f); // 1.0 grey blur coff
658 // 0, 0.0: tileMode and stretch params
659 visualEffect->SetParam(Drawing::GE_FILTER_MESA_BLUR_STRETCH_OFFSET_X, 0.0f);
660 visualEffect->SetParam(Drawing::GE_FILTER_MESA_BLUR_STRETCH_OFFSET_Y, 0.0f);
661 visualEffect->SetParam(Drawing::GE_FILTER_MESA_BLUR_STRETCH_OFFSET_Z, 0.0f);
662 visualEffect->SetParam(Drawing::GE_FILTER_MESA_BLUR_STRETCH_OFFSET_W, 0.0f);
663 visualEffect->SetParam(Drawing::GE_FILTER_MESA_BLUR_STRETCH_TILE_MODE, 0);
664 visualEffect->SetParam(Drawing::GE_FILTER_MESA_BLUR_STRETCH_WIDTH, 0.0f);
665 visualEffect->SetParam(Drawing::GE_FILTER_MESA_BLUR_STRETCH_HEIGHT, 0.0f);
666 Drawing::GEVisualEffectContainer veContainer;
667 veContainer.AddToChainedFilter(visualEffect);
668 auto geRender = std::make_shared<GERender>();
669 auto shaderFilters = geRender->GenerateShaderFilters(veContainer);
670 EXPECT_NE(shaderFilters[0], nullptr);
671
672 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFiltersMESA_001 end";
673 }
674
675 /**
676 * @tc.name: GenerateShaderFilters_005
677 * @tc.desc: Verify the GenerateShaderFilters
678 * @tc.type: FUNC
679 */
680 HWTEST_F(GERenderTest, GenerateShaderFilters_005, TestSize.Level1)
681 {
682 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFilters_005 start";
683
684 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_WATER_RIPPLE);
685 visualEffect->SetParam("PROGRESS", 0.5f);
686 visualEffect->SetParam("WAVE_NUM", 1.0f);
687 visualEffect->SetParam("RIPPLE_CENTER_X", 0.5f);
688 visualEffect->SetParam("RIPPLE_CENTER_Y", 0.5f);
689 Drawing::GEVisualEffectContainer veContainer;
690 veContainer.AddToChainedFilter(visualEffect);
691 auto geRender = std::make_shared<GERender>();
692 auto shaderFilters = geRender->GenerateShaderFilters(veContainer);
693 EXPECT_NE(shaderFilters[0], nullptr);
694
695 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFilters_005 end";
696 }
697
698 /**
699 * @tc.name: GenerateShaderFilters_006
700 * @tc.desc: Verify the GenerateShaderFilters
701 * @tc.type: FUNC
702 */
703 HWTEST_F(GERenderTest, GenerateShaderFilters_006, TestSize.Level1)
704 {
705 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFilters_006 start";
706
707 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_MAGNIFIER);
708 Drawing::GEVisualEffectContainer veContainer;
709 veContainer.AddToChainedFilter(visualEffect);
710 auto geRender = std::make_shared<GERender>();
711 auto shaderFilters = geRender->GenerateShaderFilters(veContainer);
712 EXPECT_NE(shaderFilters[0], nullptr);
713
714 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFilters_006 end";
715 }
716
717 /**
718 * @tc.name: GenerateShaderFilters_007
719 * @tc.desc: Verify the GenerateShaderFilters
720 * @tc.type: FUNC
721 */
722 HWTEST_F(GERenderTest, GenerateShaderFilters_007, TestSize.Level1)
723 {
724 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFilters_007 start";
725
726 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_COLOR_GRADIENT);
727 std::vector<float> colors = { 1.0f, 0.0f, 0.0f, 1.0f };
728 std::vector<float> positions = { 1.0f, 1.0f }; // 1.0, 1.0 is positions of xy params
729 std::vector<float> strengths = { 0.5f }; // 0.5 is strength params
730 visualEffect->SetParam(Drawing::GE_FILTER_COLOR_GRADIENT_COLOR, colors);
731 visualEffect->SetParam(Drawing::GE_FILTER_COLOR_GRADIENT_POSITION, positions);
732 visualEffect->SetParam(Drawing::GE_FILTER_COLOR_GRADIENT_STRENGTH, strengths);
733 Drawing::GEVisualEffectContainer veContainer;
734 veContainer.AddToChainedFilter(visualEffect);
735 auto geRender = std::make_shared<GERender>();
736 auto shaderFilters = geRender->GenerateShaderFilters(veContainer);
737 EXPECT_NE(shaderFilters[0], nullptr);
738
739 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFilters_007 end";
740 }
741
742 /**
743 * @tc.name: GenerateShaderFilters_009
744 * @tc.desc: Verify the GenerateShaderFilters
745 * @tc.type: FUNC
746 */
747 HWTEST_F(GERenderTest, GenerateShaderFilters_009, TestSize.Level1)
748 {
749 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFilters_009 start";
750
751 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_BEZIER_WARP);
752 Drawing::GEVisualEffectContainer veContainer;
753 veContainer.AddToChainedFilter(visualEffect);
754 auto geRender = std::make_shared<GERender>();
755 auto shaderFilters = geRender->GenerateShaderFilters(veContainer);
756 EXPECT_NE(shaderFilters[0], nullptr);
757
758 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFilters_009 end";
759 }
760
761 /**
762 * @tc.name: GenerateShaderFilters_010
763 * @tc.desc: Verify the GenerateShaderFilters
764 * @tc.type: FUNC
765 */
766 HWTEST_F(GERenderTest, GenerateShaderFilters_010, TestSize.Level1)
767 {
768 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFilters_010 start";
769
770 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_CONTENT_LIGHT);
771 Drawing::GEVisualEffectContainer veContainer;
772 veContainer.AddToChainedFilter(visualEffect);
773 auto geRender = std::make_shared<GERender>();
774 auto shaderFilters = geRender->GenerateShaderFilters(veContainer);
775 EXPECT_NE(shaderFilters[0], nullptr);
776
777 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFilters_010 end";
778 }
779
780 /**
781 * @tc.name: GenerateShaderFiltersEdgelight_001
782 * @tc.desc: Verify the GenerateShaderFilters
783 * @tc.type: FUNC
784 */
785 HWTEST_F(GERenderTest, GenerateShaderFiltersEdgelight_001, TestSize.Level1)
786 {
787 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFiltersEdgelight_001 start";
788
789 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_EDGE_LIGHT);
790 visualEffect->SetParam(Drawing::GE_FILTER_EDGE_LIGHT_ALPHA, 1.0);
791 Drawing::GEVisualEffectContainer veContainer;
792 veContainer.AddToChainedFilter(visualEffect);
793 auto geRender = std::make_shared<GERender>();
794 auto shaderFilters = geRender->GenerateShaderFilters(veContainer);
795 EXPECT_NE(shaderFilters[0], nullptr);
796
797 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFiltersEdgelight_001 end";
798 }
799
800 /**
801 * @tc.name: GenerateShaderFiltersDispersion_001
802 * @tc.desc: Verify the GenerateShaderFiltersDispersion
803 * @tc.type: FUNC
804 */
805 HWTEST_F(GERenderTest, GenerateShaderFiltersDispersion_001, TestSize.Level1)
806 {
807 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFiltersDispersion_001 start";
808
809 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_DISPERSION);
810 visualEffect->SetParam(Drawing::GE_FILTER_DISPERSION_OPACITY, 0.5f);
811 Drawing::GEVisualEffectContainer veContainer;
812 veContainer.AddToChainedFilter(visualEffect);
813 auto geRender = std::make_shared<GERender>();
814 auto shaderFilters = geRender->GenerateShaderFilters(veContainer);
815 EXPECT_EQ(shaderFilters[0], nullptr);
816
817 GTEST_LOG_(INFO) << "GERenderTest GenerateShaderFiltersDispersion_001 end";
818 }
819
820 /**
821 * @tc.name: ApplyHpsImageEffect_001
822 * @tc.desc: Verify the ApplyHpsImageEffect
823 * @tc.type: FUNC
824 */
825 HWTEST_F(GERenderTest, ApplyHpsImageEffect_001, TestSize.Level1)
826 {
827 GTEST_LOG_(INFO) << "GERenderTest ApplyHpsImageEffect_001 start";
828
829 Drawing::GEVisualEffectContainer veContainer;
830 const std::shared_ptr<Drawing::Image> image = nullptr;
831 std::shared_ptr<Drawing::Image> outImage = nullptr;
832 const Drawing::Rect src(1.0f, 1.0f, 1.0f, 1.0f);
833 const Drawing::Rect dst(1.0f, 1.0f, 1.0f, 1.0f);
834 float alpha = 1.0f;
835 std::shared_ptr<Drawing::ColorFilter> colorFilter;
836 uint32_t maskColor = 255;
837 float saturationForHPS = 1.0f;
838 float brightnessForHPS = 1.0f;
839 GERender::HpsGEImageEffectContext context = {image, src, dst, Drawing::SamplingOptions(), true, alpha,
840 colorFilter, maskColor, saturationForHPS, brightnessForHPS};
841
842 auto geRender = std::make_shared<GERender>();
843
844 /* image is nullptr*/
845 geRender->ApplyHpsImageEffect(canvas_, veContainer, context, outImage);
846
847 /* no filter*/
848 auto image2 = MakeImage(canvas_);
849 context.image = image2;
850 geRender->ApplyHpsImageEffect(canvas_, veContainer, context, outImage);
851
852 /* normal case */
853 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_EDGE_LIGHT);
854 visualEffect->SetParam(Drawing::GE_FILTER_EDGE_LIGHT_ALPHA, 1.0);
855 veContainer.AddToChainedFilter(visualEffect);
856 EXPECT_EQ(geRender->ApplyHpsImageEffect(canvas_, veContainer, context, outImage), false);
857
858 GTEST_LOG_(INFO) << "GERenderTest ApplyHpsImageEffect_001 end";
859 }
860
861 /**
862 * @tc.name: ApplyHpsGEImageEffect_001
863 * @tc.desc: Verify the ApplyHpsGEImageEffect
864 * @tc.type: FUNC
865 */
866 HWTEST_F(GERenderTest, ApplyHpsGEImageEffect_001, TestSize.Level1)
867 {
868 GTEST_LOG_(INFO) << "GERenderTest ApplyHpsGEImageEffect_001 start";
869
870 Drawing::GEVisualEffectContainer veContainer;
871 const std::shared_ptr<Drawing::Image> image = nullptr;
872 std::shared_ptr<Drawing::Image> outImage = nullptr;
873 const Drawing::Rect src(1.0f, 1.0f, 1.0f, 1.0f);
874 const Drawing::Rect dst(1.0f, 1.0f, 1.0f, 1.0f);
875 Drawing::Brush brush;
876
877 auto geRender = std::make_shared<GERender>();
878
879 /* image is nullptr */
880 GERender::HpsGEImageEffectContext context1 { image, src, dst, Drawing::SamplingOptions(), false };
881 geRender->ApplyHpsGEImageEffect(canvas_, veContainer, context1, outImage, brush);
882
883
884 /* no filter */
885 auto image2 = MakeImage(canvas_);
886 GERender::HpsGEImageEffectContext context2 { image2, src, dst, Drawing::SamplingOptions(), false };
887 geRender->ApplyHpsGEImageEffect(canvas_, veContainer, context2, outImage, brush);
888
889 /* normal case */
890 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_EDGE_LIGHT);
891 visualEffect->SetParam(Drawing::GE_FILTER_EDGE_LIGHT_ALPHA, 1.0);
892 veContainer.AddToChainedFilter(visualEffect);
893 GERender::HpsGEImageEffectContext context3 { image2, src, dst, Drawing::SamplingOptions(), false };
894 EXPECT_EQ(geRender->ApplyHpsGEImageEffect(canvas_, veContainer, context3, outImage, brush), false);
895
896 /* compatibility */
897 GERender::HpsGEImageEffectContext context4 { image2, src, dst, Drawing::SamplingOptions(), true };
898 outImage = nullptr;
899 EXPECT_EQ(geRender->ApplyHpsGEImageEffect(canvas_, veContainer, context3, outImage, brush), false);
900 EXPECT_EQ(outImage, nullptr);
901
902 GTEST_LOG_(INFO) << "GERenderTest ApplyHpsGEImageEffect_001 end";
903 }
904
905
906 /**
907 * @tc.name: GenerateShaderEffectTest_LightCave
908 * @tc.desc: Verify the GenerateShaderEffect with LightCave
909 * @tc.type: FUNC
910 */
911 HWTEST_F(GERenderTest, GenerateShaderEffectTest_LightCave, TestSize.Level1)
912 {
913 auto geVisualEffectImpl = std::make_shared<Drawing::GEVisualEffectImpl>("");
914 geVisualEffectImpl->SetFilterType(Drawing::GEVisualEffectImpl::FilterType::LIGHT_CAVE);
915 auto geRender = std::make_shared<GERender>();
916 auto shader = geRender->GenerateShaderEffect(geVisualEffectImpl);
917 EXPECT_EQ(shader, nullptr);
918
919 geVisualEffectImpl->MakeLightCaveParams();
920 shader = geRender->GenerateShaderEffect(geVisualEffectImpl);
921 EXPECT_EQ(shader, nullptr);
922 }
923 } // namespace GraphicsEffectEngine
924 } // namespace OHOS
925