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