Project

General

Profile

GraphicsResearch » History » Version 29

dl lud, 02/10/2019 08:51 PM
Added section with grallocs' comparison.

1 1 Wolfgang Wiedmeyer
h1. Research on free graphics-related software
2
3 12 Wolfgang Wiedmeyer
{{>toc}}
4
5 5 Wolfgang Wiedmeyer
On this page, information is collected that could help solving graphics issues in Replicant (see #1539). Besides evaluating free implementations that are relevant for currently supported devices, other implementations should also be listed if they are useful for potential future target devices.
6 1 Wolfgang Wiedmeyer
7 8 Wolfgang Wiedmeyer
external resources:
8
"Wikipedia":https://en.wikipedia.org/wiki/Free_and_open-source_graphics_device_driver
9 13 Wolfgang Wiedmeyer
"Debian Mobile":https://wiki.debian.org/Mobile#Drivers
10 8 Wolfgang Wiedmeyer
11 21 Denis 'GNUtoo' Carikli
h2. Multiple backends
12
13
See https://notabug.org/JeremyRand/frameworks_native for work in progress to enable to switch the OpenGL library for individual applications.
14
15 1 Wolfgang Wiedmeyer
h2. Software rendering
16
17 7 Wolfgang Wiedmeyer
Software rendering uses the CPU and not a dedicated graphics processor for graphics rendering. It is slower than per-GPU implementations and is usually used when it is not possible to make use of the GPU. An advantage is that the same software renderer can work across many different types of hardware, so working on improving a software renderer benefits many different devices, regardless of the SOC and graphics unit that is used. Furthermore, a software renderer doesn't require a kernel driver which makes it easier to work on mainline Linux kernel support for a device until the graphics driver is in mainline.
18 2 Wolfgang Wiedmeyer
19 1 Wolfgang Wiedmeyer
h3. Android software renderer
20 2 Wolfgang Wiedmeyer
21 14 Wolfgang Wiedmeyer
source code: https://git.replicant.us/replicant/frameworks_native/tree/opengl/libagl
22 2 Wolfgang Wiedmeyer
23 26 dl lud
The Android software renderer is currently used on all Replicant-supported devices and it is the fastest software renderer that is available for Replicant devices. It is a software renderer that was developed specifically for Android and it is part of the AOSP source code. The renderer includes optimizations for ARM via "libpixelflinger":https://android.googlesource.com/platform/system/core/+/master/libpixelflinger and "codeflinger":https://android.googlesource.com/platform/system/core/+/master/libpixelflinger/codeflinger/ that do JIT compilation into platform optimized code. Development ceased in 2013 and no work was done to support newer OpenGL ES (GLES) versions (which causes #705).
24 2 Wolfgang Wiedmeyer
25 26 dl lud
Until ca. 2011 (Android 4.0), another library with the name @libagl2@ existed and @surfaceflinger2@ was developed based on Mesa. The source code was later removed and no further development is known. At the time, the work was done to support a newer GLES version for the software renderer. It was abandoned later, probably when Google made it mandatory for Android 4.0 and later devices to pack their own hardware GPU with OpenGL ES 2.0 support. It is questionable if it is worth it to port the old @libagl2@ library to a recent Replicant version, also given that we would be the only ones using and maintaining the code.
26 1 Wolfgang Wiedmeyer
27 19 Denis 'GNUtoo' Carikli
h3. Mesa and llvmpipe
28 1 Wolfgang Wiedmeyer
29 20 Denis 'GNUtoo' Carikli
*Replicant llvmpipe support source code*: https://git.replicant.us/replicant/external_mesa3d
30
*Replicant documentation*: [[Graphics]]
31
*Upstream documentation*: https://www.mesa3d.org/llvmpipe.html
32
*Upstream performance improvement documentation*: https://www.mesa3d.org/perf.html
33 3 Wolfgang Wiedmeyer
34 28 dl lud
For the needs in Replicant, llvmpipe has a OpenGL ES implementation that is complete enough. But some apps don't work due to minor bugs which seem fixable or which might already be fixed in more recent upstream versions. swrast and softpipe are of no interest as both are slower than llvmpipe.
35 3 Wolfgang Wiedmeyer
36 28 dl lud
The "Android-x86 project":http://www.android-x86.org/ is using llvmpipe and quite a few of their Android-specific frameworks patches are applied in Replicant 6.0. Their Mesa source code fork is also used in Replicant 6.0. A lot of porting work of llvmpipe to Android was done by Jide while Intel is contributing as well. So there is an interest from different parties to have llvmpipe working on Android. Android patches are upstreamed to mainline Mesa.
37 3 Wolfgang Wiedmeyer
38
However, llvmpipe is still not ported to ARM which makes it slow. Also for Android, it is mostly used on the x86 platform in other projects. See #705 for more information. Optimizing llvmpipe for ARM seems currently the most promising approach to fix graphics-related issues with Replicant.
39
40 1 Wolfgang Wiedmeyer
h3. SwiftShader
41 3 Wolfgang Wiedmeyer
42
source code: https://swiftshader.googlesource.com/SwiftShader
43
44 27 dl lud
"Google released SwiftShader as free software in mid 2016":https://blog.chromium.org/2016/06/universal-rendering-with-swiftshader.html. It supports x86 (32 bit and 64 bit) and 32 bit ARM architectures with SDIV/UDIV support. It is used in the Chromium project but also with Android, for example in the Android-x86 project. Swiftshader doesn't seem to depend on any external libraries besides what are provided in its Git repository, therefore it is very easy to compile it and use it as a software renderer for Replicant. All the Android build files are provided so you just need to the add the following packages to PRODUCT_PACKAGES in order to be able to use it:
45 18 Joonas Kylmälä
46
 * libGLESv2_swiftshader
47
 * libEGL_swiftshader
48 1 Wolfgang Wiedmeyer
49
h2. Per-GPU implementations
50
51 9 Wolfgang Wiedmeyer
In the following, free software implementations are listed that should make it possible to use the respective GPU with free software.
52 1 Wolfgang Wiedmeyer
53 23 dl lud
h3. ARM Mali-4xx (Utgard) with Lima
54 7 Wolfgang Wiedmeyer
55 22 dl lud
Supported devices that use Mali 400: Galaxy S 2, Galaxy S 3, Galaxy S 3 4G, Galaxy Note, Galaxy Note 2
56 7 Wolfgang Wiedmeyer
57 22 dl lud
Project page: https://gitlab.freedesktop.org/lima/web/wikis/home
58 1 Wolfgang Wiedmeyer
59 22 dl lud
Lima is still unfinished as of January 2019 but development is going on at a fast pace. The detailed implementation status can be checked "with the piglit test suite":https://gitlab.freedesktop.org/lima/mesa/issues/39#note_79193.
60 7 Wolfgang Wiedmeyer
61 23 dl lud
Lima saw first light with the reverse-engineering efforts by Luc Verhaegen, that produced an experimental driver with it's original page at  
62 22 dl lud
https://limadriver.org . Luc's development stopped around 2014, but in 2017 Qiang Yu took on the task and started development on top of Mesa's Gallium3D driver as "reported by Phoronix":https://www.phoronix.com/scan.php?page=news_item&px=Mali-400-New-Open-Source. 
63
The code is now hosted at "freedesktop.org's GitLab":https://gitlab.freedesktop.org/lima and is getting contributions by many developers besides Qiang Yu.
64 16 Jeremy Rand
65 1 Wolfgang Wiedmeyer
h3. Imagination PowerVR
66
67
supported devices that use PowerVR SGX540: Nexus S, Galaxy S, Galaxy Nexus, Galaxy Tab 2 7.0, Galaxy Tab 2 10.1
68 5 Wolfgang Wiedmeyer
supported devices that use PowerVR SGX530: GTA04
69 8 Wolfgang Wiedmeyer
70
A reverse-engineering project exists:
71 10 Wolfgang Wiedmeyer
"website":http://powervr.gnu.org.ve/doku.php
72
"mailing list":http://listas.gnu.org.ve/listinfo/powervr-devel
73 8 Wolfgang Wiedmeyer
"Libreplanet group":https://libreplanet.org/wiki/Group:PowerVR_drivers
74 1 Wolfgang Wiedmeyer
75
Despite initial reverse-engineering progress until 2013, no further development updates seem to be available. The project website provides documentation.
76 23 dl lud
77
h3. ARM Mali-T6xx/T7xx/T8xx (Midgard) and G7x (Bifrost) with Panfrost
78
79
not used by a supported device
80
Used on several Samsung Galaxy S series phones that are now supported by LineageOs and may be potential targets for Replicant ports: S6
81
(Mali T760MP8), S7 (Mali-T880 MP12) and S9 (Mali-G72 MP18).
82
83
Project page: https://panfrost.freedesktop.org/
84
Source code: https://gitlab.freedesktop.org/panfrost
85
86
Panfrost is another reverse-engineered driver for ARM Mali GPUs, but aimed at the latest architectures (Midgard and Bifrost). It is still experimental but under active development with a strong community (as of January 2019). It's main focus are the ARM SoCs present on some laptops and single-board computers (SBC), but it is "Intended to work on as many SoCs as possible to make everyone's lives easier":https://gitlab.freedesktop.org/panfrost/mali_kbase.
87
Panfrost is developed by Alyssa Rosenzweig and Lyude Paul, and recently attracted other contributors such as "Tomeu Vizoso":https://blog.tomeuvizoso.net/2019/01/a-panfrost-milestone.html.
88
Development can be followed on "Alyssas's blog":https://rosenzweig.io/blog/.
89 1 Wolfgang Wiedmeyer
90 24 dl lud
h3. Qualcomm Adreno with freedreno
91 1 Wolfgang Wiedmeyer
92
not used by a supported device
93 9 Wolfgang Wiedmeyer
94
wiki: https://github.com/freedreno/freedreno/wiki
95
96
freedreno is actively developed. Linux kernel component is available in mainline since version 3.12. It needs to be investigated how well freedreno could work on potential target devices. However, even when using freedreno, non-free firmware is very likely still needed.
97
98
Generally speaking, Qualcomm devices have a lot of blobs and no modem isolation which is the reason why no Qualcomm-based device is yet supported by Replicant. See [[TargetsEvaluation]] for some analysis. We have not yet identified a Qualcomm-based device that would be a promising target for Replicant and where freedreno could be used on.
99 15 Wolfgang Wiedmeyer
100 24 dl lud
h3. Vivante GCxxxx with Etnaviv
101 15 Wolfgang Wiedmeyer
102
not used by a supported device
103
104
For some Vivante GCxxxx GPU variants, a free driver, Etnaviv, exists. See "wikipedia":https://en.wikipedia.org/wiki/Free_and_open-source_graphics_device_driver#Vivante for some details. It would be interesting to investigate devices using such a GPU if they would be good Replicant targets. It also needs to be checked if non-free firmware needs to be loaded to the GPU.
105 29 dl lud
106
h2. Gralloc
107
108
In order to have a working software rendering on Replicant 9 we will need a gralloc (graphics memory allocator) library that:
109
* Implements the "Android Gralloc HAL":https://source.android.com/devices/graphics/implement#gralloc_hal API version 1.
110
* Is compatible with "drm-hwcomposer":https://gitlab.freedesktop.org/drm-hwcomposer/drm-hwcomposer (a libre implementation, based on Linux's DRM, of Android's Hardware Composer HAL).
111
* Is compatible with Mesa and particularly its llvmpipe software renderer.
112
* (optional) Is compatible with SwiftShader.
113
114
There are currently 3 grallocs under evaluation:
115
* "drm_gralloc":https://osdn.net/projects/android-x86/scm/git/external-drm_gralloc/summary - Directly uses Linux DRM for buffer allocation. Built by the Android-x86 team and now getting phased out in favor of gbm_gralloc.
116
* "gbm_gralloc":https://osdn.net/projects/android-x86/scm/git/external-gbm_gralloc/summary - Uses Mesa's GBM (Generic Buffer Management) for buffer allocation through libgbm. GBM itself will then call DRM. Originally "by Rob Herring":https://github.com/robherring/gbm_gralloc, but now maintained by Android-x86.
117
* "minigbm":https://github.com/intel/minigbm - Uses its own embedded GBM implementation. Does not depend on Mesa. Built by Intel for their Android-IA project now dubbed "Project Celadon":https://github.com/projectceladon. Also used by Google "in ChromiumOS":https://chromium.googlesource.com/chromiumos/platform/minigbm/.