2015-01-28 18:40:46 +00:00
|
|
|
/*
|
|
|
|
|
* This file is part of mpv.
|
|
|
|
|
* Parts based on MPlayer code by Reimar Döffinger.
|
|
|
|
|
*
|
2016-01-19 17:36:34 +00:00
|
|
|
* mpv 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.
|
2015-01-28 18:40:46 +00:00
|
|
|
*
|
|
|
|
|
* mpv 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
|
2016-01-19 17:36:34 +00:00
|
|
|
* GNU Lesser General Public License for more details.
|
2015-01-28 18:40:46 +00:00
|
|
|
*
|
2016-01-19 17:36:34 +00:00
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
|
* License along with mpv. If not, see <http://www.gnu.org/licenses/>.
|
2015-01-28 18:40:46 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef MP_GL_UTILS_
|
|
|
|
|
#define MP_GL_UTILS_
|
|
|
|
|
|
2017-07-29 18:14:48 +00:00
|
|
|
#include <math.h>
|
|
|
|
|
|
2015-08-29 02:12:56 +00:00
|
|
|
#include "common.h"
|
2017-07-29 18:14:48 +00:00
|
|
|
#include "ra.h"
|
2015-01-28 18:40:46 +00:00
|
|
|
|
|
|
|
|
struct mp_log;
|
|
|
|
|
|
2016-05-23 19:25:43 +00:00
|
|
|
void gl_check_error(GL *gl, struct mp_log *log, const char *info);
|
2015-01-28 18:40:46 +00:00
|
|
|
|
2016-05-23 19:23:41 +00:00
|
|
|
void gl_upload_tex(GL *gl, GLenum target, GLenum format, GLenum type,
|
|
|
|
|
const void *dataptr, int stride,
|
|
|
|
|
int x, int y, int w, int h);
|
2015-01-28 18:40:46 +00:00
|
|
|
|
2017-03-20 12:31:28 +00:00
|
|
|
mp_image_t *gl_read_fbo_contents(GL *gl, int fbo, int w, int h);
|
2015-01-28 18:40:46 +00:00
|
|
|
|
2015-09-10 18:52:50 +00:00
|
|
|
const char* mp_sampler_type(GLenum texture_target);
|
|
|
|
|
|
2015-01-28 18:40:46 +00:00
|
|
|
// print a multi line string with line numbers (e.g. for shader sources)
|
|
|
|
|
// log, lev: module and log level, as in mp_msg()
|
|
|
|
|
void mp_log_source(struct mp_log *log, int lev, const char *src);
|
|
|
|
|
|
2015-01-28 21:22:29 +00:00
|
|
|
struct gl_vao_entry {
|
2015-01-29 16:19:01 +00:00
|
|
|
// used for shader / glBindAttribLocation
|
2015-01-28 21:22:29 +00:00
|
|
|
const char *name;
|
2015-01-29 16:19:01 +00:00
|
|
|
// glVertexAttribPointer() arguments
|
|
|
|
|
int num_elems; // size (number of elements)
|
2015-01-28 21:22:29 +00:00
|
|
|
GLenum type;
|
|
|
|
|
bool normalized;
|
|
|
|
|
int offset;
|
|
|
|
|
};
|
|
|
|
|
|
2015-01-29 13:58:26 +00:00
|
|
|
struct fbotex {
|
|
|
|
|
GL *gl;
|
|
|
|
|
GLuint fbo;
|
|
|
|
|
GLuint texture;
|
vo_opengl: refactor shader generation (part 1)
The basic idea is to use dynamically generated shaders instead of a
single monolithic file + a ton of ifdefs. Instead of having to setup
every aspect of it separately (like compiling shaders, setting uniforms,
perfoming the actual rendering steps, the GLSL parts), we generate the
GLSL on the fly, and perform the rendering at the same time. The GLSL
is regenerated every frame, but the actual compiled OpenGL-level shaders
are cached, which makes it fast again. Almost all logic can be in a
single place.
The new code is significantly more flexible, which allows us to improve
the code clarity, performance and add more features easily.
This commit is incomplete. It drops almost all previous code, and
readds only the most important things (some of them actually buggy).
The next commit will complete it - it's separate to preserve authorship
information.
2015-03-12 20:57:54 +00:00
|
|
|
GLenum iformat;
|
|
|
|
|
GLenum tex_filter;
|
vo_opengl: refactor pass_read_video and texture binding
This is a pretty major rewrite of the internal texture binding
mechanic, which makes it more flexible.
In general, the difference between the old and current approaches is
that now, all texture description is held in a struct img_tex and only
explicitly bound with pass_bind. (Once bound, a texture unit is assumed
to be set in stone and no longer tied to the img_tex)
This approach makes the code inside pass_read_video significantly more
flexible and cuts down on the number of weird special cases and
spaghetti logic.
It also has some improvements, e.g. cutting down greatly on the number
of unnecessary conversion passes inside pass_read_video (which was
previously mostly done to cope with the fact that the alternative would
have resulted in a combinatorial explosion of code complexity).
Some other notable changes (and potential improvements):
- texture expansion is now *always* handled in pass_read_video, and the
colormatrix never does this anymore. (Which means the code could
probably be removed from the colormatrix generation logic, modulo some
other VOs)
- struct fbo_tex now stores both its "physical" and "logical"
(configured) size, which cuts down on the amount of width/height
baggage on some function calls
- vo_opengl can now technically support textures with different bit
depths (e.g. 10 bit luma, 8 bit chroma) - but the APIs it queries
inside img_format.c doesn't export this (nor does ffmpeg support it,
really) so the status quo of using the same tex_mul for all planes is
kept.
- dumb_mode is now only needed because of the indirect_fbo being in the
main rendering pipeline. If we reintroduce p->use_indirect and thread
a transform through the entire program this could be skipped where
unnecessary, allowing for the removal of dumb_mode. But I'm not sure
how to do this in a clean way. (Which is part of why it got introduced
to begin with)
- It would be trivial to resurrect source-shader now (it would just be
one extra 'if' inside pass_read_video).
2016-03-05 10:29:19 +00:00
|
|
|
int rw, rh; // real (texture) size
|
|
|
|
|
int lw, lh; // logical (configured) size
|
2015-01-29 13:58:26 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
bool fbotex_init(struct fbotex *fbo, GL *gl, struct mp_log *log, int w, int h,
|
vo_opengl: refactor shader generation (part 1)
The basic idea is to use dynamically generated shaders instead of a
single monolithic file + a ton of ifdefs. Instead of having to setup
every aspect of it separately (like compiling shaders, setting uniforms,
perfoming the actual rendering steps, the GLSL parts), we generate the
GLSL on the fly, and perform the rendering at the same time. The GLSL
is regenerated every frame, but the actual compiled OpenGL-level shaders
are cached, which makes it fast again. Almost all logic can be in a
single place.
The new code is significantly more flexible, which allows us to improve
the code clarity, performance and add more features easily.
This commit is incomplete. It drops almost all previous code, and
readds only the most important things (some of them actually buggy).
The next commit will complete it - it's separate to preserve authorship
information.
2015-03-12 20:57:54 +00:00
|
|
|
GLenum iformat);
|
2015-01-29 13:58:26 +00:00
|
|
|
void fbotex_uninit(struct fbotex *fbo);
|
vo_opengl: refactor shader generation (part 1)
The basic idea is to use dynamically generated shaders instead of a
single monolithic file + a ton of ifdefs. Instead of having to setup
every aspect of it separately (like compiling shaders, setting uniforms,
perfoming the actual rendering steps, the GLSL parts), we generate the
GLSL on the fly, and perform the rendering at the same time. The GLSL
is regenerated every frame, but the actual compiled OpenGL-level shaders
are cached, which makes it fast again. Almost all logic can be in a
single place.
The new code is significantly more flexible, which allows us to improve
the code clarity, performance and add more features easily.
This commit is incomplete. It drops almost all previous code, and
readds only the most important things (some of them actually buggy).
The next commit will complete it - it's separate to preserve authorship
information.
2015-03-12 20:57:54 +00:00
|
|
|
bool fbotex_change(struct fbotex *fbo, GL *gl, struct mp_log *log, int w, int h,
|
|
|
|
|
GLenum iformat, int flags);
|
|
|
|
|
#define FBOTEX_FUZZY_W 1
|
|
|
|
|
#define FBOTEX_FUZZY_H 2
|
2015-03-25 22:06:46 +00:00
|
|
|
#define FBOTEX_FUZZY (FBOTEX_FUZZY_W | FBOTEX_FUZZY_H)
|
vo_opengl: refactor shader generation (part 1)
The basic idea is to use dynamically generated shaders instead of a
single monolithic file + a ton of ifdefs. Instead of having to setup
every aspect of it separately (like compiling shaders, setting uniforms,
perfoming the actual rendering steps, the GLSL parts), we generate the
GLSL on the fly, and perform the rendering at the same time. The GLSL
is regenerated every frame, but the actual compiled OpenGL-level shaders
are cached, which makes it fast again. Almost all logic can be in a
single place.
The new code is significantly more flexible, which allows us to improve
the code clarity, performance and add more features easily.
This commit is incomplete. It drops almost all previous code, and
readds only the most important things (some of them actually buggy).
The next commit will complete it - it's separate to preserve authorship
information.
2015-03-12 20:57:54 +00:00
|
|
|
void fbotex_set_filter(struct fbotex *fbo, GLenum gl_filter);
|
2016-05-23 15:31:07 +00:00
|
|
|
void fbotex_invalidate(struct fbotex *fbo);
|
2015-01-29 13:58:26 +00:00
|
|
|
|
2015-03-13 20:14:18 +00:00
|
|
|
// A 3x2 matrix, with the translation part separate.
|
|
|
|
|
struct gl_transform {
|
2016-03-28 14:16:09 +00:00
|
|
|
// row-major, e.g. in mathematical notation:
|
|
|
|
|
// | m[0][0] m[0][1] |
|
|
|
|
|
// | m[1][0] m[1][1] |
|
2015-03-13 20:14:18 +00:00
|
|
|
float m[2][2];
|
|
|
|
|
float t[2];
|
|
|
|
|
};
|
|
|
|
|
|
vo_opengl: refactor pass_read_video and texture binding
This is a pretty major rewrite of the internal texture binding
mechanic, which makes it more flexible.
In general, the difference between the old and current approaches is
that now, all texture description is held in a struct img_tex and only
explicitly bound with pass_bind. (Once bound, a texture unit is assumed
to be set in stone and no longer tied to the img_tex)
This approach makes the code inside pass_read_video significantly more
flexible and cuts down on the number of weird special cases and
spaghetti logic.
It also has some improvements, e.g. cutting down greatly on the number
of unnecessary conversion passes inside pass_read_video (which was
previously mostly done to cope with the fact that the alternative would
have resulted in a combinatorial explosion of code complexity).
Some other notable changes (and potential improvements):
- texture expansion is now *always* handled in pass_read_video, and the
colormatrix never does this anymore. (Which means the code could
probably be removed from the colormatrix generation logic, modulo some
other VOs)
- struct fbo_tex now stores both its "physical" and "logical"
(configured) size, which cuts down on the amount of width/height
baggage on some function calls
- vo_opengl can now technically support textures with different bit
depths (e.g. 10 bit luma, 8 bit chroma) - but the APIs it queries
inside img_format.c doesn't export this (nor does ffmpeg support it,
really) so the status quo of using the same tex_mul for all planes is
kept.
- dumb_mode is now only needed because of the indirect_fbo being in the
main rendering pipeline. If we reintroduce p->use_indirect and thread
a transform through the entire program this could be skipped where
unnecessary, allowing for the removal of dumb_mode. But I'm not sure
how to do this in a clean way. (Which is part of why it got introduced
to begin with)
- It would be trivial to resurrect source-shader now (it would just be
one extra 'if' inside pass_read_video).
2016-03-05 10:29:19 +00:00
|
|
|
static const struct gl_transform identity_trans = {
|
|
|
|
|
.m = {{1.0, 0.0}, {0.0, 1.0}},
|
|
|
|
|
.t = {0.0, 0.0},
|
|
|
|
|
};
|
|
|
|
|
|
2015-03-13 20:14:18 +00:00
|
|
|
void gl_transform_ortho(struct gl_transform *t, float x0, float x1,
|
|
|
|
|
float y0, float y1);
|
2015-01-29 13:58:26 +00:00
|
|
|
|
vo_opengl: refactor shader generation (part 2)
This adds stuff related to gamma, linear light, sigmoid, BT.2020-CL,
etc, as well as color management. Also adds a new gamma function (gamma22).
This adds new parameters to configure the CMS settings, in particular
letting us target simple colorspaces without requiring usage of a 3DLUT.
This adds smoothmotion. Mostly working, but it's still sensitive to
timing issues. It's based on an actual queue now, but the queue size
is kept small to avoid larger amounts of latency.
Also makes “upscale before blending” the default strategy.
This is justified because the "render after blending" thing doesn't seme
to work consistently any way (introduces stutter due to the way vsync
timing works, or something), so this behavior is a bit closer to master
and makes pausing/unpausing less weird/jumpy.
This adds the remaining scalers, including bicubic_fast, sharpen3,
sharpen5, polar filters and antiringing. Apparently, sharpen3/5 also
consult scale-param1, which was undocumented in master.
This also implements cropping and chroma transformation, plus
rotation/flipping. These are inherently part of the same logic, although
it's a bit rough around the edges in some case, mainly due to the fallback
code paths (for bilinear scaling without indirection).
2015-03-12 21:18:16 +00:00
|
|
|
// This treats m as an affine transformation, in other words m[2][n] gets
|
|
|
|
|
// added to the output.
|
2015-03-13 20:14:18 +00:00
|
|
|
static inline void gl_transform_vec(struct gl_transform t, float *x, float *y)
|
vo_opengl: refactor shader generation (part 1)
The basic idea is to use dynamically generated shaders instead of a
single monolithic file + a ton of ifdefs. Instead of having to setup
every aspect of it separately (like compiling shaders, setting uniforms,
perfoming the actual rendering steps, the GLSL parts), we generate the
GLSL on the fly, and perform the rendering at the same time. The GLSL
is regenerated every frame, but the actual compiled OpenGL-level shaders
are cached, which makes it fast again. Almost all logic can be in a
single place.
The new code is significantly more flexible, which allows us to improve
the code clarity, performance and add more features easily.
This commit is incomplete. It drops almost all previous code, and
readds only the most important things (some of them actually buggy).
The next commit will complete it - it's separate to preserve authorship
information.
2015-03-12 20:57:54 +00:00
|
|
|
{
|
|
|
|
|
float vx = *x, vy = *y;
|
2016-03-28 14:16:09 +00:00
|
|
|
*x = vx * t.m[0][0] + vy * t.m[0][1] + t.t[0];
|
|
|
|
|
*y = vx * t.m[1][0] + vy * t.m[1][1] + t.t[1];
|
vo_opengl: refactor shader generation (part 1)
The basic idea is to use dynamically generated shaders instead of a
single monolithic file + a ton of ifdefs. Instead of having to setup
every aspect of it separately (like compiling shaders, setting uniforms,
perfoming the actual rendering steps, the GLSL parts), we generate the
GLSL on the fly, and perform the rendering at the same time. The GLSL
is regenerated every frame, but the actual compiled OpenGL-level shaders
are cached, which makes it fast again. Almost all logic can be in a
single place.
The new code is significantly more flexible, which allows us to improve
the code clarity, performance and add more features easily.
This commit is incomplete. It drops almost all previous code, and
readds only the most important things (some of them actually buggy).
The next commit will complete it - it's separate to preserve authorship
information.
2015-03-12 20:57:54 +00:00
|
|
|
}
|
|
|
|
|
|
vo_opengl: refactor shader generation (part 2)
This adds stuff related to gamma, linear light, sigmoid, BT.2020-CL,
etc, as well as color management. Also adds a new gamma function (gamma22).
This adds new parameters to configure the CMS settings, in particular
letting us target simple colorspaces without requiring usage of a 3DLUT.
This adds smoothmotion. Mostly working, but it's still sensitive to
timing issues. It's based on an actual queue now, but the queue size
is kept small to avoid larger amounts of latency.
Also makes “upscale before blending” the default strategy.
This is justified because the "render after blending" thing doesn't seme
to work consistently any way (introduces stutter due to the way vsync
timing works, or something), so this behavior is a bit closer to master
and makes pausing/unpausing less weird/jumpy.
This adds the remaining scalers, including bicubic_fast, sharpen3,
sharpen5, polar filters and antiringing. Apparently, sharpen3/5 also
consult scale-param1, which was undocumented in master.
This also implements cropping and chroma transformation, plus
rotation/flipping. These are inherently part of the same logic, although
it's a bit rough around the edges in some case, mainly due to the fallback
code paths (for bilinear scaling without indirection).
2015-03-12 21:18:16 +00:00
|
|
|
struct mp_rect_f {
|
|
|
|
|
float x0, y0, x1, y1;
|
|
|
|
|
};
|
|
|
|
|
|
2016-04-16 16:14:32 +00:00
|
|
|
// Semantic equality (fuzzy comparison)
|
|
|
|
|
static inline bool mp_rect_f_seq(struct mp_rect_f a, struct mp_rect_f b)
|
|
|
|
|
{
|
|
|
|
|
return fabs(a.x0 - b.x0) < 1e-6 && fabs(a.x1 - b.x1) < 1e-6 &&
|
|
|
|
|
fabs(a.y0 - b.y0) < 1e-6 && fabs(a.y1 - b.y1) < 1e-6;
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-13 20:14:18 +00:00
|
|
|
static inline void gl_transform_rect(struct gl_transform t, struct mp_rect_f *r)
|
vo_opengl: refactor shader generation (part 2)
This adds stuff related to gamma, linear light, sigmoid, BT.2020-CL,
etc, as well as color management. Also adds a new gamma function (gamma22).
This adds new parameters to configure the CMS settings, in particular
letting us target simple colorspaces without requiring usage of a 3DLUT.
This adds smoothmotion. Mostly working, but it's still sensitive to
timing issues. It's based on an actual queue now, but the queue size
is kept small to avoid larger amounts of latency.
Also makes “upscale before blending” the default strategy.
This is justified because the "render after blending" thing doesn't seme
to work consistently any way (introduces stutter due to the way vsync
timing works, or something), so this behavior is a bit closer to master
and makes pausing/unpausing less weird/jumpy.
This adds the remaining scalers, including bicubic_fast, sharpen3,
sharpen5, polar filters and antiringing. Apparently, sharpen3/5 also
consult scale-param1, which was undocumented in master.
This also implements cropping and chroma transformation, plus
rotation/flipping. These are inherently part of the same logic, although
it's a bit rough around the edges in some case, mainly due to the fallback
code paths (for bilinear scaling without indirection).
2015-03-12 21:18:16 +00:00
|
|
|
{
|
2015-03-13 20:14:18 +00:00
|
|
|
gl_transform_vec(t, &r->x0, &r->y0);
|
|
|
|
|
gl_transform_vec(t, &r->x1, &r->y1);
|
vo_opengl: refactor shader generation (part 2)
This adds stuff related to gamma, linear light, sigmoid, BT.2020-CL,
etc, as well as color management. Also adds a new gamma function (gamma22).
This adds new parameters to configure the CMS settings, in particular
letting us target simple colorspaces without requiring usage of a 3DLUT.
This adds smoothmotion. Mostly working, but it's still sensitive to
timing issues. It's based on an actual queue now, but the queue size
is kept small to avoid larger amounts of latency.
Also makes “upscale before blending” the default strategy.
This is justified because the "render after blending" thing doesn't seme
to work consistently any way (introduces stutter due to the way vsync
timing works, or something), so this behavior is a bit closer to master
and makes pausing/unpausing less weird/jumpy.
This adds the remaining scalers, including bicubic_fast, sharpen3,
sharpen5, polar filters and antiringing. Apparently, sharpen3/5 also
consult scale-param1, which was undocumented in master.
This also implements cropping and chroma transformation, plus
rotation/flipping. These are inherently part of the same logic, although
it's a bit rough around the edges in some case, mainly due to the fallback
code paths (for bilinear scaling without indirection).
2015-03-12 21:18:16 +00:00
|
|
|
}
|
|
|
|
|
|
vo_opengl: refactor pass_read_video and texture binding
This is a pretty major rewrite of the internal texture binding
mechanic, which makes it more flexible.
In general, the difference between the old and current approaches is
that now, all texture description is held in a struct img_tex and only
explicitly bound with pass_bind. (Once bound, a texture unit is assumed
to be set in stone and no longer tied to the img_tex)
This approach makes the code inside pass_read_video significantly more
flexible and cuts down on the number of weird special cases and
spaghetti logic.
It also has some improvements, e.g. cutting down greatly on the number
of unnecessary conversion passes inside pass_read_video (which was
previously mostly done to cope with the fact that the alternative would
have resulted in a combinatorial explosion of code complexity).
Some other notable changes (and potential improvements):
- texture expansion is now *always* handled in pass_read_video, and the
colormatrix never does this anymore. (Which means the code could
probably be removed from the colormatrix generation logic, modulo some
other VOs)
- struct fbo_tex now stores both its "physical" and "logical"
(configured) size, which cuts down on the amount of width/height
baggage on some function calls
- vo_opengl can now technically support textures with different bit
depths (e.g. 10 bit luma, 8 bit chroma) - but the APIs it queries
inside img_format.c doesn't export this (nor does ffmpeg support it,
really) so the status quo of using the same tex_mul for all planes is
kept.
- dumb_mode is now only needed because of the indirect_fbo being in the
main rendering pipeline. If we reintroduce p->use_indirect and thread
a transform through the entire program this could be skipped where
unnecessary, allowing for the removal of dumb_mode. But I'm not sure
how to do this in a clean way. (Which is part of why it got introduced
to begin with)
- It would be trivial to resurrect source-shader now (it would just be
one extra 'if' inside pass_read_video).
2016-03-05 10:29:19 +00:00
|
|
|
static inline bool gl_transform_eq(struct gl_transform a, struct gl_transform b)
|
|
|
|
|
{
|
|
|
|
|
for (int x = 0; x < 2; x++) {
|
|
|
|
|
for (int y = 0; y < 2; y++) {
|
|
|
|
|
if (a.m[x][y] != b.m[x][y])
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return a.t[0] == b.t[0] && a.t[1] == b.t[1];
|
|
|
|
|
}
|
|
|
|
|
|
2015-10-26 22:43:48 +00:00
|
|
|
void gl_transform_trans(struct gl_transform t, struct gl_transform *x);
|
|
|
|
|
|
2015-01-29 14:50:21 +00:00
|
|
|
void gl_set_debug_logger(GL *gl, struct mp_log *log);
|
|
|
|
|
|
vo_opengl: refactor shader generation (part 1)
The basic idea is to use dynamically generated shaders instead of a
single monolithic file + a ton of ifdefs. Instead of having to setup
every aspect of it separately (like compiling shaders, setting uniforms,
perfoming the actual rendering steps, the GLSL parts), we generate the
GLSL on the fly, and perform the rendering at the same time. The GLSL
is regenerated every frame, but the actual compiled OpenGL-level shaders
are cached, which makes it fast again. Almost all logic can be in a
single place.
The new code is significantly more flexible, which allows us to improve
the code clarity, performance and add more features easily.
This commit is incomplete. It drops almost all previous code, and
readds only the most important things (some of them actually buggy).
The next commit will complete it - it's separate to preserve authorship
information.
2015-03-12 20:57:54 +00:00
|
|
|
struct gl_shader_cache;
|
|
|
|
|
|
2015-09-23 20:13:03 +00:00
|
|
|
struct gl_shader_cache *gl_sc_create(GL *gl, struct mp_log *log);
|
vo_opengl: refactor shader generation (part 1)
The basic idea is to use dynamically generated shaders instead of a
single monolithic file + a ton of ifdefs. Instead of having to setup
every aspect of it separately (like compiling shaders, setting uniforms,
perfoming the actual rendering steps, the GLSL parts), we generate the
GLSL on the fly, and perform the rendering at the same time. The GLSL
is regenerated every frame, but the actual compiled OpenGL-level shaders
are cached, which makes it fast again. Almost all logic can be in a
single place.
The new code is significantly more flexible, which allows us to improve
the code clarity, performance and add more features easily.
This commit is incomplete. It drops almost all previous code, and
readds only the most important things (some of them actually buggy).
The next commit will complete it - it's separate to preserve authorship
information.
2015-03-12 20:57:54 +00:00
|
|
|
void gl_sc_destroy(struct gl_shader_cache *sc);
|
2016-05-12 09:27:00 +00:00
|
|
|
bool gl_sc_error_state(struct gl_shader_cache *sc);
|
|
|
|
|
void gl_sc_reset_error(struct gl_shader_cache *sc);
|
vo_opengl: refactor shader generation (part 1)
The basic idea is to use dynamically generated shaders instead of a
single monolithic file + a ton of ifdefs. Instead of having to setup
every aspect of it separately (like compiling shaders, setting uniforms,
perfoming the actual rendering steps, the GLSL parts), we generate the
GLSL on the fly, and perform the rendering at the same time. The GLSL
is regenerated every frame, but the actual compiled OpenGL-level shaders
are cached, which makes it fast again. Almost all logic can be in a
single place.
The new code is significantly more flexible, which allows us to improve
the code clarity, performance and add more features easily.
This commit is incomplete. It drops almost all previous code, and
readds only the most important things (some of them actually buggy).
The next commit will complete it - it's separate to preserve authorship
information.
2015-03-12 20:57:54 +00:00
|
|
|
void gl_sc_add(struct gl_shader_cache *sc, const char *text);
|
2017-07-24 05:21:25 +00:00
|
|
|
void gl_sc_addf(struct gl_shader_cache *sc, const char *textf, ...)
|
|
|
|
|
PRINTF_ATTRIBUTE(2, 3);
|
2015-03-27 12:27:40 +00:00
|
|
|
void gl_sc_hadd(struct gl_shader_cache *sc, const char *text);
|
2017-07-24 05:21:25 +00:00
|
|
|
void gl_sc_haddf(struct gl_shader_cache *sc, const char *textf, ...)
|
|
|
|
|
PRINTF_ATTRIBUTE(2, 3);
|
2016-04-20 23:33:13 +00:00
|
|
|
void gl_sc_hadd_bstr(struct gl_shader_cache *sc, struct bstr text);
|
2017-07-17 16:11:32 +00:00
|
|
|
void gl_sc_paddf(struct gl_shader_cache *sc, const char *textf, ...)
|
|
|
|
|
PRINTF_ATTRIBUTE(2, 3);
|
vo_opengl: dynamically manage texture units
A minor cleanup that makes the code simpler, and guarantees that we
cleanup the GL state properly at any point.
We do this by reusing the uniform caching, and assigning each sampler
uniform its own texture unit by incrementing a counter. This has various
subtle consequences for the GL driver, which hopefully don't matter. For
example, it will bind fewer textures at a time, but also rebind them
more often.
For some reason we keep TEXUNIT_VIDEO_NUM, because it limits the number
of hook passes that can be bound at the same time.
OSD rendering is an exception: we do many passes with the same shader,
and rebinding the texture each pass. For now, this is handled in an
unclean way, and we make the shader cache reserve texture unit 0 for the
OSD texture. At a later point, we should allocate that one dynamically
too, and just pass the texture unit to the OSD rendering code. Right now
I feel like vo_rpi.c (may it rot in hell) is in the way.
2016-09-14 18:42:52 +00:00
|
|
|
void gl_sc_uniform_tex(struct gl_shader_cache *sc, char *name, GLenum target,
|
|
|
|
|
GLuint texture);
|
2017-07-29 18:14:48 +00:00
|
|
|
void gl_sc_uniform_texture(struct gl_shader_cache *sc, char *name,
|
|
|
|
|
struct ra_tex *tex);
|
vo_opengl: dynamically manage texture units
A minor cleanup that makes the code simpler, and guarantees that we
cleanup the GL state properly at any point.
We do this by reusing the uniform caching, and assigning each sampler
uniform its own texture unit by incrementing a counter. This has various
subtle consequences for the GL driver, which hopefully don't matter. For
example, it will bind fewer textures at a time, but also rebind them
more often.
For some reason we keep TEXUNIT_VIDEO_NUM, because it limits the number
of hook passes that can be bound at the same time.
OSD rendering is an exception: we do many passes with the same shader,
and rebinding the texture each pass. For now, this is handled in an
unclean way, and we make the shader cache reserve texture unit 0 for the
OSD texture. At a later point, we should allocate that one dynamically
too, and just pass the texture unit to the OSD rendering code. Right now
I feel like vo_rpi.c (may it rot in hell) is in the way.
2016-09-14 18:42:52 +00:00
|
|
|
void gl_sc_uniform_tex_ui(struct gl_shader_cache *sc, char *name, GLuint texture);
|
2017-07-17 16:11:32 +00:00
|
|
|
void gl_sc_uniform_image2D(struct gl_shader_cache *sc, char *name, GLuint texture,
|
|
|
|
|
GLuint iformat, GLenum access);
|
2017-07-17 19:39:06 +00:00
|
|
|
void gl_sc_ssbo(struct gl_shader_cache *sc, char *name, GLuint ssbo,
|
2017-07-25 04:35:10 +00:00
|
|
|
char *format, ...) PRINTF_ATTRIBUTE(4, 5);
|
vo_opengl: refactor shader generation (part 1)
The basic idea is to use dynamically generated shaders instead of a
single monolithic file + a ton of ifdefs. Instead of having to setup
every aspect of it separately (like compiling shaders, setting uniforms,
perfoming the actual rendering steps, the GLSL parts), we generate the
GLSL on the fly, and perform the rendering at the same time. The GLSL
is regenerated every frame, but the actual compiled OpenGL-level shaders
are cached, which makes it fast again. Almost all logic can be in a
single place.
The new code is significantly more flexible, which allows us to improve
the code clarity, performance and add more features easily.
This commit is incomplete. It drops almost all previous code, and
readds only the most important things (some of them actually buggy).
The next commit will complete it - it's separate to preserve authorship
information.
2015-03-12 20:57:54 +00:00
|
|
|
void gl_sc_uniform_f(struct gl_shader_cache *sc, char *name, GLfloat f);
|
2015-03-27 12:27:40 +00:00
|
|
|
void gl_sc_uniform_i(struct gl_shader_cache *sc, char *name, GLint f);
|
vo_opengl: refactor shader generation (part 1)
The basic idea is to use dynamically generated shaders instead of a
single monolithic file + a ton of ifdefs. Instead of having to setup
every aspect of it separately (like compiling shaders, setting uniforms,
perfoming the actual rendering steps, the GLSL parts), we generate the
GLSL on the fly, and perform the rendering at the same time. The GLSL
is regenerated every frame, but the actual compiled OpenGL-level shaders
are cached, which makes it fast again. Almost all logic can be in a
single place.
The new code is significantly more flexible, which allows us to improve
the code clarity, performance and add more features easily.
This commit is incomplete. It drops almost all previous code, and
readds only the most important things (some of them actually buggy).
The next commit will complete it - it's separate to preserve authorship
information.
2015-03-12 20:57:54 +00:00
|
|
|
void gl_sc_uniform_vec2(struct gl_shader_cache *sc, char *name, GLfloat f[2]);
|
|
|
|
|
void gl_sc_uniform_vec3(struct gl_shader_cache *sc, char *name, GLfloat f[3]);
|
|
|
|
|
void gl_sc_uniform_mat2(struct gl_shader_cache *sc, char *name,
|
|
|
|
|
bool transpose, GLfloat *v);
|
|
|
|
|
void gl_sc_uniform_mat3(struct gl_shader_cache *sc, char *name,
|
|
|
|
|
bool transpose, GLfloat *v);
|
2017-07-22 19:51:32 +00:00
|
|
|
void gl_sc_set_vertex_format(struct gl_shader_cache *sc,
|
|
|
|
|
const struct gl_vao_entry *entries,
|
|
|
|
|
size_t vertex_size);
|
2015-11-09 15:24:01 +00:00
|
|
|
void gl_sc_enable_extension(struct gl_shader_cache *sc, char *name);
|
2017-07-17 16:11:32 +00:00
|
|
|
struct mp_pass_perf gl_sc_generate(struct gl_shader_cache *sc, GLenum type);
|
2017-07-22 19:51:32 +00:00
|
|
|
void gl_sc_draw_data(struct gl_shader_cache *sc, GLenum prim, void *ptr,
|
|
|
|
|
size_t num);
|
vo_opengl: refactor shader generation (part 1)
The basic idea is to use dynamically generated shaders instead of a
single monolithic file + a ton of ifdefs. Instead of having to setup
every aspect of it separately (like compiling shaders, setting uniforms,
perfoming the actual rendering steps, the GLSL parts), we generate the
GLSL on the fly, and perform the rendering at the same time. The GLSL
is regenerated every frame, but the actual compiled OpenGL-level shaders
are cached, which makes it fast again. Almost all logic can be in a
single place.
The new code is significantly more flexible, which allows us to improve
the code clarity, performance and add more features easily.
This commit is incomplete. It drops almost all previous code, and
readds only the most important things (some of them actually buggy).
The next commit will complete it - it's separate to preserve authorship
information.
2015-03-12 20:57:54 +00:00
|
|
|
void gl_sc_reset(struct gl_shader_cache *sc);
|
2017-04-08 14:38:56 +00:00
|
|
|
struct mpv_global;
|
|
|
|
|
void gl_sc_set_cache_dir(struct gl_shader_cache *sc, struct mpv_global *global,
|
|
|
|
|
const char *dir);
|
vo_opengl: refactor shader generation (part 1)
The basic idea is to use dynamically generated shaders instead of a
single monolithic file + a ton of ifdefs. Instead of having to setup
every aspect of it separately (like compiling shaders, setting uniforms,
perfoming the actual rendering steps, the GLSL parts), we generate the
GLSL on the fly, and perform the rendering at the same time. The GLSL
is regenerated every frame, but the actual compiled OpenGL-level shaders
are cached, which makes it fast again. Almost all logic can be in a
single place.
The new code is significantly more flexible, which allows us to improve
the code clarity, performance and add more features easily.
This commit is incomplete. It drops almost all previous code, and
readds only the most important things (some of them actually buggy).
The next commit will complete it - it's separate to preserve authorship
information.
2015-03-12 20:57:54 +00:00
|
|
|
|
2016-06-05 19:55:30 +00:00
|
|
|
struct gl_timer;
|
|
|
|
|
|
|
|
|
|
struct gl_timer *gl_timer_create(GL *gl);
|
|
|
|
|
void gl_timer_free(struct gl_timer *timer);
|
|
|
|
|
void gl_timer_start(struct gl_timer *timer);
|
vo_opengl: refactor vo performance subsystem
This replaces `vo-performance` by `vo-passes`, bringing with it a number
of changes and improvements:
1. mpv users can now introspect the vo_opengl passes, which is something
that has been requested multiple times.
2. performance data is now measured per-pass, which helps both
development and debugging.
3. since adding more passes is cheap, we can now report information for
more passes (e.g. the blit pass, and the osd pass). Note: we also
switch to nanosecond scale, to be able to measure these passes
better.
4. `--user-shaders` authors can now describe their own passes, helping
users both identify which user shaders are active at any given time
as well as helping shader authors identify performance issues.
5. the timing data per pass is now exported as a full list of samples,
so projects like Argon-/mpv-stats can immediately read out all of the
samples and render a graph without having to manually poll this
option constantly.
Due to gl_timer's design being complicated (directly reading performance
data would block, so we delay the actual read-back until the next _start
command), it's vital not to conflate different passes that might be
doing different things from one frame to another. To accomplish this,
the actual timers are stored as part of the gl_shader_cache's sc_entry,
which makes them unique for that exact shader.
Starting and stopping the time measurement is easy to unify with the
gl_sc architecture, because the existing API already relies on a
"generate, render, reset" flow, so we can just put timer_start and
timer_stop in sc_generate and sc_reset, respectively.
The ugliest thing about this code is that due to the need to keep pass
information relatively stable in between frames, we need to distinguish
between "new" and "redrawn" frames, which bloats the code somewhat and
also feels hacky and vo_opengl-specific. (But then again, this entire
thing is vo_opengl-specific)
2017-06-29 15:00:06 +00:00
|
|
|
void gl_timer_stop(GL *gl);
|
|
|
|
|
struct mp_pass_perf gl_timer_measure(struct gl_timer *timer);
|
2016-06-05 19:55:30 +00:00
|
|
|
|
2016-09-14 11:25:13 +00:00
|
|
|
#define NUM_PBO_BUFFERS 3
|
|
|
|
|
|
2016-07-03 14:00:51 +00:00
|
|
|
struct gl_pbo_upload {
|
|
|
|
|
GL *gl;
|
2016-07-03 14:31:38 +00:00
|
|
|
int index;
|
2017-07-15 20:11:48 +00:00
|
|
|
GLuint buffer;
|
2016-07-03 14:00:51 +00:00
|
|
|
size_t buffer_size;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
void gl_pbo_upload_tex(struct gl_pbo_upload *pbo, GL *gl, bool use_pbo,
|
|
|
|
|
GLenum target, GLenum format, GLenum type,
|
|
|
|
|
int tex_w, int tex_h, const void *dataptr, int stride,
|
|
|
|
|
int x, int y, int w, int h);
|
|
|
|
|
void gl_pbo_upload_uninit(struct gl_pbo_upload *pbo);
|
|
|
|
|
|
2017-03-20 12:20:35 +00:00
|
|
|
int gl_determine_16bit_tex_depth(GL *gl);
|
|
|
|
|
int gl_get_fb_depth(GL *gl, int fbo);
|
|
|
|
|
|
2015-01-28 18:40:46 +00:00
|
|
|
#endif
|
