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 "rspropertydrawableboundsgeometry_fuzzer.h"
17 
18 #include <climits>
19 #include <cstddef>
20 #include <cstdint>
21 #include <cstdio>
22 #include <cstdlib>
23 #include <fcntl.h>
24 #include <hilog/log.h>
25 #include <iostream>
26 #include <memory>
27 #include <securec.h>
28 #include <unistd.h>
29 
30 #include "draw/canvas.h"
31 #include "pipeline/rs_paint_filter_canvas.h"
32 #include "pipeline/rs_render_content.h"
33 #include "property/rs_properties.h"
34 #include "property/rs_property_drawable_bounds_geometry.h"
35 
36 namespace OHOS {
37 namespace Rosen {
38 using namespace Drawing;
39 
40 namespace {
41 const uint8_t* g_data = nullptr;
42 size_t g_size = 0;
43 size_t g_pos;
44 } // namespace
45 
46 template<class T>
GetData()47 T GetData()
48 {
49     T object {};
50     size_t objectSize = sizeof(object);
51     if (g_data == nullptr || objectSize > g_size - g_pos) {
52         return object;
53     }
54     errno_t ret = memcpy_s(&object, objectSize, g_data + g_pos, objectSize);
55     if (ret != EOK) {
56         return {};
57     }
58     g_pos += objectSize;
59     return object;
60 }
61 
DoDraw(const uint8_t * data,size_t size)62 bool DoDraw(const uint8_t* data, size_t size)
63 {
64     if (data == nullptr) {
65         return false;
66     }
67 
68     // initialize
69     g_data = data;
70     g_size = size;
71     g_pos = 0;
72 
73     int32_t width = GetData<int32_t>();
74     int32_t height = GetData<int32_t>();
75     Canvas canvas(width, height);
76     RSPaintFilterCanvas cacheCanvas(&canvas);
77     RSRenderContent content;
78     RSProperties properties;
79     auto rsBound = std::make_shared<RSBoundsGeometryDrawable>();
80     rsBound->Draw(content, cacheCanvas);
81     auto rsPoint = std::make_shared<RSPointLightDrawable>();
82     rsPoint->Draw(content, cacheCanvas);
83     auto mask = std::make_shared<RSMask>();
84     auto rssvgDomMaskDrawable = std::make_shared<RSSvgDomMaskDrawable>(mask);
85     rssvgDomMaskDrawable->Draw(content, cacheCanvas);
86     auto rsGradientMaskDrawable = std::make_shared<RSGradientMaskDrawable>(mask);
87     rsGradientMaskDrawable->Draw(content, cacheCanvas);
88     auto rsPathMaskDrawable = std::make_shared<RSPathMaskDrawable>(mask);
89     rsPathMaskDrawable->Draw(content, cacheCanvas);
90     auto rsPixelMapMaskDrawable = std::make_shared<RSPixelMapMaskDrawable>(mask);
91     rsPixelMapMaskDrawable->Draw(content, cacheCanvas);
92     auto rsColorfulShadowDrawable = std::make_shared<RSColorfulShadowDrawable>(properties);
93     rsColorfulShadowDrawable->Draw(content, cacheCanvas);
94     auto rsHardwareAccelerationShadowDrawable = std::make_shared<RSHardwareAccelerationShadowDrawable>(properties);
95     rsHardwareAccelerationShadowDrawable->Draw(content, cacheCanvas);
96     return true;
97 }
98 
DoGenerate(const uint8_t * data,size_t size)99 bool DoGenerate(const uint8_t* data, size_t size)
100 {
101     if (data == nullptr) {
102         return false;
103     }
104 
105     // initialize
106     g_data = data;
107     g_size = size;
108     g_pos = 0;
109 
110     RSRenderContent content;
111     RSBoundsGeometryDrawable::Generate(content);
112     RSShadowBaseDrawable::Generate(content);
113     Brush brush;
114     Pen pen;
115     RSBorderDrawable::Generate(content);
116     RSOutlineDrawable::Generate(content);
117     auto mask = std::make_shared<RSMask>();
118     RSMaskDrawable::Generate(content);
119     RSShadowBaseDrawable::Generate(content);
120     return true;
121 }
122 
DoRSBorderDRRectDrawable(const uint8_t * data,size_t size)123 bool DoRSBorderDRRectDrawable(const uint8_t* data, size_t size)
124 {
125     if (data == nullptr) {
126         return false;
127     }
128 
129     // initialize
130     g_data = data;
131     g_size = size;
132     g_pos = 0;
133 
134     uint32_t r = GetData<uint32_t>();
135     uint32_t g = GetData<uint32_t>();
136     uint32_t b = GetData<uint32_t>();
137     uint32_t a = GetData<uint32_t>();
138     Color c(r, g, b, a);
139     Brush brush(c);
140     int rgba = GetData<int>();
141     Pen pen(rgba);
142     RSProperties properties;
143     auto rsBorderDrrect = std::make_shared<RSBorderDRRectDrawable>(std::move(brush), std::move(pen), properties, true);
144     RSRenderContent content;
145     int32_t width = GetData<int32_t>();
146     int32_t height = GetData<int32_t>();
147     Canvas canvas(width, height);
148     RSPaintFilterCanvas cacheCanvas(&canvas);
149     rsBorderDrrect->Draw(content, cacheCanvas);
150     rsBorderDrrect->OnBoundsChange(properties);
151     return true;
152 }
153 
DoRSBorderFourLineDrawable(const uint8_t * data,size_t size)154 bool DoRSBorderFourLineDrawable(const uint8_t* data, size_t size)
155 {
156     if (data == nullptr) {
157         return false;
158     }
159 
160     // initialize
161     g_data = data;
162     g_size = size;
163     g_pos = 0;
164 
165     uint32_t r = GetData<uint32_t>();
166     uint32_t g = GetData<uint32_t>();
167     uint32_t b = GetData<uint32_t>();
168     uint32_t a = GetData<uint32_t>();
169     Color c(r, g, b, a);
170     Brush brush(c);
171     Drawing::Pen pen;
172     pen.SetAntiAlias(true);
173     brush.SetAntiAlias(true);
174     RSProperties properties;
175     auto rsBorderFourLineDrawable =
176         std::make_shared<RSBorderFourLineDrawable>(std::move(brush), std::move(pen), properties, true);
177     RSRenderContent content;
178     int32_t width = GetData<int32_t>();
179     int32_t height = GetData<int32_t>();
180     Canvas canvas(width, height);
181     return true;
182 }
183 
DoRSShadowDrawable(const uint8_t * data,size_t size)184 bool DoRSShadowDrawable(const uint8_t* data, size_t size)
185 {
186     if (data == nullptr) {
187         return false;
188     }
189 
190     // initialize
191     g_data = data;
192     g_size = size;
193     g_pos = 0;
194     RSProperties properties;
195     auto rsShadowDrawable = std::make_shared<RSShadowDrawable>(properties);
196     RSRenderContent content;
197     int l = GetData<int>();
198     int t = GetData<int>();
199     int r = GetData<int>();
200     int b = GetData<int>();
201     OHOS::Rosen::Drawing::RectI deviceClipBounds(l, t, r, b);
202     Path skPath;
203     Matrix matrix;
204     int32_t width = GetData<int32_t>();
205     int32_t height = GetData<int32_t>();
206     Canvas canvas(width, height);
207     RSPaintFilterCanvas cacheCanvas(&canvas);
208     rsShadowDrawable->Draw(content, cacheCanvas);
209     return true;
210 }
211 
DoRSDynamicLightUpDrawable(const uint8_t * data,size_t size)212 bool DoRSDynamicLightUpDrawable(const uint8_t* data, size_t size)
213 {
214     if (data == nullptr) {
215         return false;
216     }
217 
218     // initialize
219     g_data = data;
220     g_size = size;
221     g_pos = 0;
222 
223     RSRenderContent content;
224     int32_t width = GetData<int32_t>();
225     int32_t height = GetData<int32_t>();
226     Canvas canvas(width, height);
227     RSPaintFilterCanvas cacheCanvas(&canvas);
228 
229     auto rsDynamicLightUpDrawable = std::make_shared<RSDynamicLightUpDrawable>();
230     RSDynamicLightUpDrawable::Generate(content);
231     rsDynamicLightUpDrawable->Draw(content, cacheCanvas);
232     rsDynamicLightUpDrawable->Update(content);
233     return true;
234 }
235 
DoRSBinarizationDrawable(const uint8_t * data,size_t size)236 bool DoRSBinarizationDrawable(const uint8_t* data, size_t size)
237 {
238     if (data == nullptr) {
239         return false;
240     }
241 
242     // initialize
243     g_data = data;
244     g_size = size;
245     g_pos = 0;
246 
247     auto rsBinarizationDrawable = std::make_shared<RSBinarizationDrawable>();
248     RSRenderContent content;
249     int32_t width = GetData<int32_t>();
250     int32_t height = GetData<int32_t>();
251     Canvas canvas(width, height);
252     RSPaintFilterCanvas cacheCanvas(&canvas);
253     rsBinarizationDrawable->Draw(content, cacheCanvas);
254     RSBinarizationDrawable::Generate(content);
255     return true;
256 }
257 
DoRSLightUpEffectDrawable(const uint8_t * data,size_t size)258 bool DoRSLightUpEffectDrawable(const uint8_t* data, size_t size)
259 {
260     if (data == nullptr) {
261         return false;
262     }
263 
264     // initialize
265     g_data = data;
266     g_size = size;
267     g_pos = 0;
268 
269     auto rsLightUpEffectDrawable = std::make_shared<RSLightUpEffectDrawable>();
270     RSRenderContent content;
271     int32_t width = GetData<int32_t>();
272     int32_t height = GetData<int32_t>();
273     Canvas canvas(width, height);
274     RSPaintFilterCanvas cacheCanvas(&canvas);
275     rsLightUpEffectDrawable->Draw(content, cacheCanvas);
276     RSLightUpEffectDrawable::Generate(content);
277     rsLightUpEffectDrawable->Update(content);
278     return true;
279 }
280 
DoRSDynamicDimDrawable(const uint8_t * data,size_t size)281 bool DoRSDynamicDimDrawable(const uint8_t* data, size_t size)
282 {
283     if (data == nullptr) {
284         return false;
285     }
286 
287     // initialize
288     g_data = data;
289     g_size = size;
290     g_pos = 0;
291 
292     auto rsDynamicDimDrawable = std::make_shared<RSDynamicDimDrawable>();
293     RSRenderContent content;
294     int32_t width = GetData<int32_t>();
295     int32_t height = GetData<int32_t>();
296     Canvas canvas(width, height);
297     RSPaintFilterCanvas cacheCanvas(&canvas);
298     rsDynamicDimDrawable->Draw(content, cacheCanvas);
299     RSDynamicDimDrawable::Generate(content);
300     rsDynamicDimDrawable->Update(content);
301     return true;
302 }
303 
DoRSBackgroundFilterDrawable(const uint8_t * data,size_t size)304 bool DoRSBackgroundFilterDrawable(const uint8_t* data, size_t size)
305 {
306     if (data == nullptr) {
307         return false;
308     }
309 
310     // initialize
311     g_data = data;
312     g_size = size;
313     g_pos = 0;
314 
315     auto rsBackgroundFilterDrawable = std::make_shared<RSBackgroundFilterDrawable>();
316     RSRenderContent content;
317     int32_t width = GetData<int32_t>();
318     int32_t height = GetData<int32_t>();
319     Canvas canvas(width, height);
320     RSPaintFilterCanvas cacheCanvas(&canvas);
321     rsBackgroundFilterDrawable->Draw(content, cacheCanvas);
322     RSBackgroundFilterDrawable::Generate(content);
323     rsBackgroundFilterDrawable->Update(content);
324     return true;
325 }
326 
DoRSForegroundFilterDrawable(const uint8_t * data,size_t size)327 bool DoRSForegroundFilterDrawable(const uint8_t* data, size_t size)
328 {
329     if (data == nullptr) {
330         return false;
331     }
332 
333     // initialize
334     g_data = data;
335     g_size = size;
336     g_pos = 0;
337 
338     auto rsForegroundFilterDrawable = std::make_shared<RSForegroundFilterDrawable>();
339     RSRenderContent content;
340     int32_t width = GetData<int32_t>();
341     int32_t height = GetData<int32_t>();
342     Canvas canvas(width, height);
343     RSPaintFilterCanvas cacheCanvas(&canvas);
344     rsForegroundFilterDrawable->Draw(content, cacheCanvas);
345     RSForegroundFilterDrawable::Generate(content);
346     rsForegroundFilterDrawable->Update(content);
347     return true;
348 }
349 
DoRSEffectDataGenerateDrawable(const uint8_t * data,size_t size)350 bool DoRSEffectDataGenerateDrawable(const uint8_t* data, size_t size)
351 {
352     if (data == nullptr) {
353         return false;
354     }
355 
356     // initialize
357     g_data = data;
358     g_size = size;
359     g_pos = 0;
360 
361     auto rsEffectDataGenerateDrawable = std::make_shared<RSEffectDataGenerateDrawable>();
362     RSRenderContent content;
363     int32_t width = GetData<int32_t>();
364     int32_t height = GetData<int32_t>();
365     Canvas canvas(width, height);
366     RSPaintFilterCanvas cacheCanvas(&canvas);
367     rsEffectDataGenerateDrawable->Draw(content, cacheCanvas);
368     rsEffectDataGenerateDrawable->Update(content);
369     return true;
370 }
DoRSEffectDataApplyDrawable(const uint8_t * data,size_t size)371 bool DoRSEffectDataApplyDrawable(const uint8_t* data, size_t size)
372 {
373     if (data == nullptr) {
374         return false;
375     }
376 
377     // initialize
378     g_data = data;
379     g_size = size;
380     g_pos = 0;
381 
382     auto rsEffectDataApplyDrawable = std::make_shared<RSEffectDataApplyDrawable>();
383     RSRenderContent content;
384     int32_t width = GetData<int32_t>();
385     int32_t height = GetData<int32_t>();
386     Canvas canvas(width, height);
387     RSPaintFilterCanvas cacheCanvas(&canvas);
388     rsEffectDataApplyDrawable->Draw(content, cacheCanvas);
389     RSEffectDataApplyDrawable::Generate(content);
390     rsEffectDataApplyDrawable->Update(content);
391     return true;
392 }
393 
DoRSForegroundColorDrawable(const uint8_t * data,size_t size)394 bool DoRSForegroundColorDrawable(const uint8_t* data, size_t size)
395 {
396     if (data == nullptr) {
397         return false;
398     }
399 
400     // initialize
401     g_data = data;
402     g_size = size;
403     g_pos = 0;
404 
405     uint32_t r = GetData<uint32_t>();
406     uint32_t g = GetData<uint32_t>();
407     uint32_t b = GetData<uint32_t>();
408     uint32_t a = GetData<uint32_t>();
409     Color c(r, g, b, a);
410     Brush brush(c);
411     auto rsForegroundColorDrawable = std::make_shared<RSForegroundColorDrawable>(std::move(brush));
412     RSRenderContent content;
413     int32_t width = GetData<int32_t>();
414     int32_t height = GetData<int32_t>();
415     Canvas canvas(width, height);
416     RSPaintFilterCanvas cacheCanvas(&canvas);
417     rsForegroundColorDrawable->Draw(content, cacheCanvas);
418     RSForegroundColorDrawable::Generate(content);
419     rsForegroundColorDrawable->Update(content);
420     return true;
421 }
422 
DoRSParticleDrawable(const uint8_t * data,size_t size)423 bool DoRSParticleDrawable(const uint8_t* data, size_t size)
424 {
425     if (data == nullptr) {
426         return false;
427     }
428 
429     // initialize
430     g_data = data;
431     g_size = size;
432     g_pos = 0;
433 
434     auto rsParticleDrawable = std::make_shared<RSParticleDrawable>();
435     RSRenderContent content;
436     int32_t width = GetData<int32_t>();
437     int32_t height = GetData<int32_t>();
438     Canvas canvas(width, height);
439     RSPaintFilterCanvas cacheCanvas(&canvas);
440     rsParticleDrawable->Draw(content, cacheCanvas);
441     RSParticleDrawable::Generate(content);
442     rsParticleDrawable->Update(content);
443     return true;
444 }
445 
DoRSPixelStretchDrawable(const uint8_t * data,size_t size)446 bool DoRSPixelStretchDrawable(const uint8_t* data, size_t size)
447 {
448     if (data == nullptr) {
449         return false;
450     }
451 
452     // initialize
453     g_data = data;
454     g_size = size;
455     g_pos = 0;
456 
457     auto rsPixelStretchDrawable = std::make_shared<RSPixelStretchDrawable>();
458     RSRenderContent content;
459     int32_t width = GetData<int32_t>();
460     int32_t height = GetData<int32_t>();
461     Canvas canvas(width, height);
462     RSPaintFilterCanvas cacheCanvas(&canvas);
463     rsPixelStretchDrawable->Draw(content, cacheCanvas);
464     RSPixelStretchDrawable::Generate(content);
465     rsPixelStretchDrawable->Update(content);
466     return true;
467 }
468 
DoRSBackgroundDrawable(const uint8_t * data,size_t size)469 bool DoRSBackgroundDrawable(const uint8_t* data, size_t size)
470 {
471     if (data == nullptr) {
472         return false;
473     }
474 
475     // initialize
476     g_data = data;
477     g_size = size;
478     g_pos = 0;
479 
480     auto rsBackgroundDrawable = std::make_shared<RSBackgroundDrawable>();
481     RSRenderContent content;
482     int32_t width = GetData<int32_t>();
483     int32_t height = GetData<int32_t>();
484     Canvas canvas(width, height);
485     RSPaintFilterCanvas cacheCanvas(&canvas);
486     rsBackgroundDrawable->Draw(content, cacheCanvas);
487     return true;
488 }
489 
DoRSBackgroundColorDrawable(const uint8_t * data,size_t size)490 bool DoRSBackgroundColorDrawable(const uint8_t* data, size_t size)
491 {
492     if (data == nullptr) {
493         return false;
494     }
495 
496     // initialize
497     g_data = data;
498     g_size = size;
499     g_pos = 0;
500 
501     uint32_t r = GetData<uint32_t>();
502     uint32_t g = GetData<uint32_t>();
503     uint32_t b = GetData<uint32_t>();
504     uint32_t a = GetData<uint32_t>();
505     Color c(r, g, b, a);
506     auto rsBackgroundColorDrawable = std::make_shared<RSBackgroundColorDrawable>(c);
507     RSRenderContent content;
508     rsBackgroundColorDrawable->Update(content);
509     RSBackgroundColorDrawable::Generate(content);
510     return true;
511 }
512 
DoRSBackgroundShaderDrawable(const uint8_t * data,size_t size)513 bool DoRSBackgroundShaderDrawable(const uint8_t* data, size_t size)
514 {
515     if (data == nullptr) {
516         return false;
517     }
518 
519     // initialize
520     g_data = data;
521     g_size = size;
522     g_pos = 0;
523     auto filter = std::make_shared<ShaderEffect>();
524     auto rsBackgroundShaderDrawable = std::make_shared<RSBackgroundShaderDrawable>(filter);
525     RSRenderContent content;
526     rsBackgroundShaderDrawable->Update(content);
527     RSBackgroundShaderDrawable::Generate(content);
528     return true;
529 }
530 
DoRSBackgroundImageDrawable(const uint8_t * data,size_t size)531 bool DoRSBackgroundImageDrawable(const uint8_t* data, size_t size)
532 {
533     if (data == nullptr) {
534         return false;
535     }
536 
537     // initialize
538     g_data = data;
539     g_size = size;
540     g_pos = 0;
541     auto rsBackgroundImageDrawable = std::make_shared<RSBackgroundImageDrawable>();
542     RSRenderContent content;
543     RSBackgroundImageDrawable::Generate(content);
544     int32_t width = GetData<int32_t>();
545     int32_t height = GetData<int32_t>();
546     Canvas canvas(width, height);
547     RSPaintFilterCanvas cacheCanvas(&canvas);
548     rsBackgroundImageDrawable->Update(content);
549     return true;
550 }
551 
DoRSBlendSaveLayerDrawable(const uint8_t * data,size_t size)552 bool DoRSBlendSaveLayerDrawable(const uint8_t* data, size_t size)
553 {
554     if (data == nullptr) {
555         return false;
556     }
557 
558     // initialize
559     g_data = data;
560     g_size = size;
561     g_pos = 0;
562 
563     auto rsBlendSaveLayerDrawable = std::make_shared<RSBlendSaveLayerDrawable>(2);
564     RSRenderContent content;
565     int32_t width = GetData<int32_t>();
566     int32_t height = GetData<int32_t>();
567     Canvas canvas(width, height);
568     RSPaintFilterCanvas cacheCanvas(&canvas);
569     rsBlendSaveLayerDrawable->Draw(content, cacheCanvas);
570     return true;
571 }
572 
DoRSBlendFastDrawable(const uint8_t * data,size_t size)573 bool DoRSBlendFastDrawable(const uint8_t* data, size_t size)
574 {
575     if (data == nullptr) {
576         return false;
577     }
578 
579     // initialize
580     g_data = data;
581     g_size = size;
582     g_pos = 0;
583 
584     auto rsBlendFastDrawable = std::make_shared<RSBlendFastDrawable>(2);
585     RSRenderContent content;
586     int32_t width = GetData<int32_t>();
587     int32_t height = GetData<int32_t>();
588     Canvas canvas(width, height);
589     RSPaintFilterCanvas cacheCanvas(&canvas);
590     rsBlendFastDrawable->Draw(content, cacheCanvas);
591     return true;
592 }
593 
DoRSBlendSaveLayerRestoreDrawable(const uint8_t * data,size_t size)594 bool DoRSBlendSaveLayerRestoreDrawable(const uint8_t* data, size_t size)
595 {
596     if (data == nullptr) {
597         return false;
598     }
599 
600     // initialize
601     g_data = data;
602     g_size = size;
603     g_pos = 0;
604 
605     auto rsBlendSaveLayerRestoreDrawable = std::make_shared<RSBlendSaveLayerRestoreDrawable>();
606     RSRenderContent content;
607     int32_t width = GetData<int32_t>();
608     int32_t height = GetData<int32_t>();
609     Canvas canvas(width, height);
610     RSPaintFilterCanvas cacheCanvas(&canvas);
611     rsBlendSaveLayerRestoreDrawable->Draw(content, cacheCanvas);
612     return true;
613 }
614 
DoRSBlendFastRestoreDrawable(const uint8_t * data,size_t size)615 bool DoRSBlendFastRestoreDrawable(const uint8_t* data, size_t size)
616 {
617     if (data == nullptr) {
618         return false;
619     }
620 
621     // initialize
622     g_data = data;
623     g_size = size;
624     g_pos = 0;
625 
626     auto rsBlendFastRestoreDrawable = std::make_shared<RSBlendFastRestoreDrawable>();
627     RSRenderContent content;
628     int32_t width = GetData<int32_t>();
629     int32_t height = GetData<int32_t>();
630     Canvas canvas(width, height);
631     RSPaintFilterCanvas cacheCanvas(&canvas);
632     rsBlendFastRestoreDrawable->Draw(content, cacheCanvas);
633     return true;
634 }
635 } // namespace Rosen
636 } // namespace OHOS
637 
638 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)639 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
640 {
641     /* Run your code on data */
642     OHOS::Rosen::DoDraw(data, size);
643     OHOS::Rosen::DoGenerate(data, size);
644     OHOS::Rosen::DoRSBorderDRRectDrawable(data, size);
645     OHOS::Rosen::DoRSBorderFourLineDrawable(data, size);
646     OHOS::Rosen::DoRSShadowDrawable(data, size);
647     OHOS::Rosen::DoRSDynamicLightUpDrawable(data, size);
648     OHOS::Rosen::DoRSBinarizationDrawable(data, size);
649     OHOS::Rosen::DoRSLightUpEffectDrawable(data, size);
650     OHOS::Rosen::DoRSDynamicDimDrawable(data, size);
651     OHOS::Rosen::DoRSBackgroundFilterDrawable(data, size);
652     OHOS::Rosen::DoRSForegroundFilterDrawable(data, size);
653     OHOS::Rosen::DoRSEffectDataGenerateDrawable(data, size);
654     OHOS::Rosen::DoRSEffectDataApplyDrawable(data, size);
655     OHOS::Rosen::DoRSForegroundColorDrawable(data, size);
656     OHOS::Rosen::DoRSParticleDrawable(data, size);
657     OHOS::Rosen::DoRSPixelStretchDrawable(data, size);
658     OHOS::Rosen::DoRSBackgroundDrawable(data, size);
659     OHOS::Rosen::DoRSBackgroundColorDrawable(data, size);
660     OHOS::Rosen::DoRSBackgroundShaderDrawable(data, size);
661     OHOS::Rosen::DoRSBackgroundImageDrawable(data, size);
662     OHOS::Rosen::DoRSBlendSaveLayerDrawable(data, size);
663     OHOS::Rosen::DoRSBlendFastDrawable(data, size);
664     OHOS::Rosen::DoRSBlendSaveLayerRestoreDrawable(data, size);
665     OHOS::Rosen::DoRSBlendFastRestoreDrawable(data, size);
666     return 0;
667 }