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 "draw/canvas.h"
17 #include "ge_render_fuzzer.h"
18 #include "get_object.h"
19 #include "ge_render.h"
20 #include <fuzzer/FuzzedDataProvider.h>
21
22 namespace OHOS {
23 namespace GraphicsEffectEngine {
24
25 using namespace Rosen;
26
27 // fuzz src & dst for DrawImageEffect
GERenderFuzzTest001()28 bool GERenderFuzzTest001()
29 {
30 auto geRender = std::make_shared<GERender>();
31 Drawing::Canvas canvas;
32 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_KAWASE_BLUR);
33 static constexpr int32_t radius = 10;
34 visualEffect->SetParam("KAWASE_BLUR_RADIUS", radius);
35 auto veContainer = std::make_shared<Drawing::GEVisualEffectContainer>();
36 veContainer->AddToChainedFilter(visualEffect);
37 std::shared_ptr<Drawing::Image> image = std::make_shared<Drawing::Image>();
38 Drawing::SamplingOptions sampling;
39
40 float fLeft = GETest::GetPlainData<float>();
41 float fTop = GETest::GetPlainData<float>();
42 float fWidth = GETest::GetPlainData<float>();
43 float fHeight = GETest::GetPlainData<float>();
44 Drawing::Rect src{fLeft, fTop, fWidth, fHeight};
45 Drawing::Rect dst = GETest::GetPlainData<Drawing::Rect>();
46
47 geRender->DrawImageEffect(canvas, *veContainer, image, src, dst, sampling);
48 return true;
49 }
50
51 // fuzz src & dst for ApplyImageEffect
GERenderFuzzTest002()52 std::shared_ptr<Drawing::Image> GERenderFuzzTest002()
53 {
54 auto geRender = std::make_shared<GERender>();
55 Drawing::Canvas canvas;
56 auto visualEffect = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_KAWASE_BLUR);
57 auto veContainer = std::make_shared<Drawing::GEVisualEffectContainer>();
58 veContainer->AddToChainedFilter(visualEffect);
59 std::shared_ptr<Drawing::Image> image = std::make_shared<Drawing::Image>();
60 Drawing::SamplingOptions sampling;
61
62 float fLeft = GETest::GetPlainData<float>();
63 float fTop = GETest::GetPlainData<float>();
64 float fWidth = GETest::GetPlainData<float>();
65 float fHeight = GETest::GetPlainData<float>();
66 Drawing::Rect src{fLeft, fTop, fWidth, fHeight};
67 Drawing::Rect dst = GETest::GetPlainData<Drawing::Rect>();
68
69 auto resImg = geRender->ApplyImageEffect(canvas, *veContainer, image, src, dst, sampling);
70 return resImg;
71 }
72
GERenderFuzzTest003(const uint8_t * data,size_t size)73 std::shared_ptr<Drawing::Image> GERenderFuzzTest003(const uint8_t *data, size_t size)
74 {
75 FuzzedDataProvider fdp(data, size);
76
77 auto geRender = std::make_shared<GERender>();
78 Drawing::Canvas canvas;
79 auto veContainer = std::make_shared<Drawing::GEVisualEffectContainer>();
80 std::shared_ptr<Drawing::Image> image = nullptr;
81 Drawing::Rect src{0.0, 0.0, 100.0, 100.0};
82 Drawing::Rect dst{0.0, 0.0, 100.0, 100.0};
83 Drawing::SamplingOptions sampling;
84 auto resImg = geRender->ApplyImageEffect(canvas, *veContainer, image, src, dst, sampling);
85 return resImg;
86 }
87
GERenderFuzzTest004()88 std::shared_ptr<Drawing::Image> GERenderFuzzTest004()
89 {
90 auto geRender = std::make_shared<GERender>();
91 auto veContainer = std::make_shared<Drawing::GEVisualEffectContainer>();
92 auto visualEffectGrey = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_GREY);
93 auto visualEffectAIBar = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_AI_BAR);
94 auto visualEffectLinear = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR);
95
96 visualEffectGrey->SetParam("GREY_COEF_1", 0.0f);
97 visualEffectGrey->SetParam("GREY_COEF_2", 0.0f);
98
99 Drawing::Matrix matrix;
100 std::vector<std::pair<float, float>> fractionStops = {{0.0, 0.0}, {1.0, 1.0}};
101 visualEffectLinear->SetParam("BLURRADIUS", 0.0f);
102 visualEffectLinear->SetParam("GEOWIDTH", 0.0f);
103 visualEffectLinear->SetParam("GEOHEIGHT", 0.0f);
104 visualEffectLinear->SetParam("TRANX", 0.0f);
105 visualEffectLinear->SetParam("TRANY", 0.0f);
106 visualEffectLinear->SetParam("CANVASMAT", matrix);
107 visualEffectLinear->SetParam("FRACTIONSTOPS", fractionStops);
108 visualEffectLinear->SetParam("DIRECTION", 0);
109 visualEffectLinear->SetParam("ISOFFSCREEN", true);
110
111 veContainer->AddToChainedFilter(visualEffectGrey);
112 veContainer->AddToChainedFilter(visualEffectAIBar);
113 veContainer->AddToChainedFilter(visualEffectLinear);
114
115 Drawing::Canvas canvas;
116 std::shared_ptr<Drawing::Image> image = std::make_shared<Drawing::Image>();
117 Drawing::Rect src = GETest::GetPlainData<Drawing::Rect>();
118 Drawing::Rect dst = GETest::GetPlainData<Drawing::Rect>();
119 Drawing::SamplingOptions sampling;
120 auto resImg = geRender->ApplyImageEffect(canvas, *veContainer, image, src, dst, sampling);
121 return resImg;
122 }
123
GERenderFuzzTest005()124 std::shared_ptr<Drawing::Image> GERenderFuzzTest005()
125 {
126 auto geRender = std::make_shared<GERender>();
127 auto veContainer = std::make_shared<Drawing::GEVisualEffectContainer>();
128 auto visualEffectMagnifier = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_MAGNIFIER);
129
130 visualEffectMagnifier->SetParam("FACTOR", 0.0f);
131 visualEffectMagnifier->SetParam("WIDTH", 0.0f);
132 visualEffectMagnifier->SetParam("HEIGHT", 0.0f);
133 visualEffectMagnifier->SetParam("CORNERRADIUS", 0.0f);
134 visualEffectMagnifier->SetParam("BORDERWIDTH", 0.0f);
135 visualEffectMagnifier->SetParam("SHADOWOFFSETX", 0.0f);
136 visualEffectMagnifier->SetParam("SHADOWOFFSETY", 0.0f);
137 visualEffectMagnifier->SetParam("SHADOWSIZE", 0.0f);
138 visualEffectMagnifier->SetParam("SHADOWSTRENGTH", 0.0f);
139 visualEffectMagnifier->SetParam("GRADIENTMASKCOLOR1", 0x00000000);
140 visualEffectMagnifier->SetParam("GRADIENTMASKCOLOR2", 0x00000000);
141 visualEffectMagnifier->SetParam("OUTERCONTOURCOLOR1", 0x00000000);
142 visualEffectMagnifier->SetParam("OUTERCONTOURCOLOR2", 0x00000000);
143 visualEffectMagnifier->SetParam("ROTATEDEGREE", 0);
144
145 veContainer->AddToChainedFilter(visualEffectMagnifier);
146
147 Drawing::Canvas canvas;
148 std::shared_ptr<Drawing::Image> image = std::make_shared<Drawing::Image>();
149 Drawing::Rect src = GETest::GetPlainData<Drawing::Rect>();
150 Drawing::Rect dst = GETest::GetPlainData<Drawing::Rect>();
151 Drawing::SamplingOptions sampling;
152
153 auto resImg = geRender->ApplyImageEffect(canvas, *veContainer, image, src, dst, sampling);
154 return resImg;
155 }
156
GERenderFuzzTest006()157 std::shared_ptr<Drawing::Image> GERenderFuzzTest006()
158 {
159 auto geRender = std::make_shared<GERender>();
160 auto veContainer = std::make_shared<Drawing::GEVisualEffectContainer>();
161 auto visualEffectWaterRipple = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_WATER_RIPPLE);
162 auto visualEffectMesa = std::make_shared<Drawing::GEVisualEffect>(Drawing::GE_FILTER_MESA_BLUR);
163
164 visualEffectWaterRipple->SetParam("PROGRESS", 0.0f);
165 visualEffectWaterRipple->SetParam("WAVE_NUM", 0);
166 visualEffectWaterRipple->SetParam("RIPPLE_CENTER_X", 0.0f);
167 visualEffectWaterRipple->SetParam("RIPPLE_CENTER_Y", 0.0f);
168 visualEffectWaterRipple->SetParam("RIPPLE_MODE", 0);
169
170 visualEffectMesa->SetParam("MESA_BLUR_RADIUS", 0);
171 visualEffectMesa->SetParam("MESA_BLUR_GREY_COEF_1", 0.0f);
172 visualEffectMesa->SetParam("MESA_BLUR_GREY_COEF_2", 0.0f);
173 visualEffectMesa->SetParam("OFFSET_X", 0.f);
174 visualEffectMesa->SetParam("OFFSET_Y", 0.f);
175 visualEffectMesa->SetParam("OFFSET_Z", 0.f);
176 visualEffectMesa->SetParam("OFFSET_W", 0.f);
177 visualEffectMesa->SetParam("TILE_MODE", 0);
178 visualEffectMesa->SetParam("WIDTH", 0.f);
179 visualEffectMesa->SetParam("HEIGHT", 0.f);
180
181 veContainer->AddToChainedFilter(visualEffectWaterRipple);
182 veContainer->AddToChainedFilter(visualEffectMesa);
183
184 Drawing::Canvas canvas;
185 std::shared_ptr<Drawing::Image> image = std::make_shared<Drawing::Image>();
186 Drawing::Rect src = GETest::GetPlainData<Drawing::Rect>();
187 Drawing::Rect dst = GETest::GetPlainData<Drawing::Rect>();
188 Drawing::SamplingOptions sampling;
189
190 auto resImg = geRender->ApplyImageEffect(canvas, *veContainer, image, src, dst, sampling);
191 return resImg;
192 }
193
194 } // namespace GraphicsEffectEngine
195 } // namespace OHOS
196
197 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)198 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
199 {
200 if (data == nullptr) {
201 return 0;
202 }
203 // initialize
204 OHOS::Rosen::GETest::g_data = data;
205 OHOS::Rosen::GETest::g_size = size;
206 OHOS::Rosen::GETest::g_pos = 0;
207 /* Run your code on data */
208 OHOS::GraphicsEffectEngine::GERenderFuzzTest001();
209 OHOS::GraphicsEffectEngine::GERenderFuzzTest002();
210 OHOS::GraphicsEffectEngine::GERenderFuzzTest003(data, size);
211 OHOS::GraphicsEffectEngine::GERenderFuzzTest004();
212 OHOS::GraphicsEffectEngine::GERenderFuzzTest005();
213 OHOS::GraphicsEffectEngine::GERenderFuzzTest006();
214 return 0;
215 }
216