Not sure if he refers to the Android drivers or if this implies that AMD/NVidiaMir will work with proprietary drivers, because thatís just practical reality.
have (internally) promised to deliver required EGL capable blobs...
BTW, what is actually required for a blob to support Wayland/Mir?
I know that Wayland additionally requires the EGL buffer age extension.
But apart from that it looks like the AMD blob supports EGL for quite some time:
So, what's missing here?
Some Guy: Linus, will the kernel go closed source at some point? (By god, the money he'd make if he did.)
Linus: The kernel is open source - GPL - just like pretty much everything we do.
Seems reasonable to me...... I think its PR only in your head.
Plus, how is GPL software going closed? AFAIK, the license prevents already GPL'd software from changing to non-GPL licenses.
There my post says it. But lets educate everyone here a little.
Firstly, Wayland is only a protocol, nothing more really. It specifies, essentially, the following:
1) How a program (a wayland client) requests offscreen buffers from the compositor
2) various messages to say "present" this buffer
3) some message protocol for events
There is the reference compositor Weston. Now how those buffers are created and how they are drawn to is a function of the system, the integration and the compositor. Nothing more. Over on the RasberryPi, there is a compositor that uses the display controller to present the window contents (i.e not even using OpenGL or OpenGL ES). What is key for a Wayland based system to get performance is that the buffers written to are the buffers being presented. A dumb, slow as molasses, implementation will make the buffers generic shared memory and the compositor would use glTexSubimage2D to upload the image data to GL. That is terrible and one of the worst ways to get the job done, and yet it is done in some places. Shudders.
Over on freedesktop.org there is an EGL extension written up for this buffer image sharing, note that the extension is not in the OpenGL ES registry though. This is not really a big deal, but what is important is this: any system using Wayland needs to have a means to allocate cross-process image buffers where a client (program) writes to it and the server (Wayland compositor) draws them. That is it. Nothing more.
On the issue of Mir. The main stink for Canonical for Wayland was event handling. In a nutshell, Wayland did not have a rich enough system for user events. If you take a look at http://wayland.freedesktop.org/docs/html/, you will see that Wayland's event system is lacking and not particularly rich. There was a long blab on the Wiki of Mir about the why, it was not a NIH issue, there were serious concerns with respect to input.
Going on, I noticed a comment about OpenGL being too linked/reliant on X to use with Wayland. Epically wrong. The main issue is creating a GL context. Now, for X, one uses GLX (gee). However, EGL has a provision to create OpenGL (not just OpenGL ES) contexts as well.
The post about memory consumption was a waste of bytes. Indeed, those numbers are so much tinier than how much RAM is on the system as to not worth noting; the real issue to look at is how much bandwidth does each system consume. That is where the real action with respect to performance is. On embedded systems, X has worked. Indeed both the N900 and N9 from Nokia have X. I do not think it was a good idea, but it did work and memory consumption was kept reasonable. The main stinks for X are the following:
1) making good X.org drivers is a royal pain. Getting accelerated compositing working is another royal pain.
2) X does lots of things, and in truth using X to get anything done is painful. It's input APIs suck, it's window API's suck, it has lots of API's that all suck to use
3) and yet, most application draw all their content themselves (be it via Cairo, Qt, whatever) and do not use Xlib to draw anything. All they want is a surface to which to draw and a way to grab events
Looking at the above, one sees that all one needs is something to allocate image buffers, notify on what buffer to present and to receive events. Wayland did the first fine, but the events just are not rich enough.
At any rate, on desktop, the only player in Linux land that can get us out of X is Canonical. They are the only ones with enough clout to convince IHV's (namely NVIDIA and AMD/ATI) to make it possible to create GL contexts and such without X. Wayland has been around for several years now, and still nothing has been made for it that is used a great deal. My thinking of the why is essentially those folks are not in a position to push it to the correct people at the correct IHV's. There is a place for Wayland on embedded devices, but in truth for mobile, Android and iOS rule it... Maemo/Meego/Tizen look pathetic... there are some Tizen devices out there, but I am not impressed with Tizen at all.