Skip to content

Tags

Tags give the ability to mark specific points in history as being important
  • v0.5.0
    b94421ac · meson: update version ·
    v0.5.0
    
    This release brings with it greatly improved support for HDR (including
    HDR-in-SDR emulation, native HDR passthrough and improvements to the
    HDR->SDR tone mapping algorithm), as well as support for ICC profiles
    and external VkImage interop (needed for e.g. hardware decoding).
    
    Additions:
    - Add support for treating an SDR curve as an HDR curve by
      overriding/providing the true target peak. This essentially allows you
      to calibrate a true HDR device to a typical SDR curve and use it to
      display HDR media, at the cost of bit precision
    - Add more values to enum pl_chroma_location
    - Add a scale factor to struct pl_sample_src, which is useful for e.g.
      debanding on bit-shifted inputs
    - Add a new function to infer/guess unknown pl_color_space fields
    - Add support for 3DLUTs / ICC profiles (via LittleCMS), including
      support for assigning ICC profiles to the `pl_render_image` and
      `pl_render_target` structs
    - Allow enabling optional extra vulkan device/instance extensions, as
      well as listing what extensions were actually loaded
    - Add an API for VkImage interop with user code, e.g. to wrap mapped
      hardware decoding planes into `pl_tex`, plus all synchronization code
      and extra metadata necessary to make this interop safe
    - Implement support for native HDR output on supported platforms
    
    Changes:
    - Separate the texture from the plane data struct in `pl_upload_plane`
    - Swapchain FBOs are now guaranteed to be blittable (e.g. pl_tex_clear)
    - Tone mapping is no longer done for desaturation steps. Users wanting
      high quality desaturation should use ICC profiles
    - Change the types of various fields in struct pl_gpu_limits
    - Slightly relax the sizing requirements of pl_tex_transfer
    - Change the default value for pl_tex_transfer_params.stride_w/h.
      Instead of defaulting to the image size, they now default to the rect to
      be transferred
    - Texture transfer buffer offsets must (now) be aligned to the texel
      size, in addition to being a multiple of 4
    - Change the API of `pl_color_space_equal` to be consistent with the
      rest of the colorspace APIs
    - Allow the `pl_upload_plane` helpers to upload from buffers as well
    - Switch the type of mapped buffer pointers from char* to uint8_t*
    - Rename DCI_P3 to Display_P3, and add DCI_P3 (using the actual DCI white
      point)
    
    Fixes and performance improvements:
    - Fix some compatibility issues with GLSL 120
    - Prevent desaturation from exploding when tone mapping to HDR, or when
      tone mapping a very bright HDR scene to SDR
    - Implement the fully parametrized BT.2100 (HLG) OOTF in both
      directions, based on the tagged/inferred signal peak
    - Fix an issue preventing the out-of-gamut feature from working
      correctly on HDR displays
    - Fix a segfault that occurs when instance creation fails
    - Fix an issue where `peak_detect_frames` was sometimes too low
    - Allow debanding to take care of implicit bilinear sampling in cases
      where no other scaler is requested, thus avoiding an unnecessary FBO
      indirection
    - Only run the debanding algorithm on the parts of the image we will
      actually be displaying. This is relevant when cropping
    - Fix an issue where PL_TONE_MAPPINg_MOBIUS could fail in certain
      (unrealistic) scenarios involving HDR-in-SDR emulation
    - Fix an issue where vulkan could sometimes modify commands after
      submitting them, when recreating vertex buffers
    - Make an effort to reuse the same vertex buffer when the contents don't
      change from the previous invocation
    - Fix the glslang locale work-arounds on windows
    - Fix an issue where trying to upload from a too-large texel buffer
      results in an assertion failure rather than a clean error
    - Fix an issue where the usage of VkEvents prevented libplacebo from
      working on platforms where they were unsupported (e.g. MoltenVK)
    - Support and use vulkan push descriptors where supported. This avoids
      having to maintain, update and synchronize descriptor sets
    - Correctly disable signal linearization on low-bit depth FBOs
    - Prevent a crash on the (pathological) case of a shader with no
      descriptors
    - Fix a bug in the size limit calculations for 2D/3D LUTs
    - Use optimization level "performance" instead of "size" for shader
      compilation
    - Fix an abort() when trying to render to a non-storable FBO when using
      a final pass that requires compute shaders (e.g. HDR peak detection)
    
  • v0.2.1
    b17e51cf · meson: update fixver ·
    v0.2.1
    
    This is a bugfix release, intended to backport a number of easy and/or
    critical fixes onto v0.2.0, since this is effectively the current 'LTS'
    due to its use in VLC 3.0. Despite the included fixes, it's still not
    recommended to make use of `pl_renderer` in this release. v0.4.0 is the
    first release where that feature could be considered officially
    supported.
    
    For a full list of backported changes, see the git log. But aside from
    cosmetics, comment fixes, here are the most noteworthy changes:
    
    Fixes:
    - Fix some typos in shaders that lead to miscompilation
    - Work around the lack of mix(vecN, vecN, bvecN) on GLSL 120
    - Avoid the use of platform-dependent locale-invariant printf() calls
      for shader generation. Instead, use a custom implementation
    - Work around libshaderc locale dependence (currently only relevant when
      using vulkan)
    - Fix various errors with anamorphic content handling
    - Fix various errors when using vulkan
    - Add some more sanitization to RA calls, and fix some of the existing
      ones
    
  • v0.4.0
    6c336a1d · meson: update version ·
    v0.4.0
    
    This release brings with it a major performance change to the renderer's
    scaling pipeline, support for vulkan format emulation, improvements to
    the HDR peak detection algorithm as well as greatly improved support for
    compute shader-based rasterization.
    
    In addition to the above features, this release renames the `RA`
    abstraction to `pl_gpu`, and normalizes the `ra_` prefix to `pl_` in
    order to match the rest of the API as well as prevent potential future
    symbol conflicts with mpv's internal copy of RA.
    
    Additions:
    - Add `pl_shader_encode_color`, which is an inversion of
      `pl_shader_decode_color` (NOTE: Some features, such as inverse
      constant luminance or XYZ encoding, are not currently supported)
    - Add API for overlay images. This can be used to directly overlay
      arbitrary planes (e.g. subtitles, or menu items) on top of the
      rendered image or the target FBO. Each plane is allowed to have its
      own color space/repr and format. See `struct pl_overlay` for more
      details
    - Add various predefined `pl_color_repr` values
    - Add scene change detection functionality to the HDR peak detection
      algorithm in `pl_shader_color_map`. The new algorithm is designed to
      allow using larger peak detection buffers without the associated risk
      of eye-adaptation-like effects
    - Add support for texel buffers (uniform and storage) in the pl_buf API.
      These can be used to storage raw texels in buffer format, much like 1D
      textures, but with the usual buffer-related functionality
    - Add support for vulkan format emulation, which allows users to
      directly upload and download e.g. rgb8 or rgb32f textures, even though
      these are not typically supported by GPUs. The format emulation uses
      compute shaders and texel storage buffers to fix the data
      representation on-GPU, and is significantly faster than doing the same
      with on-CPU software conversion routines
    - Add a `pl_dispatch_compute` function, which behaves like
      `pl_dispatch_finish` but without the FBO output, blending and
      rasterization simulation logic. This is useful when dispatching
      pure-compute shaders. (Note: Not currently very useful for API users
      since there are no pure-compute shaders as part of the public API)
    
    Changes:
    - Rename the `ra_` series of abstractions to `pl_` for consistency. The
      old `struct ra` was renamed to `struct pl_gpu`
    - The dispatch logic for compute shaders will now correctly simulate the
      dispatch rect, by manually translating coordinates in the shader.
    - Disallow using compute shader scaling for flipped source rects. API
      users who relied on this behavior are encouraged to instead flip the
      coordinates of the resulting `pl_dispatch_finish` call
    - Have the renderer infer `src_rect` and `dst_rect` when not given
    - Have the renderer encode colors to the `target.repr` before outputting
      to screen. This includes, for example, conversion to YUV and dithering
      to the target representation's bit depth (where known)
    - Add a `pl_blend_params` struct to `pl_dispatch_finish`, which can be
      used to enable blending (including compute shaders)
      including when using compute shaders.
    - Subsampled planes must now be an integer multiple (or inverse thereof)
      of the reference size. If this is not the case, the renderer will
      assume the planes are cropped or expanded. This is needed to correctly
      render e.g. 4:2:0 subsampled JPEGs with odd sizes
    - Require that all uses of `pl_image` with the same `signature` point to
      the same data, to allow safe cache purging
    - Allow dispatching debanding and bicubic shaders at any size
    - `pl_plane_find_fmt` may now be called with `out_map=NULL`
    - Change the `pl_color_map_default_params` in response to the new scene
      detection feature. The default buffer size has been increased from 21
      to 64, which leads to a much more stable image that flickers less
    
    Fixes and performance improvements:
    - Fix typo that lead to incorrect anamorphic rendering
    - Fix various rendering issues when using a flipped src_rect
    - Fix a double-free that could happen as a result of rendering failing
      in an unexpected way.
    - Fix handling of alpha values in `pl_shader_decode_color`
    - Correctly set the queue family index for vulkan buffer barriers
    - Work around a locale dependence in libshaderc by calling uselocale/XXX
      before calling into shaderc functions
    - Remove POSIX dependence in the test suite
    - Remove non-portable ffsll call
    - Fix demos/sdl2.c building on windows
    - Fix an issue where trying to polar sample multiple planes could result
      in a variable conflict
    - Fix inverted plane shift offset calculation
    - Respect the debanding settings in the renderer
    - Sanitize `pl_pass_run_params.scissors` and silently drop no-ops
    - Avoid dependence on exact float equality in the renderer's
      upscaling/downscaling checks
    - Fix an off-by-one in the HDR peak computation code which lead to
      subtly too-dark output
    - Correctly check for and enable required vulkan device features
    - Switch to a custom implementation of locale-invariant printf, to avoid
      depending on broken platform-dependent versions
    - Overhaul the renderer's scaling pipeline. The new code is
      significantly faster when rendering cropped images, and also fixes an
      issue where src_rect was not applied when FBOs are unavailable
    - Minor performance tweaks here and there
    - Cap the sizes of various buffer pools and command queues in order to
      avoid OOM scenarios in infinite loops that don't contain enough
      forward dependencies to force command flushing
    - Correctly check for and catch buffer access overflow
    - Don't segfault when `pl_buf_create` fails
    - Don't segfault when running a compute shader without viewport/scissors
    - Fix a 32-bit integer overflow that could occurr when using HDR peak
      detection on 4K content with large values of `peak_detect_frames`
    - Fix an off-by-one in the generation of literal LUTs such as the type
      used by the dithering code when textures are unavailable, which led to
      these shaders miscompiling
    - Various fixes for building on 32-bit systems
    - Fix an uninitialized value in the renderer
    
  • v0.3.0
    44589895 · meson: update version ·
    v0.3.0
    
    This update brings with it some major changes to the renderer, support
    for swapchains, separated sampling, sigmoidization and more. It also
    includes, for the first time, a graphical demo capable of rendering to
    the screen - as well as a benchmark.
    
    Additions:
    - Add a new type (ra_swapchain) encapsulating the concept of a
      presentable surface (e.g. graphical window) which can be presented to
      the display, as well as an implementation for vulkan swapchains
    - Add a simple benchmark suite
    - Add a new helper utils/upload.h for simplifying the process of picking
      a compatible texture format and uploading raw texture data
    - Add a helper function to setup a pl_render_target from a swapchain
    - Add a graphical demo based on SDL2 (compiled with vulkan support)
    - Add support for separated (orthogonal) scaling, and make the renderer
      use it
    - Add support for using the optimized GPU-native sampling methods for
      nearest/bilinear/bicubic where possible
    - Add support for sigmoidization/unsigmoidization shaders
    - Make the renderer use linearization/sigmoidization where appropriate
    
    Changes:
    - Require vulkan >= v1.0.24, rather than the old >= 1.0.50
    - Split up vulkan instance and device creation into separate helpers.
      This is needed to satisfy the typical VkInstance -> VkSurface -> VkDevice
      dependency dance required to create a renderable swapchain.
    - Change the API of pl_dispatch_finish/abort to make it clear that they
      consume and take over ownership of the pl_shader
    - Have the renderer also #include most of its API dependencies, to cut
      down the amount of #include spam needed to use it
    - Rename pl_sample_polar_params and generalize it to include separated
      (orthogonal) scaling as well
    - Various API changes to pl_render_params
    
    Fixes:
    - Allow running the build script without `git` installed
    - Fix an invalid bounds check on ra_tex_blit causing it to fail for
      1D/2D textures
    - Use global #include paths for all public headers, rather than relative
    - Fix the src_rect calculation in the renderer, thus fixing an issue
      where anamorphic scaling produced the wrong result
    - Fix a typo in the renderer, causing it to skip some planes
    - Fix a memory leak caused by implicit deallocation of pl_shader
    - Fix a bug in the renderer causing the image to stop updating after the
      first frame after a resize
    - Fixes a bug where the color mapping / tone mapping shaders sometimes
      got (accidentally) triggered when the source colorspace is unknown
    - Fix a bug where compute shaders were incorrectly dispatched after a
      resize of the dispatch target
    - Fix a bug where the polar compute shader read from uninitialized
      memory when performing anamorphic scaling
    - Various other bug fixes and performance tweaks
    
  • v0.2.0
    v0.2.0
    
    Additions:
    - Add a public "renderer" API. This is currently very WIP, and not ready
      for stable usage yet. Both the API and the implementation are in flux,
      but the general goal is to make it easier to use libplcaebo to just
      render some data in the optimal way.
    - Add pl_deband_default_params
    - Expand shader system to support shader merging. This is not directly
      publicly useful yet, but it's used internally in the renderer.
    - Allow dispatching to sub-rects of the render target
    - Expand the scaling API to allow disabling antialiasing
    - Add high quality dithering algorithms (blue noise, arbitrary size bayer
      matrix). This uses a new, genearlized shader LUT mechanism which
      allows the LUT to manifest itself either as a texture, a uniform
      float[] or as an in-line constant array depending on
      environment/hardware capabilities. As such, this can be used to enable
      dithering even without the use of a RA.
    
    Changes:
    - Minor RA API changes here and there (e.g. signed -> unsigned stride)
    
    Fixes:
    - Improved check logic for various shaders
    - More descriptive variable names in some of the generated shaders
    - Fix overflow when dithering to bit depths greater than 32
    - Fix the RA format finding logic in some cases
    - Make the scalers correctly support flipped scaling rects
    - Fix some incorrect vulkan texture barriers
    - Fix some locale issues on BSD
    - GLSL 120 compat fix with the dithering algorithm
    - Fix vulkan command polling logic to avoid blocking for longer than
      intended
    
  • v0.1.2
    91c724f6 · meson: update fixver ·
    v0.1.2
    
    Fixes:
    - Add missing header file
    - Cosmetic fixes in the generated shaders
    
    Improvements:
    - Log slightly more debugging information for RAs
    - Slight improvement of the internal PRNG
    - Add travis CI support
    
  • v0.1.1
    2cd5792c · meson: bump fixver ·
    Release v0.1.1
    
    This is a minor bug fix release, to solve some issues that arose while
    integrating libplacebo into VLC 3.0.
    
    Fixes:
    - various fixes under NDEBUG
    - removed the LIBPLACEBO_ENABLE_SECURITY_BUGS nag under NDEBUG
    - removed the LIBPLACEBO_LEAK_REPORT check under NDEBUG
    
  • v0.1.0
    Release v0.1.0
    
    This represents the initial release, mostly so we can get VLC with basic
    libplacebo support out of the way.
    
    As of v0.1, libplacebo only supports vulkan, and only exposes the
    low-level interfaces (dispatch, shader, ra). So as of now, libplacebo is
    only useful either as a GLSL shader generator (shaders.h), or as an
    offline tool for processing images (dispatch.h + vulkan). There is
    currently no high-level image/video rendering interface, and no support
    for OpenGL whatsoever.
    
    OpenGL support is planned for v0.2, and the addition of a high level
    renderer is planend for v0.3.