[vlc-devel] [PATCH 04/10] opengl: privatize sampler parts
Alexandre Janniaux
ajanni at videolabs.io
Thu Jun 11 16:17:33 CEST 2020
Hi,
Indeed, my bad, then I guess it's ok. :)
Regards,
--
Alexandre Janniaux
Videolabs
On Wed, Jun 10, 2020 at 04:11:01PM +0200, Romain Vimont wrote:
> On Wed, Jun 10, 2020 at 03:22:45PM +0200, Alexandre Janniaux wrote:
> > Hi,
> >
> > I'm not fond of adding yet another naming for private struct
> > given that we already have _sys, _owner, and even _private
> > somewhere.
>
> There are also vlc_player_track_priv, stream_priv_t, vlc_gl_priv_t,
> vout_display_priv_t, picture_priv_t, etc.
>
> > Can you be more explicit about what will be the user of this
> > private part? Can it be a different part depending on what is
> > initializing the sampler?
>
> The private part of the sampler is only used by vout_helper, which
> creates the sampler, destroys it and updates its input picture
> (privately).
>
> (Later in my branch, it's wrapped by vlc_gl_filters, so it will also be
> used indirectly by the OpenGL video filter opengl.c.)
>
> > Regards,
> > --
> > Alexandre Janniaux
> > Videolabs
> >
> > On Thu, Jun 04, 2020 at 11:52:12AM +0200, Romain Vimont wrote:
> > > Hide sampler implementation details from renderer.
> > >
> > > This will allow to expose only what OpenGL filters need in the public
> > > API.
> > > ---
> > > modules/video_output/Makefile.am | 1 +
> > > modules/video_output/opengl/sampler.c | 311 ++++++++++++---------
> > > modules/video_output/opengl/sampler.h | 67 -----
> > > modules/video_output/opengl/sampler_priv.h | 57 ++++
> > > modules/video_output/opengl/vout_helper.c | 1 +
> > > 5 files changed, 244 insertions(+), 193 deletions(-)
> > > create mode 100644 modules/video_output/opengl/sampler_priv.h
> > >
> > > diff --git a/modules/video_output/Makefile.am b/modules/video_output/Makefile.am
> > > index 36ad308081f3..4b2151679c4f 100644
> > > --- a/modules/video_output/Makefile.am
> > > +++ b/modules/video_output/Makefile.am
> > > @@ -17,6 +17,7 @@ OPENGL_COMMONSOURCES = video_output/opengl/vout_helper.c \
> > > video_output/opengl/renderer.h \
> > > video_output/opengl/sampler.c \
> > > video_output/opengl/sampler.h \
> > > + video_output/opengl/sampler_priv.h \
> > > video_output/opengl/sub_renderer.c \
> > > video_output/opengl/sub_renderer.h
> > > if HAVE_LIBPLACEBO
> > > diff --git a/modules/video_output/opengl/sampler.c b/modules/video_output/opengl/sampler.c
> > > index 22ddf67e4840..1028c5103a93 100644
> > > --- a/modules/video_output/opengl/sampler.c
> > > +++ b/modules/video_output/opengl/sampler.c
> > > @@ -22,10 +22,9 @@
> > > # include "config.h"
> > > #endif
> > >
> > > -#include "sampler.h"
> > > +#include "sampler_priv.h"
> > >
> > > #include <vlc_common.h>
> > > -#include <vlc_es.h>
> > > #include <vlc_memstream.h>
> > > #include <vlc_opengl.h>
> > >
> > > @@ -41,6 +40,52 @@
> > > #include "internal.h"
> > > #include "interop.h"
> > >
> > > +struct vlc_gl_sampler_priv {
> > > + struct vlc_gl_sampler sampler;
> > > +
> > > + struct vlc_gl_t *gl;
> > > + const opengl_vtable_t *vt;
> > > +
> > > + struct {
> > > + GLfloat OrientationMatrix[4*4];
> > > + GLfloat TexCoordsMap[PICTURE_PLANE_MAX][3*3];
> > > + } var;
> > > + struct {
> > > + GLint Texture[PICTURE_PLANE_MAX];
> > > + GLint TexSize[PICTURE_PLANE_MAX]; /* for GL_TEXTURE_RECTANGLE */
> > > + GLint ConvMatrix;
> > > + GLint *pl_vars; /* for pl_sh_res */
> > > +
> > > + GLint TransformMatrix;
> > > + GLint OrientationMatrix;
> > > + GLint TexCoordsMap[PICTURE_PLANE_MAX];
> > > + } uloc;
> > > +
> > > + bool yuv_color;
> > > + GLfloat conv_matrix[4*4];
> > > +
> > > + /* libplacebo context */
> > > + struct pl_context *pl_ctx;
> > > + struct pl_shader *pl_sh;
> > > + const struct pl_shader_res *pl_sh_res;
> > > +
> > > + GLsizei tex_width[PICTURE_PLANE_MAX];
> > > + GLsizei tex_height[PICTURE_PLANE_MAX];
> > > +
> > > + GLuint textures[PICTURE_PLANE_MAX];
> > > +
> > > + struct {
> > > + unsigned int i_x_offset;
> > > + unsigned int i_y_offset;
> > > + unsigned int i_visible_width;
> > > + unsigned int i_visible_height;
> > > + } last_source;
> > > +
> > > + struct vlc_gl_interop *interop;
> > > +};
> > > +
> > > +#define PRIV(sampler) container_of(sampler, struct vlc_gl_sampler_priv, sampler)
> > > +
> > > static const float MATRIX_COLOR_RANGE_LIMITED[4*3] = {
> > > 255.0/219, 0, 0, -255.0/219 * 16.0/255,
> > > 0, 255.0/224, 0, -255.0/224 * 128.0/255,
> > > @@ -136,9 +181,11 @@ sampler_yuv_base_init(struct vlc_gl_sampler *sampler, vlc_fourcc_t chroma,
> > > const vlc_chroma_description_t *desc,
> > > video_color_space_t yuv_space)
> > > {
> > > + struct vlc_gl_sampler_priv *priv = PRIV(sampler);
> > > +
> > > /* The current implementation always converts from limited to full range. */
> > > const video_color_range_t range = COLOR_RANGE_LIMITED;
> > > - float *matrix = sampler->conv_matrix;
> > > + float *matrix = priv->conv_matrix;
> > > init_conv_matrix(matrix, yuv_space, range);
> > >
> > > if (desc->pixel_size == 2)
> > > @@ -171,7 +218,7 @@ sampler_yuv_base_init(struct vlc_gl_sampler *sampler, vlc_fourcc_t chroma,
> > > }
> > > }
> > >
> > > - sampler->yuv_color = true;
> > > + priv->yuv_color = true;
> > >
> > > /* Some formats require to swap the U and V components.
> > > *
> > > @@ -208,25 +255,26 @@ sampler_yuv_base_init(struct vlc_gl_sampler *sampler, vlc_fourcc_t chroma,
> > > static int
> > > sampler_base_fetch_locations(struct vlc_gl_sampler *sampler, GLuint program)
> > > {
> > > - struct vlc_gl_interop *interop = sampler->interop;
> > > - const opengl_vtable_t *vt = sampler->vt;
> > > + struct vlc_gl_sampler_priv *priv = PRIV(sampler);
> > >
> > > - if (sampler->yuv_color)
> > > + struct vlc_gl_interop *interop = priv->interop;
> > > + const opengl_vtable_t *vt = priv->vt;
> > > +
> > > + if (priv->yuv_color)
> > > {
> > > - sampler->uloc.ConvMatrix = vt->GetUniformLocation(program,
> > > - "ConvMatrix");
> > > - if (sampler->uloc.ConvMatrix == -1)
> > > + priv->uloc.ConvMatrix = vt->GetUniformLocation(program, "ConvMatrix");
> > > + if (priv->uloc.ConvMatrix == -1)
> > > return VLC_EGENERIC;
> > > }
> > >
> > > - sampler->uloc.TransformMatrix =
> > > + priv->uloc.TransformMatrix =
> > > vt->GetUniformLocation(program, "TransformMatrix");
> > > - if (sampler->uloc.TransformMatrix == -1)
> > > + if (priv->uloc.TransformMatrix == -1)
> > > return VLC_EGENERIC;
> > >
> > > - sampler->uloc.OrientationMatrix =
> > > + priv->uloc.OrientationMatrix =
> > > vt->GetUniformLocation(program, "OrientationMatrix");
> > > - if (sampler->uloc.OrientationMatrix == -1)
> > > + if (priv->uloc.OrientationMatrix == -1)
> > > return VLC_EGENERIC;
> > >
> > > assert(interop->tex_count < 10); /* to guarantee variable names length */
> > > @@ -235,29 +283,29 @@ sampler_base_fetch_locations(struct vlc_gl_sampler *sampler, GLuint program)
> > > char name[sizeof("TexCoordsMapX")];
> > >
> > > snprintf(name, sizeof(name), "Texture%1u", i);
> > > - sampler->uloc.Texture[i] = vt->GetUniformLocation(program, name);
> > > - if (sampler->uloc.Texture[i] == -1)
> > > + priv->uloc.Texture[i] = vt->GetUniformLocation(program, name);
> > > + if (priv->uloc.Texture[i] == -1)
> > > return VLC_EGENERIC;
> > >
> > > snprintf(name, sizeof(name), "TexCoordsMap%1u", i);
> > > - sampler->uloc.TexCoordsMap[i] = vt->GetUniformLocation(program, name);
> > > - if (sampler->uloc.TexCoordsMap[i] == -1)
> > > + priv->uloc.TexCoordsMap[i] = vt->GetUniformLocation(program, name);
> > > + if (priv->uloc.TexCoordsMap[i] == -1)
> > > return VLC_EGENERIC;
> > >
> > > if (interop->tex_target == GL_TEXTURE_RECTANGLE)
> > > {
> > > snprintf(name, sizeof(name), "TexSize%1u", i);
> > > - sampler->uloc.TexSize[i] = vt->GetUniformLocation(program, name);
> > > - if (sampler->uloc.TexSize[i] == -1)
> > > + priv->uloc.TexSize[i] = vt->GetUniformLocation(program, name);
> > > + if (priv->uloc.TexSize[i] == -1)
> > > return VLC_EGENERIC;
> > > }
> > > }
> > >
> > > #ifdef HAVE_LIBPLACEBO
> > > - const struct pl_shader_res *res = sampler->pl_sh_res;
> > > + const struct pl_shader_res *res = priv->pl_sh_res;
> > > for (int i = 0; res && i < res->num_variables; i++) {
> > > struct pl_shader_var sv = res->variables[i];
> > > - sampler->uloc.pl_vars[i] = vt->GetUniformLocation(program, sv.var.name);
> > > + priv->uloc.pl_vars[i] = vt->GetUniformLocation(program, sv.var.name);
> > > }
> > > #endif
> > >
> > > @@ -278,42 +326,44 @@ GetTransformMatrix(const struct vlc_gl_interop *interop)
> > > static void
> > > sampler_base_prepare_shader(const struct vlc_gl_sampler *sampler)
> > > {
> > > - const struct vlc_gl_interop *interop = sampler->interop;
> > > - const opengl_vtable_t *vt = sampler->vt;
> > > + struct vlc_gl_sampler_priv *priv = PRIV(sampler);
> > > +
> > > + const struct vlc_gl_interop *interop = priv->interop;
> > > + const opengl_vtable_t *vt = priv->vt;
> > >
> > > - if (sampler->yuv_color)
> > > - vt->UniformMatrix4fv(sampler->uloc.ConvMatrix, 1, GL_FALSE,
> > > - sampler->conv_matrix);
> > > + if (priv->yuv_color)
> > > + vt->UniformMatrix4fv(priv->uloc.ConvMatrix, 1, GL_FALSE,
> > > + priv->conv_matrix);
> > >
> > > for (unsigned i = 0; i < interop->tex_count; ++i)
> > > {
> > > - vt->Uniform1i(sampler->uloc.Texture[i], i);
> > > + vt->Uniform1i(priv->uloc.Texture[i], i);
> > >
> > > - assert(sampler->textures[i] != 0);
> > > + assert(priv->textures[i] != 0);
> > > vt->ActiveTexture(GL_TEXTURE0 + i);
> > > - vt->BindTexture(interop->tex_target, sampler->textures[i]);
> > > + vt->BindTexture(interop->tex_target, priv->textures[i]);
> > >
> > > - vt->UniformMatrix3fv(sampler->uloc.TexCoordsMap[i], 1, GL_FALSE,
> > > - sampler->var.TexCoordsMap[i]);
> > > + vt->UniformMatrix3fv(priv->uloc.TexCoordsMap[i], 1, GL_FALSE,
> > > + priv->var.TexCoordsMap[i]);
> > > }
> > >
> > > const GLfloat *tm = GetTransformMatrix(interop);
> > > - vt->UniformMatrix4fv(sampler->uloc.TransformMatrix, 1, GL_FALSE, tm);
> > > + vt->UniformMatrix4fv(priv->uloc.TransformMatrix, 1, GL_FALSE, tm);
> > >
> > > - vt->UniformMatrix4fv(sampler->uloc.OrientationMatrix, 1, GL_FALSE,
> > > - sampler->var.OrientationMatrix);
> > > + vt->UniformMatrix4fv(priv->uloc.OrientationMatrix, 1, GL_FALSE,
> > > + priv->var.OrientationMatrix);
> > >
> > > if (interop->tex_target == GL_TEXTURE_RECTANGLE)
> > > {
> > > for (unsigned i = 0; i < interop->tex_count; ++i)
> > > - vt->Uniform2f(sampler->uloc.TexSize[i], sampler->tex_width[i],
> > > - sampler->tex_height[i]);
> > > + vt->Uniform2f(priv->uloc.TexSize[i], priv->tex_width[i],
> > > + priv->tex_height[i]);
> > > }
> > >
> > > #ifdef HAVE_LIBPLACEBO
> > > - const struct pl_shader_res *res = sampler->pl_sh_res;
> > > + const struct pl_shader_res *res = priv->pl_sh_res;
> > > for (int i = 0; res && i < res->num_variables; i++) {
> > > - GLint loc = sampler->uloc.pl_vars[i];
> > > + GLint loc = priv->uloc.pl_vars[i];
> > > if (loc == -1) // uniform optimized out
> > > continue;
> > >
> > > @@ -347,25 +397,26 @@ sampler_base_prepare_shader(const struct vlc_gl_sampler *sampler)
> > > static int
> > > sampler_xyz12_fetch_locations(struct vlc_gl_sampler *sampler, GLuint program)
> > > {
> > > - const opengl_vtable_t *vt = sampler->vt;
> > > + struct vlc_gl_sampler_priv *priv = PRIV(sampler);
> > > + const opengl_vtable_t *vt = priv->vt;
> > >
> > > - sampler->uloc.Texture[0] = vt->GetUniformLocation(program, "Texture0");
> > > - if (sampler->uloc.Texture[0] == -1)
> > > + priv->uloc.Texture[0] = vt->GetUniformLocation(program, "Texture0");
> > > + if (priv->uloc.Texture[0] == -1)
> > > return VLC_EGENERIC;
> > >
> > > - sampler->uloc.TransformMatrix =
> > > + priv->uloc.TransformMatrix =
> > > vt->GetUniformLocation(program, "TransformMatrix");
> > > - if (sampler->uloc.TransformMatrix == -1)
> > > + if (priv->uloc.TransformMatrix == -1)
> > > return VLC_EGENERIC;
> > >
> > > - sampler->uloc.OrientationMatrix =
> > > + priv->uloc.OrientationMatrix =
> > > vt->GetUniformLocation(program, "OrientationMatrix");
> > > - if (sampler->uloc.OrientationMatrix == -1)
> > > + if (priv->uloc.OrientationMatrix == -1)
> > > return VLC_EGENERIC;
> > >
> > > - sampler->uloc.TexCoordsMap[0] =
> > > + priv->uloc.TexCoordsMap[0] =
> > > vt->GetUniformLocation(program, "TexCoordsMap0");
> > > - if (sampler->uloc.TexCoordsMap[0] == -1)
> > > + if (priv->uloc.TexCoordsMap[0] == -1)
> > > return VLC_EGENERIC;
> > >
> > > return VLC_SUCCESS;
> > > @@ -374,23 +425,24 @@ sampler_xyz12_fetch_locations(struct vlc_gl_sampler *sampler, GLuint program)
> > > static void
> > > sampler_xyz12_prepare_shader(const struct vlc_gl_sampler *sampler)
> > > {
> > > - const struct vlc_gl_interop *interop = sampler->interop;
> > > - const opengl_vtable_t *vt = sampler->vt;
> > > + struct vlc_gl_sampler_priv *priv = PRIV(sampler);
> > > + const struct vlc_gl_interop *interop = priv->interop;
> > > + const opengl_vtable_t *vt = priv->vt;
> > >
> > > - vt->Uniform1i(sampler->uloc.Texture[0], 0);
> > > + vt->Uniform1i(priv->uloc.Texture[0], 0);
> > >
> > > - assert(sampler->textures[0] != 0);
> > > + assert(priv->textures[0] != 0);
> > > vt->ActiveTexture(GL_TEXTURE0);
> > > - vt->BindTexture(interop->tex_target, sampler->textures[0]);
> > > + vt->BindTexture(interop->tex_target, priv->textures[0]);
> > >
> > > - vt->UniformMatrix3fv(sampler->uloc.TexCoordsMap[0], 1, GL_FALSE,
> > > - sampler->var.TexCoordsMap[0]);
> > > + vt->UniformMatrix3fv(priv->uloc.TexCoordsMap[0], 1, GL_FALSE,
> > > + priv->var.TexCoordsMap[0]);
> > >
> > > const GLfloat *tm = GetTransformMatrix(interop);
> > > - vt->UniformMatrix4fv(sampler->uloc.TransformMatrix, 1, GL_FALSE, tm);
> > > + vt->UniformMatrix4fv(priv->uloc.TransformMatrix, 1, GL_FALSE, tm);
> > >
> > > - vt->UniformMatrix4fv(sampler->uloc.OrientationMatrix, 1, GL_FALSE,
> > > - sampler->var.OrientationMatrix);
> > > + vt->UniformMatrix4fv(priv->uloc.OrientationMatrix, 1, GL_FALSE,
> > > + priv->var.OrientationMatrix);
> > > }
> > >
> > > static int
> > > @@ -572,7 +624,9 @@ opengl_fragment_shader_init(struct vlc_gl_sampler *sampler, GLenum tex_target,
> > > vlc_fourcc_t chroma, video_color_space_t yuv_space,
> > > video_orientation_t orientation)
> > > {
> > > - struct vlc_gl_interop *interop = sampler->interop;
> > > + struct vlc_gl_sampler_priv *priv = PRIV(sampler);
> > > +
> > > + struct vlc_gl_interop *interop = priv->interop;
> > >
> > > const char *swizzle_per_tex[PICTURE_PLANE_MAX] = { NULL, };
> > > const bool is_yuv = vlc_fourcc_IsYUV(chroma);
> > > @@ -582,7 +636,7 @@ opengl_fragment_shader_init(struct vlc_gl_sampler *sampler, GLenum tex_target,
> > > if (desc == NULL)
> > > return VLC_EGENERIC;
> > >
> > > - InitOrientationMatrix(sampler->var.OrientationMatrix, orientation);
> > > + InitOrientationMatrix(priv->var.OrientationMatrix, orientation);
> > >
> > > if (chroma == VLC_CODEC_XYZ12)
> > > return xyz12_shader_init(sampler);
> > > @@ -630,42 +684,42 @@ opengl_fragment_shader_init(struct vlc_gl_sampler *sampler, GLenum tex_target,
> > > "uniform mat3 TexCoordsMap%u;\n", glsl_sampler, i, i);
> > >
> > > #ifdef HAVE_LIBPLACEBO
> > > - if (sampler->pl_sh) {
> > > - struct pl_shader *sh = sampler->pl_sh;
> > > + if (priv->pl_sh) {
> > > + struct pl_shader *sh = priv->pl_sh;
> > > struct pl_color_map_params color_params = pl_color_map_default_params;
> > > - color_params.intent = var_InheritInteger(sampler->gl, "rendering-intent");
> > > - color_params.tone_mapping_algo = var_InheritInteger(sampler->gl, "tone-mapping");
> > > - color_params.tone_mapping_param = var_InheritFloat(sampler->gl, "tone-mapping-param");
> > > + color_params.intent = var_InheritInteger(priv->gl, "rendering-intent");
> > > + color_params.tone_mapping_algo = var_InheritInteger(priv->gl, "tone-mapping");
> > > + color_params.tone_mapping_param = var_InheritFloat(priv->gl, "tone-mapping-param");
> > > # if PL_API_VER >= 10
> > > - color_params.desaturation_strength = var_InheritFloat(sampler->gl, "desat-strength");
> > > - color_params.desaturation_exponent = var_InheritFloat(sampler->gl, "desat-exponent");
> > > - color_params.desaturation_base = var_InheritFloat(sampler->gl, "desat-base");
> > > + color_params.desaturation_strength = var_InheritFloat(priv->gl, "desat-strength");
> > > + color_params.desaturation_exponent = var_InheritFloat(priv->gl, "desat-exponent");
> > > + color_params.desaturation_base = var_InheritFloat(priv->gl, "desat-base");
> > > # else
> > > - color_params.tone_mapping_desaturate = var_InheritFloat(sampler->gl, "tone-mapping-desat");
> > > + color_params.tone_mapping_desaturate = var_InheritFloat(priv->gl, "tone-mapping-desat");
> > > # endif
> > > - color_params.gamut_warning = var_InheritBool(sampler->gl, "tone-mapping-warn");
> > > + color_params.gamut_warning = var_InheritBool(priv->gl, "tone-mapping-warn");
> > >
> > > struct pl_color_space dst_space = pl_color_space_unknown;
> > > - dst_space.primaries = var_InheritInteger(sampler->gl, "target-prim");
> > > - dst_space.transfer = var_InheritInteger(sampler->gl, "target-trc");
> > > + dst_space.primaries = var_InheritInteger(priv->gl, "target-prim");
> > > + dst_space.transfer = var_InheritInteger(priv->gl, "target-trc");
> > >
> > > pl_shader_color_map(sh, &color_params,
> > > vlc_placebo_ColorSpace(&interop->fmt),
> > > dst_space, NULL, false);
> > >
> > > struct pl_shader_obj *dither_state = NULL;
> > > - int method = var_InheritInteger(sampler->gl, "dither-algo");
> > > + int method = var_InheritInteger(priv->gl, "dither-algo");
> > > if (method >= 0) {
> > >
> > > unsigned out_bits = 0;
> > > - int override = var_InheritInteger(sampler->gl, "dither-depth");
> > > + int override = var_InheritInteger(priv->gl, "dither-depth");
> > > if (override > 0)
> > > out_bits = override;
> > > else
> > > {
> > > GLint fb_depth = 0;
> > > #if !defined(USE_OPENGL_ES2)
> > > - const opengl_vtable_t *vt = sampler->vt;
> > > + const opengl_vtable_t *vt = priv->vt;
> > > /* fetch framebuffer depth (we are already bound to the default one). */
> > > if (vt->GetFramebufferAttachmentParameteriv != NULL)
> > > vt->GetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_BACK_LEFT,
> > > @@ -683,11 +737,11 @@ opengl_fragment_shader_init(struct vlc_gl_sampler *sampler, GLenum tex_target,
> > > });
> > > }
> > >
> > > - const struct pl_shader_res *res = sampler->pl_sh_res = pl_shader_finalize(sh);
> > > + const struct pl_shader_res *res = priv->pl_sh_res = pl_shader_finalize(sh);
> > > pl_shader_obj_destroy(&dither_state);
> > >
> > > - FREENULL(sampler->uloc.pl_vars);
> > > - sampler->uloc.pl_vars = calloc(res->num_variables, sizeof(GLint));
> > > + FREENULL(priv->uloc.pl_vars);
> > > + priv->uloc.pl_vars = calloc(res->num_variables, sizeof(GLint));
> > > for (int i = 0; i < res->num_variables; i++) {
> > > struct pl_shader_var sv = res->variables[i];
> > > const char *glsl_type_name = pl_var_glsl_type_name(sv.var);
> > > @@ -705,7 +759,7 @@ opengl_fragment_shader_init(struct vlc_gl_sampler *sampler, GLenum tex_target,
> > > interop->fmt.primaries == COLOR_PRIMARIES_BT2020)
> > > {
> > > // no warning for HLG because it's more or less backwards-compatible
> > > - msg_Warn(sampler->gl, "VLC needs to be built with support for libplacebo "
> > > + msg_Warn(priv->gl, "VLC needs to be built with support for libplacebo "
> > > "in order to display wide gamut or HDR signals correctly.");
> > > }
> > > #endif
> > > @@ -764,8 +818,8 @@ opengl_fragment_shader_init(struct vlc_gl_sampler *sampler, GLenum tex_target,
> > > assert(yuv_space == COLOR_SPACE_UNDEF || color_count == 3);
> > >
> > > #ifdef HAVE_LIBPLACEBO
> > > - if (sampler->pl_sh_res) {
> > > - const struct pl_shader_res *res = sampler->pl_sh_res;
> > > + if (priv->pl_sh_res) {
> > > + const struct pl_shader_res *res = priv->pl_sh_res;
> > > assert(res->input == PL_SHADER_SIG_COLOR);
> > > assert(res->output == PL_SHADER_SIG_COLOR);
> > > ADDF(" result = %s(result);\n", res->name);
> > > @@ -802,18 +856,20 @@ opengl_fragment_shader_init(struct vlc_gl_sampler *sampler, GLenum tex_target,
> > > struct vlc_gl_sampler *
> > > vlc_gl_sampler_New(struct vlc_gl_interop *interop)
> > > {
> > > - struct vlc_gl_sampler *sampler = calloc(1, sizeof(*sampler));
> > > - if (!sampler)
> > > + struct vlc_gl_sampler_priv *priv = calloc(1, sizeof(*priv));
> > > + if (!priv)
> > > return NULL;
> > >
> > > - sampler->uloc.pl_vars = NULL;
> > > - sampler->pl_ctx = NULL;
> > > - sampler->pl_sh = NULL;
> > > - sampler->pl_sh_res = NULL;
> > > + struct vlc_gl_sampler *sampler = &priv->sampler;
> > > +
> > > + priv->uloc.pl_vars = NULL;
> > > + priv->pl_ctx = NULL;
> > > + priv->pl_sh = NULL;
> > > + priv->pl_sh_res = NULL;
> > >
> > > - sampler->interop = interop;
> > > - sampler->gl = interop->gl;
> > > - sampler->vt = interop->vt;
> > > + priv->interop = interop;
> > > + priv->gl = interop->gl;
> > > + priv->vt = interop->vt;
> > >
> > > sampler->fmt = &interop->sw_fmt;
> > >
> > > @@ -822,10 +878,10 @@ vlc_gl_sampler_New(struct vlc_gl_interop *interop)
> > >
> > > #ifdef HAVE_LIBPLACEBO
> > > // Create the main libplacebo context
> > > - sampler->pl_ctx = vlc_placebo_Create(VLC_OBJECT(interop->gl));
> > > - if (sampler->pl_ctx) {
> > > + priv->pl_ctx = vlc_placebo_Create(VLC_OBJECT(interop->gl));
> > > + if (priv->pl_ctx) {
> > > # if PL_API_VER >= 20
> > > - sampler->pl_sh = pl_shader_alloc(sampler->pl_ctx, &(struct pl_shader_params) {
> > > + priv->pl_sh = pl_shader_alloc(priv->pl_ctx, &(struct pl_shader_params) {
> > > .glsl = {
> > > # ifdef USE_OPENGL_ES2
> > > .version = 100,
> > > @@ -836,9 +892,9 @@ vlc_gl_sampler_New(struct vlc_gl_interop *interop)
> > > },
> > > });
> > > # elif PL_API_VER >= 6
> > > - sampler->pl_sh = pl_shader_alloc(sampler->pl_ctx, NULL, 0);
> > > + priv->pl_sh = pl_shader_alloc(priv->pl_ctx, NULL, 0);
> > > # else
> > > - sampler->pl_sh = pl_shader_alloc(sampler->pl_ctx, NULL, 0, 0);
> > > + priv->pl_sh = pl_shader_alloc(priv->pl_ctx, NULL, 0, 0);
> > > # endif
> > > }
> > > #endif
> > > @@ -861,19 +917,19 @@ vlc_gl_sampler_New(struct vlc_gl_interop *interop)
> > > const GLsizei h = interop->fmt.i_visible_height * interop->texs[j].h.num
> > > / interop->texs[j].h.den;
> > > if (interop->api->supports_npot) {
> > > - sampler->tex_width[j] = w;
> > > - sampler->tex_height[j] = h;
> > > + priv->tex_width[j] = w;
> > > + priv->tex_height[j] = h;
> > > } else {
> > > - sampler->tex_width[j] = vlc_align_pot(w);
> > > - sampler->tex_height[j] = vlc_align_pot(h);
> > > + priv->tex_width[j] = vlc_align_pot(w);
> > > + priv->tex_height[j] = vlc_align_pot(h);
> > > }
> > > }
> > >
> > > if (!interop->handle_texs_gen)
> > > {
> > > - ret = vlc_gl_interop_GenerateTextures(interop, sampler->tex_width,
> > > - sampler->tex_height,
> > > - sampler->textures);
> > > + ret = vlc_gl_interop_GenerateTextures(interop, priv->tex_width,
> > > + priv->tex_height,
> > > + priv->textures);
> > > if (ret != VLC_SUCCESS)
> > > {
> > > free(sampler);
> > > @@ -887,43 +943,47 @@ vlc_gl_sampler_New(struct vlc_gl_interop *interop)
> > > void
> > > vlc_gl_sampler_Delete(struct vlc_gl_sampler *sampler)
> > > {
> > > - struct vlc_gl_interop *interop = sampler->interop;
> > > + struct vlc_gl_sampler_priv *priv = PRIV(sampler);
> > > +
> > > + struct vlc_gl_interop *interop = priv->interop;
> > > const opengl_vtable_t *vt = interop->vt;
> > >
> > > if (!interop->handle_texs_gen)
> > > - vt->DeleteTextures(interop->tex_count, sampler->textures);
> > > + vt->DeleteTextures(interop->tex_count, priv->textures);
> > >
> > > #ifdef HAVE_LIBPLACEBO
> > > - FREENULL(sampler->uloc.pl_vars);
> > > - if (sampler->pl_ctx)
> > > - pl_context_destroy(&sampler->pl_ctx);
> > > + FREENULL(priv->uloc.pl_vars);
> > > + if (priv->pl_ctx)
> > > + pl_context_destroy(&priv->pl_ctx);
> > > #endif
> > >
> > > free(sampler->shader.extensions);
> > > free(sampler->shader.body);
> > >
> > > - free(sampler);
> > > + free(priv);
> > > }
> > >
> > > int
> > > vlc_gl_sampler_Update(struct vlc_gl_sampler *sampler, picture_t *picture)
> > > {
> > > - const struct vlc_gl_interop *interop = sampler->interop;
> > > + struct vlc_gl_sampler_priv *priv = PRIV(sampler);
> > > +
> > > + const struct vlc_gl_interop *interop = priv->interop;
> > > const video_format_t *source = &picture->format;
> > >
> > > - if (source->i_x_offset != sampler->last_source.i_x_offset
> > > - || source->i_y_offset != sampler->last_source.i_y_offset
> > > - || source->i_visible_width != sampler->last_source.i_visible_width
> > > - || source->i_visible_height != sampler->last_source.i_visible_height)
> > > + if (source->i_x_offset != priv->last_source.i_x_offset
> > > + || source->i_y_offset != priv->last_source.i_y_offset
> > > + || source->i_visible_width != priv->last_source.i_visible_width
> > > + || source->i_visible_height != priv->last_source.i_visible_height)
> > > {
> > > - memset(sampler->var.TexCoordsMap, 0,
> > > - sizeof(sampler->var.TexCoordsMap));
> > > + memset(priv->var.TexCoordsMap, 0,
> > > + sizeof(priv->var.TexCoordsMap));
> > > for (unsigned j = 0; j < interop->tex_count; j++)
> > > {
> > > float scale_w = (float)interop->texs[j].w.num / interop->texs[j].w.den
> > > - / sampler->tex_width[j];
> > > + / priv->tex_width[j];
> > > float scale_h = (float)interop->texs[j].h.num / interop->texs[j].h.den
> > > - / sampler->tex_height[j];
> > > + / priv->tex_height[j];
> > >
> > > /* Warning: if NPOT is not supported a larger texture is
> > > allocated. This will cause right and bottom coordinates to
> > > @@ -974,7 +1034,7 @@ vlc_gl_sampler_Update(struct vlc_gl_sampler *sampler, picture_t *picture)
> > > *
> > > * It is stored in column-major order.
> > > */
> > > - GLfloat *matrix = sampler->var.TexCoordsMap[j];
> > > + GLfloat *matrix = priv->var.TexCoordsMap[j];
> > > #define COL(x) (x*3)
> > > #define ROW(x) (x)
> > > matrix[COL(0) + ROW(0)] = right - left;
> > > @@ -986,15 +1046,14 @@ vlc_gl_sampler_Update(struct vlc_gl_sampler *sampler, picture_t *picture)
> > > #undef ROW
> > > }
> > >
> > > - sampler->last_source.i_x_offset = source->i_x_offset;
> > > - sampler->last_source.i_y_offset = source->i_y_offset;
> > > - sampler->last_source.i_visible_width = source->i_visible_width;
> > > - sampler->last_source.i_visible_height = source->i_visible_height;
> > > + priv->last_source.i_x_offset = source->i_x_offset;
> > > + priv->last_source.i_y_offset = source->i_y_offset;
> > > + priv->last_source.i_visible_width = source->i_visible_width;
> > > + priv->last_source.i_visible_height = source->i_visible_height;
> > > }
> > >
> > > /* Update the texture */
> > > - return interop->ops->update_textures(interop, sampler->textures,
> > > - sampler->tex_width,
> > > - sampler->tex_height, picture,
> > > - NULL);
> > > + return interop->ops->update_textures(interop, priv->textures,
> > > + priv->tex_width, priv->tex_height,
> > > + picture, NULL);
> > > }
> > > diff --git a/modules/video_output/opengl/sampler.h b/modules/video_output/opengl/sampler.h
> > > index dd40692843f6..4b0c305c4e71 100644
> > > --- a/modules/video_output/opengl/sampler.h
> > > +++ b/modules/video_output/opengl/sampler.h
> > > @@ -50,49 +50,9 @@
> > > * implicitly available.
> > > */
> > > struct vlc_gl_sampler {
> > > - struct vlc_gl_t *gl;
> > > - const opengl_vtable_t *vt;
> > > -
> > > /* Input format */
> > > const video_format_t *fmt;
> > >
> > > - struct {
> > > - GLfloat OrientationMatrix[4*4];
> > > - GLfloat TexCoordsMap[PICTURE_PLANE_MAX][3*3];
> > > - } var;
> > > - struct {
> > > - GLint Texture[PICTURE_PLANE_MAX];
> > > - GLint TexSize[PICTURE_PLANE_MAX]; /* for GL_TEXTURE_RECTANGLE */
> > > - GLint ConvMatrix;
> > > - GLint *pl_vars; /* for pl_sh_res */
> > > -
> > > - GLint TransformMatrix;
> > > - GLint OrientationMatrix;
> > > - GLint TexCoordsMap[PICTURE_PLANE_MAX];
> > > - } uloc;
> > > -
> > > - bool yuv_color;
> > > - GLfloat conv_matrix[4*4];
> > > -
> > > - /* libplacebo context */
> > > - struct pl_context *pl_ctx;
> > > - struct pl_shader *pl_sh;
> > > - const struct pl_shader_res *pl_sh_res;
> > > -
> > > - GLsizei tex_width[PICTURE_PLANE_MAX];
> > > - GLsizei tex_height[PICTURE_PLANE_MAX];
> > > -
> > > - GLuint textures[PICTURE_PLANE_MAX];
> > > -
> > > - struct {
> > > - unsigned int i_x_offset;
> > > - unsigned int i_y_offset;
> > > - unsigned int i_visible_width;
> > > - unsigned int i_visible_height;
> > > - } last_source;
> > > -
> > > - struct vlc_gl_interop *interop;
> > > -
> > > struct {
> > > /**
> > > * Piece of fragment shader code declaration OpenGL extensions.
> > > @@ -140,33 +100,6 @@ struct vlc_gl_sampler {
> > > void (*pf_prepare_shader)(const struct vlc_gl_sampler *sampler);
> > > };
> > >
> > > -/**
> > > - * Create a new sampler
> > > - *
> > > - * \param interop the interop
> > > - */
> > > -struct vlc_gl_sampler *
> > > -vlc_gl_sampler_New(struct vlc_gl_interop *interop);
> > > -
> > > -/**
> > > - * Delete a sampler
> > > - *
> > > - * \param sampler the sampler
> > > - */
> > > -void
> > > -vlc_gl_sampler_Delete(struct vlc_gl_sampler *sampler);
> > > -
> > > -/**
> > > - * Update the input picture
> > > - *
> > > - * This changes the current input picture, available from the fragment shader.
> > > - *
> > > - * \param sampler the sampler
> > > - * \param picture the new picture
> > > - */
> > > -int
> > > -vlc_gl_sampler_Update(struct vlc_gl_sampler *sampler, picture_t *picture);
> > > -
> > > static inline int
> > > vlc_gl_sampler_FetchLocations(struct vlc_gl_sampler *sampler, GLuint program)
> > > {
> > > diff --git a/modules/video_output/opengl/sampler_priv.h b/modules/video_output/opengl/sampler_priv.h
> > > new file mode 100644
> > > index 000000000000..ccd96b60c4e5
> > > --- /dev/null
> > > +++ b/modules/video_output/opengl/sampler_priv.h
> > > @@ -0,0 +1,57 @@
> > > +/*****************************************************************************
> > > + * sampler_priv.h
> > > + *****************************************************************************
> > > + * Copyright (C) 2020 VLC authors and VideoLAN
> > > + *
> > > + * This program is free software; you can redistribute it and/or modify it
> > > + * under the terms of the GNU Lesser General Public License as published by
> > > + * the Free Software Foundation; either version 2.1 of the License, or
> > > + * (at your option) any later version.
> > > + *
> > > + * This program is distributed in the hope that it will be useful,
> > > + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> > > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> > > + * GNU Lesser General Public License for more details.
> > > + *
> > > + * You should have received a copy of the GNU Lesser General Public License
> > > + * along with this program; if not, write to the Free Software Foundation,
> > > + * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
> > > + *****************************************************************************/
> > > +
> > > +#ifndef VLC_GL_SAMPLER_PRIV_H
> > > +#define VLC_GL_SAMPLER_PRIV_H
> > > +
> > > +#include <vlc_common.h>
> > > +
> > > +#include "sampler.h"
> > > +
> > > +struct vlc_gl_interop;
> > > +
> > > +/**
> > > + * Create a new sampler
> > > + *
> > > + * \param interop the interop
> > > + */
> > > +struct vlc_gl_sampler *
> > > +vlc_gl_sampler_New(struct vlc_gl_interop *interop);
> > > +
> > > +/**
> > > + * Delete a sampler
> > > + *
> > > + * \param sampler the sampler
> > > + */
> > > +void
> > > +vlc_gl_sampler_Delete(struct vlc_gl_sampler *sampler);
> > > +
> > > +/**
> > > + * Update the input picture
> > > + *
> > > + * This changes the current input picture, available from the fragment shader.
> > > + *
> > > + * \param sampler the sampler
> > > + * \param picture the new picture
> > > + */
> > > +int
> > > +vlc_gl_sampler_Update(struct vlc_gl_sampler *sampler, picture_t *picture);
> > > +
> > > +#endif
> > > diff --git a/modules/video_output/opengl/vout_helper.c b/modules/video_output/opengl/vout_helper.c
> > > index 806360e255c3..3f8cd816af52 100644
> > > --- a/modules/video_output/opengl/vout_helper.c
> > > +++ b/modules/video_output/opengl/vout_helper.c
> > > @@ -45,6 +45,7 @@
> > > #include "internal.h"
> > > #include "renderer.h"
> > > #include "sampler.h"
> > > +#include "sampler_priv.h"
> > > #include "sub_renderer.h"
> > >
> > > struct vout_display_opengl_t {
> > > --
> > > 2.27.0
> > >
> > > _______________________________________________
> > > vlc-devel mailing list
> > > To unsubscribe or modify your subscription options:
> > > https://mailman.videolan.org/listinfo/vlc-devel
> > _______________________________________________
> > vlc-devel mailing list
> > To unsubscribe or modify your subscription options:
> > https://mailman.videolan.org/listinfo/vlc-devel
> _______________________________________________
> vlc-devel mailing list
> To unsubscribe or modify your subscription options:
> https://mailman.videolan.org/listinfo/vlc-devel
More information about the vlc-devel
mailing list