Last week, Wayland/Weston
was forked by a long-time
contributor, Scott Moreau. The fork of the Wayland/Weston display server ended
up becoming known as Northfield/Norwood,
following disagreements within the Wayland development camp. Scott Moreau was
ultimately banned from the Wayland mailing list and IRC channel, so he's written
an exclusive, independent article for Phoronix to explain his actions and why
he felt a fork of the Wayland display server protocol and the reference Weston compositor were necessary.
Northfield/Wayland Split - Technical Aspects
Since there are many interested parties involved here, I spent some time assembling
this writeup. I would like to change the tune to more positive notes that intend
to introduce insight and reason into the picture. Since my actions inadvertently
caused a significant disturbance, I feel that I owe it to everyone to explain
the technical problems from my point of view. I would like other people to understand
the problem as well and see how they might solve it, given the pertinent details.
This an involving issue touching on many technical details. This is my attempt
to fully explain the issues to all audiences.
It is noteworthy that these views are my own and may not be completely correct.
I do not know everything nor do I claim to. There's nothing wrong with being wrong
about a technical understanding. In fact, voicing ideas can be a good thing, because
it encourages others with further insight, to share their knowledge and start
a productive conversation. I will try to explain this in basic and technical terms
as best I can.
First, we need to talk a bit about how wayland, weston and wayland clients
work together to form a composited image.
- Wayland Display: wl_display: The core global object. A pointer to a wl_display.
Used for internal wayland interfaces.
- Wayland Buffer: wl_buffer: The contents of a wl_surface.
- Wayland Surface: wl_surface: This is an image that is displayed on the screen.
It has a location, size and pixel contents.
- Wayland: The term Wayland in this context implies two closely related things:
1) A wayland protocol
2) An implementation of this protocol in C
- Weston: The official wayland reference compositor. This is the program that
represents the core compositing program
- surface: The term 'surface' is used here to denote 'an application window'
In order for clients to render their content into wayland composited surfaces,
it needs to do a few things.
At a basic high level of abstraction these are:
1) Connect to the wayland wl_display - Using wl_display_connect().
2) Create a wl_buffer in which to render content - Buffer creation method varies
3) Draw something - Typically using cairo or GL (though client rendering is not
restricted to any specific method).
4) Tell the compositor to show the wl_surface - This is handled by the compositor
and shell plugin.
5) Repaint the surface and notify the compositor that the rendering has finished
- this can be done by calling wl_surface_damage(), wl_surface_attach() and finally
wl_surface_commit() as the sync point. In the EGL case, eglSwapBuffers() uses
these specific wayland calls from mesa internally to 'refresh' the surface.
6) Repeat step 5) as necessary for the life of the program.
The compositing program then takes all of these surfaces and paints them to
a final buffer that is suitable for output.
The primary argument against the need for a fork is one that sounds reasonable
Why not just fork the shell plugin alone?
This was a suggestion given by many. An example representation of such reasoning
can be found in this wayland-devel
mailing list post: "What you could aim instead is a new tree with your
own shell plugin and stack over the core protocol another high level surface protocol."