mirror of
https://codeberg.org/dnkl/foot.git
synced 2026-02-04 04:06:06 -05:00
ccf625b991
This implements gamma-correct blending, which mainly affects font rendering. The implementation requires compile-time availability of the new color-management protocol (available in wayland-protocols >= 1.41), and run-time support for the same in the compositor (specifically, the EXT_LINEAR TF function and sRGB primaries). How it works: all colors are decoded from sRGB to linear (using a lookup table, generated in the exact same way pixman generates it's internal conversion tables) before being used by pixman. The resulting image buffer is thus in decoded/linear format. We use the color-management protocol to inform the compositor of this, by tagging the wayland surfaces with the 'ext_linear' image attribute. Sixes: all colors are sRGB internally, and decoded to linear before being used in any sixels. Thus, the image buffers will contain linear colors. This is important, since otherwise there would be a decode/encode penalty every time a sixel is blended to the grid. Emojis: we require fcft >= 3.2, which adds support for sRGB decoding color glyphs. Meaning, the emoji pixman surfaces can be blended directly to the grid, just like sixels. Gamma-correct blending is enabled by default *when the compositor supports it*. There's a new option to explicitly enable/disable it: gamma-correct-blending=no|yes. If set to 'yes', and the compositor does not implement the required color-management features, warning logs are emitted. There's a loss of precision when storing linear pixels in 8-bit channels. For this reason, this patch also adds supports for 10-bit surfaces. For now, this is disabled by default since such surfaces only have 2 bits for alpha. It can be enabled with tweak.surface-bit-depth=10-bit. Perhaps, in the future, we can enable it by default if: * gamma-correct blending is enabled * the user has not enabled a transparent background
92 lines
2.6 KiB
C
92 lines
2.6 KiB
C
#pragma once
|
|
|
|
#include <stdbool.h>
|
|
#include <stddef.h>
|
|
#include <sys/types.h>
|
|
|
|
#include <pixman.h>
|
|
#include <wayland-client.h>
|
|
|
|
#include <tllist.h>
|
|
|
|
#include "wayland.h"
|
|
|
|
struct damage;
|
|
|
|
struct buffer {
|
|
int width;
|
|
int height;
|
|
int stride;
|
|
|
|
void *data;
|
|
|
|
struct wl_buffer *wl_buf;
|
|
pixman_image_t **pix;
|
|
size_t pix_instances;
|
|
|
|
unsigned age;
|
|
|
|
/*
|
|
* First item in the array is used to track frame-to-frame
|
|
* damage. This is used when re-applying damage from the last
|
|
* frame, when the compositor doesn't release buffers immediately
|
|
* (forcing us to double buffer)
|
|
*
|
|
* The remaining items are used to track surface damage. Each
|
|
* worker thread adds its own cell damage to "its" region. When
|
|
* the frame is done, all damage is converted to a single region,
|
|
* which is then used in calls to wl_surface_damage_buffer().
|
|
*/
|
|
pixman_region32_t *dirty;
|
|
};
|
|
|
|
void shm_fini(void);
|
|
void shm_set_max_pool_size(off_t max_pool_size);
|
|
|
|
struct buffer_chain;
|
|
struct buffer_chain *shm_chain_new(
|
|
struct wayland *wayl, bool scrollable, size_t pix_instances,
|
|
bool ten_bit_it_if_capable);
|
|
void shm_chain_free(struct buffer_chain *chain);
|
|
|
|
/*
|
|
* Returns a single buffer.
|
|
*
|
|
* May returned a cached buffer. If so, the buffer's age indicates how
|
|
* many shm_get_buffer() calls have been made for the same
|
|
* width/height while the buffer was still busy.
|
|
*
|
|
* A newly allocated buffer has an age of 1234.
|
|
*/
|
|
struct buffer *shm_get_buffer(
|
|
struct buffer_chain *chain, int width, int height, bool with_alpha);
|
|
/*
|
|
* Returns many buffers, described by 'info', all sharing the same SHM
|
|
* buffer pool.
|
|
*
|
|
* Never returns cached buffers. However, the newly created buffers
|
|
* are all inserted into the regular buffer cache, and are treated
|
|
* just like buffers created by shm_get_buffer().
|
|
*
|
|
* This function is useful when allocating many small buffers, with
|
|
* (roughly) the same life time.
|
|
*
|
|
* Buffers are tagged for immediate purging, and will be destroyed as
|
|
* soon as the compositor releases them.
|
|
*/
|
|
void shm_get_many(
|
|
struct buffer_chain *chain, size_t count,
|
|
int widths[static count], int heights[static count],
|
|
struct buffer *bufs[static count], bool with_alpha);
|
|
|
|
void shm_did_not_use_buf(struct buffer *buf);
|
|
|
|
bool shm_can_scroll(const struct buffer *buf);
|
|
bool shm_scroll(struct buffer *buf, int rows,
|
|
int top_margin, int top_keep_rows,
|
|
int bottom_margin, int bottom_keep_rows);
|
|
|
|
void shm_addref(struct buffer *buf);
|
|
void shm_unref(struct buffer *buf);
|
|
|
|
void shm_purge(struct buffer_chain *chain);
|