1 /*
2 * Copyright (c) 2021-2025 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 "impl_factory.h"
17
18 #include "effect/runtime_effect.h"
19 #include "skia_adapter/skia_impl_factory.h"
20 #include "utils/matrix.h"
21 #include "utils/system_properties.h"
22 #ifdef ENABLE_DDGR_OPTIMIZE
23 #include "ddgr_impl_factory.h"
24 #endif
25 namespace OHOS {
26 namespace Rosen {
27 namespace Drawing {
28 using EngineImplFactory = SkiaImplFactory;
29
CreateCoreCanvasImpl()30 std::unique_ptr<CoreCanvasImpl> ImplFactory::CreateCoreCanvasImpl()
31 {
32 #ifdef ENABLE_DDGR_OPTIMIZE
33 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
34 return DDGRImplFactory::CreateCoreCanvas();
35 }
36 #endif
37 return EngineImplFactory::CreateCoreCanvas();
38 }
39
CreateCoreCanvasImpl(DrawingType type)40 std::unique_ptr<CoreCanvasImpl> ImplFactory::CreateCoreCanvasImpl(DrawingType type)
41 {
42 #ifdef ENABLE_DDGR_OPTIMIZE
43 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
44 return DDGRImplFactory::CreateCoreCanvas();
45 }
46 #endif
47 return EngineImplFactory::CreateCoreCanvas(type);
48 }
49
CreateCoreCanvasImpl(int32_t width,int32_t height)50 std::unique_ptr<CoreCanvasImpl> ImplFactory::CreateCoreCanvasImpl(int32_t width, int32_t height)
51 {
52 #ifdef ENABLE_DDGR_OPTIMIZE
53 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
54 return DDGRImplFactory::CreateCoreCanvas(width, height);
55 }
56 #endif
57 return EngineImplFactory::CreateCoreCanvas(width, height);
58 }
59
CreateDataImpl()60 std::unique_ptr<DataImpl> ImplFactory::CreateDataImpl()
61 {
62 #ifdef ENABLE_DDGR_OPTIMIZE
63 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
64 return DDGRImplFactory::CreateData();
65 }
66 #endif
67 return EngineImplFactory::CreateData();
68 }
69
70 #ifdef RS_ENABLE_GPU
CreateGPUContextImpl()71 std::unique_ptr<GPUContextImpl> ImplFactory::CreateGPUContextImpl()
72 {
73 #ifdef ENABLE_DDGR_OPTIMIZE
74 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
75 return DDGRImplFactory::CreateGPUContext();
76 }
77 #endif
78 return EngineImplFactory::CreateGPUContext();
79 }
80 #endif
81
CreateTraceMemoryDumpImpl(const char * categoryKey,bool itemizeType)82 std::unique_ptr<TraceMemoryDumpImpl> ImplFactory::CreateTraceMemoryDumpImpl(const char* categoryKey, bool itemizeType)
83 {
84 #ifdef ENABLE_DDGR_OPTIMIZE
85 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
86 return DDGRImplFactory::CreateTraceMemoryDump(categoryKey, itemizeType);
87 }
88 #endif
89 return EngineImplFactory::CreateTraceMemoryDump(categoryKey, itemizeType);
90 }
91
CreateBitmapImpl()92 std::unique_ptr<BitmapImpl> ImplFactory::CreateBitmapImpl()
93 {
94 #ifdef ENABLE_DDGR_OPTIMIZE
95 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
96 return DDGRImplFactory::CreateBitmap();
97 }
98 #endif
99 return EngineImplFactory::CreateBitmap();
100 }
101
CreatePixmapImpl()102 std::unique_ptr<PixmapImpl> ImplFactory::CreatePixmapImpl()
103 {
104 #ifdef ENABLE_DDGR_OPTIMIZE
105 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
106 return DDGRImplFactory::CreatePixmap();
107 }
108 #endif
109 return EngineImplFactory::CreatePixmap();
110 }
111
CreatePixmapImpl(const ImageInfo & imageInfo,const void * addr,size_t rowBytes)112 std::unique_ptr<PixmapImpl> ImplFactory::CreatePixmapImpl(const ImageInfo& imageInfo, const void* addr, size_t rowBytes)
113 {
114 #ifdef ENABLE_DDGR_OPTIMIZE
115 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
116 return DDGRImplFactory::CreatePixmap(imageInfo, addr, rowBytes);
117 }
118 #endif
119 return EngineImplFactory::CreatePixmap(imageInfo, addr, rowBytes);
120 }
121
CreateImageImpl()122 std::unique_ptr<ImageImpl> ImplFactory::CreateImageImpl()
123 {
124 #ifdef ENABLE_DDGR_OPTIMIZE
125 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
126 return DDGRImplFactory::CreateImage();
127 }
128 #endif
129 return EngineImplFactory::CreateImage();
130 }
131
CreateImageImpl(void * rawImage)132 std::unique_ptr<ImageImpl> ImplFactory::CreateImageImpl(void* rawImage)
133 {
134 #ifdef ENABLE_DDGR_OPTIMIZE
135 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
136 return DDGRImplFactory::CreateImage(rawImage);
137 }
138 #endif
139 return EngineImplFactory::CreateImage(rawImage);
140 }
141
CreatePictureImpl()142 std::unique_ptr<PictureImpl> ImplFactory::CreatePictureImpl()
143 {
144 #ifdef ENABLE_DDGR_OPTIMIZE
145 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
146 return DDGRImplFactory::CreatePicture();
147 }
148 #endif
149 return EngineImplFactory::CreatePicture();
150 }
151
CreatePictureRecorderImpl()152 std::unique_ptr<PictureRecorderImpl> ImplFactory::CreatePictureRecorderImpl()
153 {
154 #ifdef ENABLE_DDGR_OPTIMIZE
155 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
156 return DDGRImplFactory::CreatePictureRecorder();
157 }
158 #endif
159 return EngineImplFactory::CreatePictureRecorder();
160 }
161
CreateSerialProcsImpl()162 std::unique_ptr<SerialProcsImpl> ImplFactory::CreateSerialProcsImpl()
163 {
164 #ifdef ENABLE_DDGR_OPTIMIZE
165 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
166 return nullptr; //ddgr has no serialprocs
167 }
168 #endif
169 return EngineImplFactory::CreateSerialProcs();
170 }
171
CreateSharingSerialContextImpl()172 std::unique_ptr<SharingSerialContextImpl> ImplFactory::CreateSharingSerialContextImpl()
173 {
174 #ifdef ENABLE_DDGR_OPTIMIZE
175 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
176 return nullptr; //ddgr has no sharingserialcontext
177 }
178 #endif
179 return EngineImplFactory::CreateSharingSerialContext();
180 }
181
CreateFileWStreamImpl(const char path[])182 std::unique_ptr<FileWStreamImpl> ImplFactory::CreateFileWStreamImpl(const char path[])
183 {
184 #ifdef ENABLE_DDGR_OPTIMIZE
185 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
186 return DDGRImplFactory::CreateFileWStream(path);
187 }
188 #endif
189 return EngineImplFactory::CreateFileWStream(path);
190 }
191
CreatePathImpl()192 std::unique_ptr<PathImpl> ImplFactory::CreatePathImpl()
193 {
194 #ifdef ENABLE_DDGR_OPTIMIZE
195 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
196 return DDGRImplFactory::CreatePath();
197 }
198 #endif
199 return EngineImplFactory::CreatePath();
200 }
201
CreatePathIterImpl(const Path & path,bool forceClose)202 std::unique_ptr<PathIterImpl> ImplFactory::CreatePathIterImpl(const Path& path, bool forceClose)
203 {
204 #ifdef ENABLE_DDGR_OPTIMIZE
205 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
206 return DDGRImplFactory::CreatePathIter(path, forceClose);
207 }
208 #endif
209 return EngineImplFactory::CreatePathIter(path, forceClose);
210 }
211
CreatePathIteratorImpl(const Path & path)212 std::unique_ptr<PathIteratorImpl> ImplFactory::CreatePathIteratorImpl(const Path& path)
213 {
214 #ifdef ENABLE_DDGR_OPTIMIZE
215 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
216 return DDGRImplFactory::CreatePathIterator(path);
217 }
218 #endif
219 return EngineImplFactory::CreatePathIterator(path);
220 }
221
CreateColorFilterImpl()222 std::unique_ptr<ColorFilterImpl> ImplFactory::CreateColorFilterImpl()
223 {
224 #ifdef ENABLE_DDGR_OPTIMIZE
225 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
226 return DDGRImplFactory::CreateColorFilter();
227 }
228 #endif
229 return EngineImplFactory::CreateColorFilter();
230 }
CreateMaskFilterImpl()231 std::unique_ptr<MaskFilterImpl> ImplFactory::CreateMaskFilterImpl()
232 {
233 #ifdef ENABLE_DDGR_OPTIMIZE
234 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
235 return DDGRImplFactory::CreateMaskFilter();
236 }
237 #endif
238 return EngineImplFactory::CreateMaskFilter();
239 }
240
CreateImageFilterImpl()241 std::unique_ptr<ImageFilterImpl> ImplFactory::CreateImageFilterImpl()
242 {
243 #ifdef ENABLE_DDGR_OPTIMIZE
244 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
245 return DDGRImplFactory::CreateImageFilter();
246 }
247 #endif
248 return EngineImplFactory::CreateImageFilter();
249 }
250
CreateShaderEffectImpl()251 std::unique_ptr<ShaderEffectImpl> ImplFactory::CreateShaderEffectImpl()
252 {
253 #ifdef ENABLE_DDGR_OPTIMIZE
254 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
255 return DDGRImplFactory::CreateShaderEffect();
256 }
257 #endif
258 return EngineImplFactory::CreateShaderEffect();
259 }
260
CreateBlenderImpl()261 std::unique_ptr<BlenderImpl> ImplFactory::CreateBlenderImpl()
262 {
263 #ifdef ENABLE_DDGR_OPTIMIZE
264 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
265 return DDGRImplFactory::CreateBlender();
266 }
267 #endif
268 return EngineImplFactory::CreateBlender();
269 }
270
CreateRuntimeEffectImpl()271 std::unique_ptr<RuntimeEffectImpl> ImplFactory::CreateRuntimeEffectImpl()
272 {
273 #ifdef ENABLE_DDGR_OPTIMIZE
274 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
275 return DDGRImplFactory::CreateRuntimeEffect();
276 }
277 #endif
278 return EngineImplFactory::CreateRuntimeEffect();
279 }
280
CreateRuntimeShaderBuilderImpl(std::shared_ptr<RuntimeEffect> runtimeEffect)281 std::unique_ptr<RuntimeShaderBuilderImpl> ImplFactory::CreateRuntimeShaderBuilderImpl(
282 std::shared_ptr<RuntimeEffect> runtimeEffect)
283 {
284 #ifdef ENABLE_DDGR_OPTIMIZE
285 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
286 return DDGRImplFactory::CreateRuntimeShaderBuilder(runtimeEffect);
287 }
288 #endif
289 return EngineImplFactory::CreateRuntimeShaderBuilder(runtimeEffect);
290 }
291
CreateRuntimeBlenderBuilderImpl(std::shared_ptr<RuntimeEffect> runtimeEffect)292 std::unique_ptr<RuntimeBlenderBuilderImpl> ImplFactory::CreateRuntimeBlenderBuilderImpl(
293 std::shared_ptr<RuntimeEffect> runtimeEffect)
294 {
295 #ifdef ENABLE_DDGR_OPTIMIZE
296 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
297 return DDGRImplFactory::CreateRuntimeBlenderBuilder(runtimeEffect);
298 }
299 #endif
300 return EngineImplFactory::CreateRuntimeBlenderBuilder(runtimeEffect);
301 }
302
CreateSurfaceImpl()303 std::unique_ptr<SurfaceImpl> ImplFactory::CreateSurfaceImpl()
304 {
305 #ifdef ENABLE_DDGR_OPTIMIZE
306 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
307 return DDGRImplFactory::CreateSurface();
308 }
309 #endif
310 return EngineImplFactory::CreateSurface();
311 }
312
CreateOplistHandleImpl()313 std::unique_ptr<OpListHandleImpl> ImplFactory::CreateOplistHandleImpl()
314 {
315 #ifdef ENABLE_DDGR_OPTIMIZE
316 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
317 return DDGRImplFactory::CreateOplistHandle();
318 }
319 #endif
320 return EngineImplFactory::CreateOplistHandle();
321 }
322
CreatePathEffectImpl()323 std::unique_ptr<PathEffectImpl> ImplFactory::CreatePathEffectImpl()
324 {
325 #ifdef ENABLE_DDGR_OPTIMIZE
326 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
327 return DDGRImplFactory::CreatePathEffect();
328 }
329 #endif
330 return EngineImplFactory::CreatePathEffect();
331 }
332
CreateColorSpaceImpl()333 std::unique_ptr<ColorSpaceImpl> ImplFactory::CreateColorSpaceImpl()
334 {
335 #ifdef ENABLE_DDGR_OPTIMIZE
336 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
337 return DDGRImplFactory::CreateColorSpace();
338 }
339 #endif
340 return EngineImplFactory::CreateColorSpace();
341 }
342
CreateMatrixImpl()343 std::unique_ptr<MatrixImpl> ImplFactory::CreateMatrixImpl()
344 {
345 #ifdef ENABLE_DDGR_OPTIMIZE
346 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
347 return DDGRImplFactory::CreateMatrix();
348 }
349 #endif
350 return EngineImplFactory::CreateMatrix();
351 }
352
CreateMatrixImpl(const Matrix & other)353 std::unique_ptr<MatrixImpl> ImplFactory::CreateMatrixImpl(const Matrix& other)
354 {
355 #ifdef ENABLE_DDGR_OPTIMIZE
356 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
357 return DDGRImplFactory::CreateMatrix(other);
358 }
359 #endif
360 return EngineImplFactory::CreateMatrix(other);
361 }
362
CreateMatrix44Impl()363 std::unique_ptr<Matrix44Impl> ImplFactory::CreateMatrix44Impl()
364 {
365 #ifdef ENABLE_DDGR_OPTIMIZE
366 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
367 return DDGRImplFactory::CreateMatrix44();
368 }
369 #endif
370 return EngineImplFactory::CreateMatrix44();
371 }
372
CreateCameraImpl()373 std::unique_ptr<CameraImpl> ImplFactory::CreateCameraImpl()
374 {
375 #ifdef ENABLE_DDGR_OPTIMIZE
376 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
377 return DDGRImplFactory::CreateCamera();
378 }
379 #endif
380 return EngineImplFactory::CreateCamera();
381 }
382
CreateRegionImpl()383 std::unique_ptr<RegionImpl> ImplFactory::CreateRegionImpl()
384 {
385 #ifdef ENABLE_DDGR_OPTIMIZE
386 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
387 return DDGRImplFactory::CreateRegion();
388 }
389 #endif
390 return EngineImplFactory::CreateRegion();
391 }
392
CreateFontImpl()393 std::unique_ptr<FontImpl> ImplFactory::CreateFontImpl()
394 {
395 #ifdef ENABLE_DDGR_OPTIMIZE
396 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
397 return DDGRImplFactory::CreateFont();
398 }
399 #endif
400 return EngineImplFactory::CreateFont();
401 }
402
CreateFontImpl(std::shared_ptr<Typeface> typeface,scalar size,scalar scaleX,scalar skewX)403 std::unique_ptr<FontImpl> ImplFactory::CreateFontImpl(std::shared_ptr<Typeface> typeface,
404 scalar size, scalar scaleX, scalar skewX)
405 {
406 #ifdef ENABLE_DDGR_OPTIMIZE
407 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
408 return DDGRImplFactory::CreateFont(typeface, size, scaleX, skewX);
409 }
410 #endif
411 return EngineImplFactory::CreateFont(typeface, size, scaleX, skewX);
412 }
413
CreateFontImpl(const Font & font)414 std::unique_ptr<FontImpl> ImplFactory::CreateFontImpl(const Font& font)
415 {
416 #ifdef ENABLE_DDGR_OPTIMIZE
417 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
418 return DDGRImplFactory::CreateFont(font);
419 }
420 #endif
421 return EngineImplFactory::CreateFont(font);
422 }
423
CreateTextBlobBuilderImpl()424 std::unique_ptr<TextBlobBuilderImpl> ImplFactory::CreateTextBlobBuilderImpl()
425 {
426 #ifdef ENABLE_DDGR_OPTIMIZE
427 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
428 return DDGRImplFactory::CreateTextBlobBuilder();
429 }
430 #endif
431 return EngineImplFactory::CreateTextBlobBuilder();
432 }
433
CreateDefaultFontMgrImpl()434 std::shared_ptr<FontMgrImpl> ImplFactory::CreateDefaultFontMgrImpl()
435 {
436 #ifdef ENABLE_DDGR_OPTIMIZE
437 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
438 return DDGRImplFactory::CreateDefaultFontMgr();
439 }
440 #endif
441 return EngineImplFactory::CreateDefaultFontMgr();
442 }
443
CreateDynamicFontMgrImpl()444 std::shared_ptr<FontMgrImpl> ImplFactory::CreateDynamicFontMgrImpl()
445 {
446 #ifdef ENABLE_DDGR_OPTIMIZE
447 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
448 return DDGRImplFactory::CreateDynamicFontMgr();
449 }
450 #endif
451 return EngineImplFactory::CreateDynamicFontMgr();
452 }
453
CreateVerticesImpl()454 std::unique_ptr<VerticesImpl> ImplFactory::CreateVerticesImpl()
455 {
456 #ifdef ENABLE_DDGR_OPTIMIZE
457 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
458 return DDGRImplFactory::CreateVertices();
459 }
460 #endif
461 return EngineImplFactory::CreateVertices();
462 }
463
CreateVerticesBuilderImpl()464 std::unique_ptr<VerticesImpl::BuilderImpl> ImplFactory::CreateVerticesBuilderImpl()
465 {
466 #ifdef ENABLE_DDGR_OPTIMIZE
467 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
468 return DDGRImplFactory::CreateVerticesBuilder();
469 }
470 #endif
471 return EngineImplFactory::CreateVerticesBuilder();
472 }
473
CreateMemoryStreamImpl()474 std::shared_ptr<MemoryStreamImpl> ImplFactory::CreateMemoryStreamImpl()
475 {
476 #ifdef ENABLE_DDGR_OPTIMIZE
477 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
478 return DDGRImplFactory::CreateMemoryStream();
479 }
480 #endif
481 return EngineImplFactory::CreateMemoryStream();
482 }
483
CreateMemoryStreamImpl(const void * data,size_t length,bool copyData)484 std::shared_ptr<MemoryStreamImpl> ImplFactory::CreateMemoryStreamImpl(const void* data, size_t length, bool copyData)
485 {
486 #ifdef ENABLE_DDGR_OPTIMIZE
487 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
488 return DDGRImplFactory::CreateMemoryStream(data, length, copyData);
489 }
490 #endif
491 return EngineImplFactory::CreateMemoryStream(data, length, copyData);
492 }
493
CreateResourceHolderImpl()494 std::shared_ptr<ResourceHolderImpl> ImplFactory::CreateResourceHolderImpl()
495 {
496 #ifdef ENABLE_DDGR_OPTIMIZE
497 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
498 return DDGRImplFactory::CreateResourceHolder();
499 }
500 #endif
501 return EngineImplFactory::CreateResourceHolder();
502 }
503 } // namespace Drawing
504 } // namespace Rosen
505 } // namespace OHOS