The code in fragment_shaders.c is part of the implementation of the
sampler: it generates the fragment shader to expose a GLSL function
"vlc_texture(vec2 coords)".

The function vlc_gl_renderer_Draw() (almost) just called
DrawWithShaders(). There is no need for a separate function.

The renderer is expected to be independant of the input picture format.
Instead, update the sampler directly.

Remove the remaining usage of interop from renderer.

Now, the renderer only need to use the sampler.

The sampler were owned by the renderer.

Move it to vgl, so that the renderer never have to handle an interop
instance directly.

For convenience, expose the video format directly in sampler.

The renderer should not know the interop, so it may not be responsible
to upload the textures.

Move the pictures update to sampler.

The orentation matrix is managed by the sampler. Move its initialization
to opengl_fragment_shader_init() (called by the sampler).

Move opengl_fragment_shader_init() call from renderer to sampler.

The sampler handles the input pictures, so it is also responsible for
generating the necessary GLSL extensions code (if any).

The function opengl_fragment_shader_init() both initializes the
and creates the fragment shader.

To be able to move its initialization outside the renderer, store it in
the sampler instead of returning it. This will also allow to provide the
"extensions" part of the fragment shader as a separate string.

The renderer instance is not needed anymore.

Remove the (weak) reference to the interop from the renderer structure.

The interop is still accessed explicitly from the renderer via the
sampler structure for now.

The fact that the sampler use internal function pointers (instead of
if-blocks for example) is an internal detail.

Remove tex_width and tex_height parameters, as they are either unused or
accessible from the sampler itself.

The alpha value was used to render subpictures, which are now drawn by
the subpictures renderer using its own fragment shader.

Load uniforms related to sampler from sampler->pf_prepare_shader.

Fetch locations related to sampler from sampler->pf_fetch_locations.

The sampler is responsible to fetch its location and initialize its
textures and uniforms.

This will allow to use them from several files.

For convenience, expose the vlc_gl_t and the OpenGL virtual table in
sampler.

Extract sampler creation and destruction to separate functions.

This allows to use an interop instance without a renderer.

The interop initializes its own video_format_t from the input format.

In the renderer initialization, always use this updated format. This
avoids an additional format parameter, which may be confusing.

The interop instances were owned by the renderers.

To prepare for making the renderers independant of the input picture
(in particular, independant of the interop), make the vgl own the
interop instances.

Move the fields necessary to retrieve a picture pixel from its
coordinates.

Make the renderer create the vertex shader, using the vlc_texture()
function generated by fragment_shader.c.

Extract a fragment shader function to provide the pixel color of a
picture from pictures coordinates.

Concretely, it replaces:

    void main(void) {
     vec3 pic_hcoords = vec3(PicCoords, 1.0);
     ...
     gl_FragColor = result * FillColor;
    }

by:

    vec4 vlc_texture(vec2 pic_coords) {
     vec3 pic_hcoords = vec3(pic_coords, 1.0);
     ...
     return result * FillColor;
    }
    void main() {
     gl_FragColor = vlc_texture(PicCoords);
    }

The video_format_t parameter of vout_display_opengl_Display() is not
used anymore. Remove it.

Texture paddings were computed in _Display(), while the picture format
is known in _Prepare().

This will allow to remove the video_format_t parameter of _Display().

It will be modified to depend on static functions. Move it below them.

This will make the diff more readable.

After the previous changes, two successive loops iterating tex_count
times can now be merged into one.

The multiview mode (stereo) was applied by changing the texture
paddings to crop only the left eye.

The problem is that these texture paddings are specific to the input
picture, while the stereo mode is specific to the renderer, which should
be independent of the input picture.

To separate these concerns, apply the stereo mode using a matrix to
transform the texture coordinates from the renderer.

Apply all texture coordinates transformation in the fragment shader.

This is necessary to be able to implement a renderer independent of the
input picture (i.e. without even knowing the details) by using a single
GLSL function "vlc_texture(vec2 pic_coords)".

Now that the coordinates are independant of paddings (which are
transmitted via a separate transform matrix), there is no need to
recompute them when the paddings change.

A picture is stored in OpenGL textures (one per plane), possibly with
padding (the texture may be larger than the actual picture).

The conversion from pictures coordinates to texture coordinates (which
takes the padding into account) was applied on the input coordinates,
before the vertex shader. As a consequence, the vertex shader received
one vector of input texture coordinates per plane (the padding is not
necessarily the same for all the planes):

    (before this commit)

   picture   texture
   coords    coords        (attributes)      (varyings)
          (1 per plane)

             (x0, y0) --> MultiTexCoord0     TexCoord0     fragment
   (x,y) --> (x1, y1) --> MultiTexCoord1 --> TexCoord1 --> shader
             (x2, y2) --> MultiTexCoord2     TexCoord2

This poses a problem to separate chroma conversion from rendering: the
renderer should be able to retrieve a pixel color in picture
coordinates, regarless of the input format or padding.

To solve this issue, pass the picture coordinates instead of the texture
coordinates as attribute, and initialize uniform matrices to convert
from picture to texture coordinates for each plane directly in the
fragment shader:

    (after this commit)

   picture
   coords    (attribute)     (varying)

   (x,y) --> PicCoordsIn --> PicCoords --> fragment shader
                                             ^^^
                                             |||
                             TexCoordsMap0 --'||
                (uniforms)   TexCoordsMap1 ---'|
                             TexCoordsMap2 ----'

Note that this also changes the multiplication order of
(non-commutative) matrices, from (semantically):

    TexCoords = Orientation * TexCoordsMap * PicCoords

to:

    TexCoords = TexCoordsMap * Orientation * PicCoords

The latter is the correct one: the orientation defines how the input
picture is rotated, so it must apply to picture coordinates, regardless
of the actual coordinates in the texture.

As a side effect, BuildRectangle, BuildSphere and BuildCube are now
independant of both the number of planes and any texture padding.

For now, TexCoordsMap is computed from the renderer, but the goal is to
move it to a separate component (a "sampler").

Expose in vlc_gl_api whether it supports non-power of 2 textures.

The fields is_gles and glexts (extensions) are not specific to interop,
and may be useful without an interop instance.

Pass the whole structure (which will have new fields soon) to interop
and renderers, instead of the virtual table only.

Use a separate component for storing OpenGL API-specific utils (for now,
only the vtable).