1 /*
2 * Copyright (c) 2021-2023 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
CreatePathIteratorImpl(const Path & path)202 std::unique_ptr<PathIteratorImpl> ImplFactory::CreatePathIteratorImpl(const Path& path)
203 {
204 #ifdef ENABLE_DDGR_OPTIMIZE
205 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
206 return DDGRImplFactory::CreatePathIterator(path);
207 }
208 #endif
209 return EngineImplFactory::CreatePathIterator(path);
210 }
211
CreateColorFilterImpl()212 std::unique_ptr<ColorFilterImpl> ImplFactory::CreateColorFilterImpl()
213 {
214 #ifdef ENABLE_DDGR_OPTIMIZE
215 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
216 return DDGRImplFactory::CreateColorFilter();
217 }
218 #endif
219 return EngineImplFactory::CreateColorFilter();
220 }
CreateMaskFilterImpl()221 std::unique_ptr<MaskFilterImpl> ImplFactory::CreateMaskFilterImpl()
222 {
223 #ifdef ENABLE_DDGR_OPTIMIZE
224 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
225 return DDGRImplFactory::CreateMaskFilter();
226 }
227 #endif
228 return EngineImplFactory::CreateMaskFilter();
229 }
230
CreateImageFilterImpl()231 std::unique_ptr<ImageFilterImpl> ImplFactory::CreateImageFilterImpl()
232 {
233 #ifdef ENABLE_DDGR_OPTIMIZE
234 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
235 return DDGRImplFactory::CreateImageFilter();
236 }
237 #endif
238 return EngineImplFactory::CreateImageFilter();
239 }
240
CreateShaderEffectImpl()241 std::unique_ptr<ShaderEffectImpl> ImplFactory::CreateShaderEffectImpl()
242 {
243 #ifdef ENABLE_DDGR_OPTIMIZE
244 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
245 return DDGRImplFactory::CreateShaderEffect();
246 }
247 #endif
248 return EngineImplFactory::CreateShaderEffect();
249 }
250
CreateBlenderImpl()251 std::unique_ptr<BlenderImpl> ImplFactory::CreateBlenderImpl()
252 {
253 #ifdef ENABLE_DDGR_OPTIMIZE
254 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
255 return DDGRImplFactory::CreateBlender();
256 }
257 #endif
258 return EngineImplFactory::CreateBlender();
259 }
260
CreateRuntimeEffectImpl()261 std::unique_ptr<RuntimeEffectImpl> ImplFactory::CreateRuntimeEffectImpl()
262 {
263 #ifdef ENABLE_DDGR_OPTIMIZE
264 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
265 return DDGRImplFactory::CreateRuntimeEffect();
266 }
267 #endif
268 return EngineImplFactory::CreateRuntimeEffect();
269 }
270
CreateRuntimeShaderBuilderImpl(std::shared_ptr<RuntimeEffect> runtimeEffect)271 std::unique_ptr<RuntimeShaderBuilderImpl> ImplFactory::CreateRuntimeShaderBuilderImpl(
272 std::shared_ptr<RuntimeEffect> runtimeEffect)
273 {
274 #ifdef ENABLE_DDGR_OPTIMIZE
275 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
276 return DDGRImplFactory::CreateRuntimeShaderBuilder(runtimeEffect);
277 }
278 #endif
279 return EngineImplFactory::CreateRuntimeShaderBuilder(runtimeEffect);
280 }
281
CreateRuntimeBlenderBuilderImpl(std::shared_ptr<RuntimeEffect> runtimeEffect)282 std::unique_ptr<RuntimeBlenderBuilderImpl> ImplFactory::CreateRuntimeBlenderBuilderImpl(
283 std::shared_ptr<RuntimeEffect> runtimeEffect)
284 {
285 #ifdef ENABLE_DDGR_OPTIMIZE
286 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
287 return DDGRImplFactory::CreateRuntimeBlenderBuilder(runtimeEffect);
288 }
289 #endif
290 return EngineImplFactory::CreateRuntimeBlenderBuilder(runtimeEffect);
291 }
292
CreateSurfaceImpl()293 std::unique_ptr<SurfaceImpl> ImplFactory::CreateSurfaceImpl()
294 {
295 #ifdef ENABLE_DDGR_OPTIMIZE
296 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
297 return DDGRImplFactory::CreateSurface();
298 }
299 #endif
300 return EngineImplFactory::CreateSurface();
301 }
302
CreateOplistHandleImpl()303 std::unique_ptr<OpListHandleImpl> ImplFactory::CreateOplistHandleImpl()
304 {
305 #ifdef ENABLE_DDGR_OPTIMIZE
306 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
307 return DDGRImplFactory::CreateOplistHandle();
308 }
309 #endif
310 return EngineImplFactory::CreateOplistHandle();
311 }
312
CreatePathEffectImpl()313 std::unique_ptr<PathEffectImpl> ImplFactory::CreatePathEffectImpl()
314 {
315 #ifdef ENABLE_DDGR_OPTIMIZE
316 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
317 return DDGRImplFactory::CreatePathEffect();
318 }
319 #endif
320 return EngineImplFactory::CreatePathEffect();
321 }
322
CreateColorSpaceImpl()323 std::unique_ptr<ColorSpaceImpl> ImplFactory::CreateColorSpaceImpl()
324 {
325 #ifdef ENABLE_DDGR_OPTIMIZE
326 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
327 return DDGRImplFactory::CreateColorSpace();
328 }
329 #endif
330 return EngineImplFactory::CreateColorSpace();
331 }
332
CreateMatrixImpl()333 std::unique_ptr<MatrixImpl> ImplFactory::CreateMatrixImpl()
334 {
335 #ifdef ENABLE_DDGR_OPTIMIZE
336 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
337 return DDGRImplFactory::CreateMatrix();
338 }
339 #endif
340 return EngineImplFactory::CreateMatrix();
341 }
342
CreateMatrixImpl(const Matrix & other)343 std::unique_ptr<MatrixImpl> ImplFactory::CreateMatrixImpl(const Matrix& other)
344 {
345 #ifdef ENABLE_DDGR_OPTIMIZE
346 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
347 return DDGRImplFactory::CreateMatrix(other);
348 }
349 #endif
350 return EngineImplFactory::CreateMatrix(other);
351 }
352
CreateMatrix44Impl()353 std::unique_ptr<Matrix44Impl> ImplFactory::CreateMatrix44Impl()
354 {
355 #ifdef ENABLE_DDGR_OPTIMIZE
356 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
357 return DDGRImplFactory::CreateMatrix44();
358 }
359 #endif
360 return EngineImplFactory::CreateMatrix44();
361 }
362
CreateCameraImpl()363 std::unique_ptr<CameraImpl> ImplFactory::CreateCameraImpl()
364 {
365 #ifdef ENABLE_DDGR_OPTIMIZE
366 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
367 return DDGRImplFactory::CreateCamera();
368 }
369 #endif
370 return EngineImplFactory::CreateCamera();
371 }
372
CreateRegionImpl()373 std::unique_ptr<RegionImpl> ImplFactory::CreateRegionImpl()
374 {
375 #ifdef ENABLE_DDGR_OPTIMIZE
376 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
377 return DDGRImplFactory::CreateRegion();
378 }
379 #endif
380 return EngineImplFactory::CreateRegion();
381 }
382
CreateFontImpl()383 std::unique_ptr<FontImpl> ImplFactory::CreateFontImpl()
384 {
385 #ifdef ENABLE_DDGR_OPTIMIZE
386 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
387 return DDGRImplFactory::CreateFont();
388 }
389 #endif
390 return EngineImplFactory::CreateFont();
391 }
392
CreateFontImpl(std::shared_ptr<Typeface> typeface,scalar size,scalar scaleX,scalar skewX)393 std::unique_ptr<FontImpl> ImplFactory::CreateFontImpl(std::shared_ptr<Typeface> typeface,
394 scalar size, scalar scaleX, scalar skewX)
395 {
396 #ifdef ENABLE_DDGR_OPTIMIZE
397 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
398 return DDGRImplFactory::CreateFont(typeface, size, scaleX, skewX);
399 }
400 #endif
401 return EngineImplFactory::CreateFont(typeface, size, scaleX, skewX);
402 }
403
CreateFontImpl(const Font & font)404 std::unique_ptr<FontImpl> ImplFactory::CreateFontImpl(const Font& font)
405 {
406 #ifdef ENABLE_DDGR_OPTIMIZE
407 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
408 return DDGRImplFactory::CreateFont(font);
409 }
410 #endif
411 return EngineImplFactory::CreateFont(font);
412 }
413
CreateTextBlobBuilderImpl()414 std::unique_ptr<TextBlobBuilderImpl> ImplFactory::CreateTextBlobBuilderImpl()
415 {
416 #ifdef ENABLE_DDGR_OPTIMIZE
417 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
418 return DDGRImplFactory::CreateTextBlobBuilder();
419 }
420 #endif
421 return EngineImplFactory::CreateTextBlobBuilder();
422 }
423
CreateDefaultFontMgrImpl()424 std::shared_ptr<FontMgrImpl> ImplFactory::CreateDefaultFontMgrImpl()
425 {
426 #ifdef ENABLE_DDGR_OPTIMIZE
427 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
428 return DDGRImplFactory::CreateDefaultFontMgr();
429 }
430 #endif
431 return EngineImplFactory::CreateDefaultFontMgr();
432 }
433
434 #ifndef USE_TEXGINE
CreateDynamicFontMgrImpl()435 std::shared_ptr<FontMgrImpl> ImplFactory::CreateDynamicFontMgrImpl()
436 {
437 #ifdef ENABLE_DDGR_OPTIMIZE
438 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
439 return DDGRImplFactory::CreateDynamicFontMgr();
440 }
441 #endif
442 return EngineImplFactory::CreateDynamicFontMgr();
443 }
444 #endif
445
CreateVerticesImpl()446 std::unique_ptr<VerticesImpl> ImplFactory::CreateVerticesImpl()
447 {
448 #ifdef ENABLE_DDGR_OPTIMIZE
449 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
450 return DDGRImplFactory::CreateVertices();
451 }
452 #endif
453 return EngineImplFactory::CreateVertices();
454 }
455
CreateVerticesBuilderImpl()456 std::unique_ptr<VerticesImpl::BuilderImpl> ImplFactory::CreateVerticesBuilderImpl()
457 {
458 #ifdef ENABLE_DDGR_OPTIMIZE
459 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
460 return DDGRImplFactory::CreateVerticesBuilder();
461 }
462 #endif
463 return EngineImplFactory::CreateVerticesBuilder();
464 }
465
CreateMemoryStreamImpl()466 std::shared_ptr<MemoryStreamImpl> ImplFactory::CreateMemoryStreamImpl()
467 {
468 #ifdef ENABLE_DDGR_OPTIMIZE
469 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
470 return DDGRImplFactory::CreateMemoryStream();
471 }
472 #endif
473 return EngineImplFactory::CreateMemoryStream();
474 }
475
CreateMemoryStreamImpl(const void * data,size_t length,bool copyData)476 std::shared_ptr<MemoryStreamImpl> ImplFactory::CreateMemoryStreamImpl(const void* data, size_t length, bool copyData)
477 {
478 #ifdef ENABLE_DDGR_OPTIMIZE
479 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
480 return DDGRImplFactory::CreateMemoryStream(data, length, copyData);
481 }
482 #endif
483 return EngineImplFactory::CreateMemoryStream(data, length, copyData);
484 }
485
CreateResourceHolderImpl()486 std::shared_ptr<ResourceHolderImpl> ImplFactory::CreateResourceHolderImpl()
487 {
488 #ifdef ENABLE_DDGR_OPTIMIZE
489 if (SystemProperties::GetGpuApiType() == GpuApiType::DDGR) {
490 return DDGRImplFactory::CreateResourceHolder();
491 }
492 #endif
493 return EngineImplFactory::CreateResourceHolder();
494 }
495 } // namespace Drawing
496 } // namespace Rosen
497 } // namespace OHOS