Direct float comparison against 1.0 was a terrible idea. I have no idea
how this survived my tests up to this point, but it definitely breaks
sporadically in some cases.

Otherwise, this introduces unwanted one-pixel scaling (and/or trips the
ortho2 bidirectional scaling detection logic).

Investigating a bug with broken yuv422 scaling on a cropped texture made
me conclude that this API is fundamentally broken. We cannot discard the
unused component from inside this function without knowing what the
source crop was. We need it to be less magic and to move responsibility
onto the API user.

Since this is a significant break in API, rename it to
`pl_shader_sample_ortho2` and preserve the original name for backwards
compatibility. Annoying, but necessary, because otherwise this regresses
current users of `pl_shader_sample_ortho` (e.g. vs-placebo).

The logic in `vk_buf_flush` treates buffers imported from
PL_HANDLE_HOST_PTR identically to `host_mapped` buffers, but this
assumption is only true if we assume that the host pointers were
imported to a host-visible memory type. This is not always the case.

Relax the restriction to only require invalidating mapped memory if the
memory is actually mapped.

Fixes: https://github.com/haasn/libplacebo/issues/146

Pulls in a bug fix for building on some platforms we transitively care
about.

Doing this too early doesn't undefined it before the symbol is defined.

Otherwise, gl->MemoryBarrier expands to something that the CPP expects
to be a macro invocation. Oops.

No need to use these to join strings, since it's just shorthand for '/'

3rdparty/Vulkan-Headers might exist, but be empty.

Hooray for tagged releases \o/

Two changes rolled into one:

1. We don't need to guard the GL/GLES loader anymore, as this has become
   thread safe as part of the glad2 update.

2. We *do* need to guard the entire EGL state, because even the
   `gladLoadEGLUserPtr` mutates many different global symbols. In some
   strange hypothetical world, two calls to `pl_opengl_create` could try
   mutating these global symbols simultaneously, resulting in undefined
   behavior if they, for whatever reason, pick up *different* entry
   points. (Perhaps a user is over-riding some symbols in
   `getProcAddress`)

So rename the mutex and always use it when loading EGL.

`gladLoaderUnload*` got changed to be context-specific.

See-Also: videolan/libplacebo#235

The status quo way of doing it is pretty much undefined-ish behavior,
and bad juju in general. With 158c8976 merged, this is no longer needed.

Instead, try loading GL first, and only fall back to GLES if needed (or
if a GLES context was suspected/detected).

This is redundant with just re-checking for the proc_addr callbacks in
params. This is mainly done to make some up-coming refactors easier and
more orthogonal.

No point calling this function if the user did not specify an EGL
display.

For stylistic reasons.

This solves the part where `pl_opengl_destroy` would otherwise
implicitly call `gladLoaderUnloadEGL`, which breaks the re-use of GLAD
in our test framework.

This distinction shouldn't matter to ordinary API users.

And conditionally use this instead of GL_OES_EGL_image_external on
non-GLES contexts.

This is not thread safe out of the box.

See-Also: https://github.com/Dav1dde/glad/issues/383

We need these in principle to protect static variables, as well as to
wrap non-thread-safe external libraries. We don't currently have any
such use case, but this is at least in part because we lacked this
capability in the past.

Co-authored-by: Hendrik Leppkes <h.leppkes@gmail.com>

Even though we don't actually compile it, this at least helps figure out
what the actual supported API *is*.

This logic was copied blindly from the CUDA version, but comparing it
aginst the C yadif made me conclude that it's wrong. (As the naming of
the variable clearly indicates, `is_second_field` should be true when
field is *not* equal to first)

Fix the logic (and get rid of the basically redundant variable, "field
== first_field" is clearly understandable, so why confuse matters by
inverting the boolean name arbitrarily?).

These two changes mysteriously appeared in the CUDA version of Yadif,
from which this shader was implemented. Undo them to bring the code in
line with the C version again.

I'm really, really annoyed by having to hard-code assumptions about the
video bit depth here. But I don't feel like this is adequate
justification to break API just to plumb it through. Besides, the visual
difference appears to be insignificant.

Kacper Michajłow authored 2 years ago and Niklas Haas committed 2 years ago

This change is to workaround AMD driver on Windows, which even though
VK_EXT_full_screen_exclusive is not enabled still tries to enter
exclusive mode.

Fixes: https://github.com/mpv-player/mpv/issues/8008


Signed-off-by: Kacper Michajłow <kasper93@gmail.com>
Co-authored-by: Niklas Haas <git@haasn.dev>
Co-authored-by: Hendrik Leppkes <h.leppkes@gmail.com>

The existing code is written to assume that planes are always textures,
but when deinterlacing after dfa1217c they may be shaders instead.

Failure to do this leaks the handle internally.

Note that doing so unfortunately breaks the `opengl_surfaceless.c` test,
because it re-uses the glad loader internally. Work-around this by
forcibly re-loading it.

Oops.

`lut_out` is not used in the PL_LUT_CONVERSION case, so there's no point
in even defaulting it to `target->color`.

Hendrik Leppkes authored 2 years ago and Niklas Haas committed 2 years ago

libdl is not present on Windows, instead the functionality is always
available, and glad2 (which this is used for) uses proper Windows
loading functions as needed.

No longer used, no need to bundle it.

Since jinja2 is a necessary dependency of glad2, which we depend on for
OpenGL, it makes sense to re-use that to avoid pulling in *two* string
templaters.

Also, I think, vastly more likely to be pre-installed on the system in
some fashion or another.

This setting must invalidate cache entries.

Mostly for myself, so I don't forget the various steps.

This overrides the built-in BPC logic and progressively mixes a linear
ramp into the near-black entries of the generated LUT. May help fix
"bad" monitor profiles, containing invalid colorimetric tables.

Disabled by default because it effectively disables the 3DLUT near
black, which may not be desired, especially for well-behaved profiles.

Closes: videolan/libplacebo#219

For consistency with other such definitions.

Instead of requiring GLSL 130+ for texelFetch().

Fixes: videolan/libplacebo#233

Splits up shaders.c and also makes this code easier to find.

This is definitely slower in enough environments to be worth not picking
automatically, since it basically requires sampling twice.