#25 fix(drm): retry commits refused for memory instead of stopping the output

state: merged · fdd661a · merge commit
branch: fix/drm-enomem-retry → main
opened: bnema · 25h ago
updated: 20h ago

Problem

Under VRAM pressure amdgpu can refuse an atomic commit with ENOMEM (the kernel fails to pin the new framebuffer). The previous frame stays on screen, but NeferWL treated the error as fatal: the output stopped and stayed dark until the next hotplug.

Change

ENOMEM on a frame, state or modeset commit keeps the output: the last frame stays on screen and the commit retries with a backoff from 16 ms to 1 s, without limit and without the stuck-recovery modeset.
The frame lifecycle tracks the current wait kind (flip, busy, nomem) apart from the memory-refusal run, so EBUSY after ENOMEM keeps its event unblocking and modeset recovery.
Direct scanout refused for memory pauses scanout for 2 s and composes into the resident output images.
Signalled render fences are reaped during retries, so long refusals do not accumulate descriptors.
Protected (locked) commits keep their existing retry path: a refused frame is never certified or reported.
Logs: one warn per refusal run, another after 5 s, info commit recovered with attempts and outage.

Checks

make check, make race, make mocks-check, staticcheck ./...; unit tests for backoff, ENOMEM→EBUSY, lasting refusal, modeset retry, scanout fallback, protected path, fence reaping. Not tested on real hardware under memory pressure.

Out of scope: renderer out-of-memory and GBM allocation failures at start/resume still stop the output.

Commit	Subject	Author	Date	Signature
d40e1f9	fix(drm): reap signalled render fences during commit retries	brice	25h ago	GPG Verified
7703bb9	fix(drm): separate the frame wait reason from the memory-refusal run	brice	25h ago	GPG Verified
d707400	fix(drm): retry commits refused for memory instead of stopping the output	brice	25h ago	GPG Verified

Checks 1

check success

35 files · +742 -1833

1/1

M .goreleaser.yaml +2 -2

@@ -1,100 +0,0 @@
1	-	// Package hdrcursor converts cursor images to the HDR10 output encoding
2	-	// (BT.2020 PQ) for cursor planes, whichever adapter owns the image memory.
3	-	package hdrcursor
4	-
5	-	import (
6	-	"crypto/sha256"
7	-	"encoding/binary"
8	-	"math"
9	-	)
10	-
11	-	var srgbTable = func() (table [256]float64) {
12	-	for i := range table {
13	-	table[i] = SRGBToLinear(float64(i) / 255)
14	-	}
15	-	return
16	-	}()
17	-
18	-	// SRGBToLinear decodes a unit-range sRGB component.
19	-	func SRGBToLinear(v float64) float64 {
20	-	if v <= 0.04045 {
21	-	return v / 12.92
22	-	}
23	-	return math.Pow((v+0.055)/1.055, 2.4)
24	-	}
25	-
26	-	// PQEncode encodes absolute luminance in nits using SMPTE ST 2084.
27	-	func PQEncode(nits float64) float64 {
28	-	if nits <= 0 {
29	-	return 0
30	-	}
31	-	x := math.Pow(min(nits, 10000)/10000, 2610.0/16384)
32	-	return math.Pow((3424.0/4096+2413.0/128x)/(1+2392.0/128x), 2523.0/32)
33	-	}
34	-
35	-	// Pixel converts premultiplied BGRA bytes in place, preserving alpha. The
36	-	// source is quantized to its 8-bit unassociated sRGB value for the LUT.
37	-	func Pixel(p []byte, nits float64) {
38	-	a := float64(p[3]) / 255
39	-	if a == 0 {
40	-	clear(p[:3])
41	-	return
42	-	}
43	-	index := func(v byte) int { return min(255, int(math.Round(float64(v)/a))) }
44	-	r, g, b := srgbTable[index(p[2])], srgbTable[index(p[1])], srgbTable[index(p[0])]
45	-	r, g, b = PQEncode((0.627404r+0.329283g+0.043313b)nits), PQEncode((0.069097r+0.919540g+0.011362b)nits), PQEncode((0.016391r+0.088013g+0.895595b)nits)
46	-	p[0], p[1], p[2] = byte(math.Round(ba255)), byte(math.Round(ga255)), byte(math.Round(ra255))
47	-	}
48	-
49	-	// Cache converts cursor images and keeps only the last result, bounded by
50	-	// the cursor plane's maximum side regardless of cursor theme size. The
51	-	// zero value is ready; it is not safe for concurrent use.
52	-	type Cache struct {
53	-	key [32]byte
54	-	pixels []byte
55	-	}
56	-
57	-	// Len is the size of the cached conversion in bytes (0: empty).
58	-	func (c *Cache) Len() int { return len(c.pixels) }
59	-
60	-	// Key identifies the cached conversion (the zero key: empty).
61	-	func (c *Cache) Key() [32]byte { return c.key }
62	-
63	-	// Reset drops the cached conversion.
64	-	func (c Cache) Reset() { c = Cache{} }
65	-
66	-	func key(pixels []byte, w, h, side int, nits float64) [32]byte {
67	-	var header [32]byte
68	-	binary.LittleEndian.PutUint64(header[:8], uint64(w))
69	-	binary.LittleEndian.PutUint64(header[8:16], uint64(h))
70	-	binary.LittleEndian.PutUint64(header[16:24], math.Float64bits(nits))
71	-	binary.LittleEndian.PutUint64(header[24:], uint64(side))
72	-	digest := sha256.New()
73	-	_, _ = digest.Write(header[:])
74	-	_, _ = digest.Write(pixels)
75	-	var k [32]byte
76	-	digest.Sum(k[:0])
77	-	return k
78	-	}
79	-
80	-	// Convert returns the w×h premultiplied BGRA image (w*4 per row) cropped
81	-	// to side×side and converted for an SDR white of nits, packed without row
82	-	// padding: min(w, side) pixels per row, min(h, side) rows. The result is
83	-	// owned by the cache and valid until the next call.
84	-	func (c *Cache) Convert(pixels []byte, w, h, side int, nits float64) []byte {
85	-	pixels = pixels[:wh4]
86	-	k := key(pixels, w, h, side, nits)
87	-	if c.pixels != nil && c.key == k {
88	-	return c.pixels
89	-	}
90	-	cw, ch := min(w, side)*4, min(h, side)
91	-	out := make([]byte, cw*ch)
92	-	for y := range ch {
93	-	copy(out[ycw:(y+1)cw], pixels[yw4:yw4+cw])
94	-	for x := 0; x < cw; x += 4 {
95	-	Pixel(out[ycw+x:ycw+x+4], nits)
96	-	}
97	-	}
98	-	c.key, c.pixels = k, out
99	-	return out
100	-	}

@@ -1,76 +0,0 @@
1	-	package hdrcursor
2	-
3	-	import (
4	-	"bytes"
5	-	"math"
6	-	"testing"
7	-	)
8	-
9	-	// vector is a 5×3 premultiplied BGRA image: alpha ramps up with one fully
10	-	// transparent pixel (index 3).
11	-	func vector() (pixels []byte, w, h int) {
12	-	w, h = 5, 3
13	-	pixels = make([]byte, wh4)
14	-	for i := range w * h {
15	-	a := byte(i * 255 / (w*h - 1))
16	-	if i == 3 {
17	-	a = 0
18	-	}
19	-	c := func(v int) byte { return byte(v * int(a) / 255) }
20	-	pixels[i4], pixels[i4+1], pixels[i4+2], pixels[i4+3] = c(i37%256), c((i91+20)%256), c((i*53+200)%256), a
21	-	}
22	-	return
23	-	}
24	-
25	-	// The conversion is byte-identical to the one the Vulkan renderer did
26	-	// before it moved here (203 nits, cropped to 4×4).
27	-	func TestConvertMatchesRecordedVector(t *testing.T) {
28	-	pixels, w, h := vector()
29	-	want := []byte{0x0, 0x0, 0x0, 0x0, 0x5, 0x7, 0x9, 0x12, 0xd, 0x13, 0xf, 0x24, 0x0, 0x0, 0x0, 0x0, 0x2e, 0x31, 0x31, 0x5b, 0x3a, 0x1f, 0x20, 0x6d, 0x20, 0x39, 0x30, 0x7f, 0x33, 0x51, 0x46, 0x91, 0x4c, 0x58, 0x5f, 0xb6, 0x5f, 0x72, 0x5e, 0xc8, 0x6d, 0x4e, 0x4c, 0xda, 0x81, 0x75, 0x6c, 0xec}
30	-	var c Cache
31	-	if got := c.Convert(pixels, w, h, 4, 203); !bytes.Equal(got, want) {
32	-	t.Fatalf("converted\n got %#v\nwant %#v", got, want)
33	-	}
34	-	}
35	-
36	-	func TestPixelWhite(t *testing.T) {
37	-	p := []byte{255, 255, 255, 255}
38	-	Pixel(p, 203)
39	-	if p[3] != 255 \|\| math.Abs(float64(p[0])-148) > 1 \|\| p[0] != p[1] \|\| p[1] != p[2] {
40	-	t.Fatalf("cursor white: %v", p)
41	-	}
42	-	if PQEncode(0) != 0 \|\| math.Abs(PQEncode(10000)-1) > 1e-9 {
43	-	t.Fatal("PQ endpoints")
44	-	}
45	-	}
46	-
47	-	func TestCacheKeepsLastConversion(t *testing.T) {
48	-	var c Cache
49	-	px := []byte{255, 255, 255, 255}
50	-	a := c.Convert(px, 1, 1, 64, 203)
51	-	if c.Len() != 4 \|\| a[0] != 148 {
52	-	t.Fatalf("len %d pixel %v", c.Len(), a)
53	-	}
54	-	first := c.Key()
55	-	if b := c.Convert(px, 1, 1, 64, 203); &a[0] != &b[0] {
56	-	t.Fatal("same image converted again")
57	-	}
58	-	for i := range 12 {
59	-	v := byte(i * 18)
60	-	c.Convert([]byte{v, v, v, 255}, 1, 1, 64, 203)
61	-	if c.Len() != 4 {
62	-	t.Fatalf("cache grew after image %d: %d", i, c.Len())
63	-	}
64	-	}
65	-	if c.Key() == first {
66	-	t.Fatal("conversion not replaced")
67	-	}
68	-	c.Convert(px, 1, 1, 64, 100)
69	-	if c.Key() == first {
70	-	t.Fatal("nits not part of the key")
71	-	}
72	-	c.Reset()
73	-	if c.Len() != 0 \|\| c.Key() != [32]byte{} {
74	-	t.Fatal("reset left a conversion")
75	-	}
76	-	}

@@ -1,8 +1,11 @@
1	1		package vulkan
2	2
3	3		import (
	4	+	"crypto/sha256"
	5	+	"encoding/binary"
4	6		"errors"
5	7		"fmt"
	8	+	"math"
6	9		"os"
7	10		"unsafe"
8	11

@@ -105,6 +108,26 @@ func (r Renderer) cursorImage(size int) (cursorImage, ports.DMABuf, error) {
105	108		return c, ports.DMABuf{Width: size, Height: size, Format: fourccARGB, Modifier: 0, Planes: []ports.DMABufPlane{{File: f, Offset: uint32(layout.Offset), Stride: uint32(layout.RowPitch)}}}, nil
106	109		}
107	110
	111	+	// cursorConversion keeps only the last converted image, bounded by the
	112	+	// cursor plane's maximum dimensions, regardless of cursor theme size.
	113	+	type cursorConversion struct {
	114	+	key [32]byte
	115	+	pixels []byte
	116	+	}
	117	+
	118	+	func cursorKey(pixels []byte, w, h int, nits float64) [32]byte {
	119	+	var header [24]byte
	120	+	binary.LittleEndian.PutUint64(header[:8], uint64(w))
	121	+	binary.LittleEndian.PutUint64(header[8:16], uint64(h))
	122	+	binary.LittleEndian.PutUint64(header[16:], math.Float64bits(nits))
	123	+	digest := sha256.New()
	124	+	_, _ = digest.Write(header[:])
	125	+	_, _ = digest.Write(pixels)
	126	+	var key [32]byte
	127	+	digest.Sum(key[:0])
	128	+	return key
	129	+	}
	130	+
108	131		// WriteCursor copies premultiplied ARGB8888 pixels (w×h, w*4 per row)
109	132		// into cursor image i at its row pitch, cropped and cleared around.
110	133		func (r *Renderer) WriteCursor(i int, pixels []byte, w, h int) error {

@@ -118,13 +141,27 @@ func (r *Renderer) WriteCursor(i int, pixels []byte, w, h int) error {
118	141		mem := unsafe.Slice((byte)(c.mapped), c.pitchc.size)
119	142		clear(mem)
120	143		cw := min(w, c.size) * 4
121		-	src, stride := pixels, w*4
122	144		if r.hdrNits > 0 {
123	145		// WriteCursor is called only on image changes, never on moves.
124		-	src, stride = r.cursorCache.Convert(pixels, w, h, c.size, r.hdrNits), cw
125		-	}
126		-	for y := range min(h, c.size) {
127		-	copy(mem[yc.pitch:yc.pitch+cw], src[ystride:ystride+cw])
	146	+	key := cursorKey(pixels[:wh4], w, h, r.hdrNits)
	147	+	converted := r.cursorCache.pixels
	148	+	if converted == nil \|\| r.cursorCache.key != key {
	149	+	converted = make([]byte, cw*min(h, c.size))
	150	+	for y := range min(h, c.size) {
	151	+	copy(converted[ycw:(y+1)cw], pixels[yw4:yw4+cw])
	152	+	for x := 0; x < cw; x += 4 {
	153	+	hdrCursorPixel(converted[ycw+x:ycw+x+4], r.hdrNits)
	154	+	}
	155	+	}
	156	+	r.cursorCache = cursorConversion{key: key, pixels: converted}
	157	+	}
	158	+	for y := range min(h, c.size) {
	159	+	copy(mem[yc.pitch:yc.pitch+cw], converted[ycw:(y+1)cw])
	160	+	}
	161	+	} else {
	162	+	for y := range min(h, c.size) {
	163	+	copy(mem[yc.pitch:yc.pitch+cw], pixels[yw4:yw4+cw])
	164	+	}
128	165		}
129	166		return nil
130	167		}


@@ -47,7 +47,7 @@ func TestCursorBuffersWriteCursor(t *testing.T) {
47	47		}
48	48		}
49	49
50		-	func TestHDRCursorWritesBothImagesAndInvalidates(t *testing.T) {
	50	+	func TestHDRCursorCachesConversion(t *testing.T) {
51	51		r, err := New(32, 16)
52	52		if err != nil {
53	53		t.Skipf("Vulkan unavailable: %v", err)

@@ -65,6 +65,28 @@ func TestHDRCursorWritesBothImagesAndInvalidates(t *testing.T) {
65	65		if err := r.WriteCursor(0, px, 1, 1); err != nil {
66	66		t.Fatal(err)
67	67		}
	68	+	if len(r.cursorCache.pixels) != 4 {
	69	+	t.Fatalf("cache size %d", len(r.cursorCache.pixels))
	70	+	}
	71	+	if err := r.WriteCursor(1, px, 1, 1); err != nil {
	72	+	t.Fatal(err)
	73	+	}
	74	+	if len(r.cursorCache.pixels) != 4 {
	75	+	t.Fatalf("cache grew on reselect: %d", len(r.cursorCache.pixels))
	76	+	}
	77	+	first := r.cursorCache.key
	78	+	for i := 0; i < 12; i++ {
	79	+	color := byte(i * 18)
	80	+	if err := r.WriteCursor(1, []byte{color, color, color, 255}, 1, 1); err != nil {
	81	+	t.Fatal(err)
	82	+	}
	83	+	if len(r.cursorCache.pixels) != 4 {
	84	+	t.Fatalf("cache grew after image %d: %d", i, len(r.cursorCache.pixels))
	85	+	}
	86	+	}
	87	+	if first == r.cursorCache.key {
	88	+	t.Fatal("cursor conversion not replaced")
	89	+	}
68	90		if err := r.WriteCursor(1, px, 1, 1); err != nil {
69	91		t.Fatal(err)
70	92		}

@@ -75,13 +97,10 @@ func TestHDRCursorWritesBothImagesAndInvalidates(t *testing.T) {
75	97		}
76	98		}
77	99		r.SetHDR(0)
78		-	if r.cursorCache.Len() != 0 {
79		-	t.Fatal("SetHDR kept conversion")
80		-	}
81	100		if err := r.WriteCursor(0, px, 1, 1); err != nil {
82	101		t.Fatal(err)
83	102		}
84		-	if got := unsafe.Slice((*byte)(r.cursors[0].mapped), 4); got[0] != 255 \|\| r.cursorCache.Len() != 0 {
85		-	t.Fatalf("SDR cursor/cache: %v %d", got, r.cursorCache.Len())
	103	+	if got := unsafe.Slice((*byte)(r.cursors[0].mapped), 4); got[0] != 255 \|\| len(r.cursorCache.pixels) != 0 {
	104	+	t.Fatalf("SDR cursor/cache: %v %d", got, len(r.cursorCache.pixels))
86	105		}
87	106		}

 	}
 }
-func TestHDRCursorWritesBothImagesAndInvalidates(t *testing.T) {
+func TestHDRCursorCachesConversion(t *testing.T) {
 	r, err := New(32, 16)
 	if err != nil {
 		t.Skipf("Vulkan unavailable: %v", err)
 	if err := r.WriteCursor(0, px, 1, 1); err != nil {
 		t.Fatal(err)
 	}
+	if len(r.cursorCache.pixels) != 4 {
+		t.Fatalf("cache size %d", len(r.cursorCache.pixels))
+	}
+	if err := r.WriteCursor(1, px, 1, 1); err != nil {
+		t.Fatal(err)
+	}
+	if len(r.cursorCache.pixels) != 4 {
+		t.Fatalf("cache grew on reselect: %d", len(r.cursorCache.pixels))
+	}
+	first := r.cursorCache.key
+	for i := 0; i < 12; i++ {
+		color := byte(i * 18)
+		if err := r.WriteCursor(1, []byte{color, color, color, 255}, 1, 1); err != nil {
+			t.Fatal(err)
+		}
+		if len(r.cursorCache.pixels) != 4 {
+			t.Fatalf("cache grew after image %d: %d", i, len(r.cursorCache.pixels))
+		}
+	}
+	if first == r.cursorCache.key {
+		t.Fatal("cursor conversion not replaced")
+	}
 	if err := r.WriteCursor(1, px, 1, 1); err != nil {
 		t.Fatal(err)
 	}
 		}
 	}
 	r.SetHDR(0)
-	if r.cursorCache.Len() != 0 {
-		t.Fatal("SetHDR kept conversion")
-	}
 	if err := r.WriteCursor(0, px, 1, 1); err != nil {
 		t.Fatal(err)
 	}
-	if got := unsafe.Slice((*byte)(r.cursors[0].mapped), 4); got[0] != 255 || r.cursorCache.Len() != 0 {
+	if got := unsafe.Slice((*byte)(r.cursors[0].mapped), 4); got[0] != 255 || len(r.cursorCache.pixels) != 0 {
-		t.Fatalf("SDR cursor/cache: %v %d", got, r.cursorCache.Len())
+		t.Fatalf("SDR cursor/cache: %v %d", got, len(r.cursorCache.pixels))
 	}
 }


@@ -28,7 +28,7 @@ type hdrPass struct {
28	28		// remains owner-goroutine confined; all GPU objects are reused each frame.
29	29		func (r *Renderer) SetHDR(nits float64) {
30	30		if nits != r.hdrNits {
31		-	r.cursorCache.Reset()
	31	+	r.cursorCache = cursorConversion{}
32	32		if r.hdrNits > 0 && nits > 0 {
33	33		r.hdrOwn.valid = false
34	34		}

@@ -47,7 +47,7 @@ func (r *Renderer) SetHDR(nits float64) {
47	47		}
48	48		r.hdrNits = nits
49	49		if nits <= 0 {
50		-	r.cursorCache.Reset()
	50	+	r.cursorCache = cursorConversion{}
51	51		r.hdrError = nil
52	52		return
53	53		}

@@ -1,13 +1,21 @@
1	1		package vulkan
2	2
3		-	import (
4		-	"math"
	3	+	import "math"
5	4
6		-	"github.com/bnema/neferwl/internal/adapters/hdrcursor"
7		-	)
	5	+	var srgbTable = func() (table [256]float64) {
	6	+	for i := range table {
	7	+	table[i] = srgbToLinear(float64(i) / 255)
	8	+	}
	9	+	return
	10	+	}()
8	11
9	12		// srgbToLinear decodes a unit-range sRGB component.
10		-	func srgbToLinear(v float64) float64 { return hdrcursor.SRGBToLinear(v) }
	13	+	func srgbToLinear(v float64) float64 {
	14	+	if v <= 0.04045 {
	15	+	return v / 12.92
	16	+	}
	17	+	return math.Pow((v+0.055)/1.055, 2.4)
	18	+	}
11	19
12	20		// linearToSRGB encodes a unit-range linear component; the inverse of
13	21		// srgbToLinear.

@@ -19,7 +27,13 @@ func linearToSRGB(v float64) float64 {
19	27		}
20	28
21	29		// pqEncode encodes absolute luminance in nits using SMPTE ST 2084.
22		-	func pqEncode(nits float64) float64 { return hdrcursor.PQEncode(nits) }
	30	+	func pqEncode(nits float64) float64 {
	31	+	if nits <= 0 {
	32	+	return 0
	33	+	}
	34	+	x := math.Pow(min(nits, 10000)/10000, 2610.0/16384)
	35	+	return math.Pow((3424.0/4096+2413.0/128x)/(1+2392.0/128x), 2523.0/32)
	36	+	}
23	37
24	38		// hdrPixel transforms an unassociated sRGB triplet into BT.2020 PQ.
25	39		func hdrPixel(red, green, blue, nits float64) (float64, float64, float64) {

@@ -28,3 +42,17 @@ func hdrPixel(red, green, blue, nits float64) (float64, float64, float64) {
28	42		pqEncode((0.069097r + 0.919540g + 0.011362b) nits),
29	43		pqEncode((0.016391r + 0.088013g + 0.895595b) nits)
30	44		}
	45	+
	46	+	// hdrCursorPixel converts premultiplied BGRA bytes, preserving alpha.
	47	+	// The source is quantized to its 8-bit unassociated sRGB value for the LUT.
	48	+	func hdrCursorPixel(p []byte, nits float64) {
	49	+	a := float64(p[3]) / 255
	50	+	if a == 0 {
	51	+	clear(p[:3])
	52	+	return
	53	+	}
	54	+	index := func(v byte) int { return min(255, int(math.Round(float64(v)/a))) }
	55	+	r, g, b := srgbTable[index(p[2])], srgbTable[index(p[1])], srgbTable[index(p[0])]
	56	+	r, g, b = pqEncode((0.627404r+0.329283g+0.043313b)nits), pqEncode((0.069097r+0.919540g+0.011362b)nits), pqEncode((0.016391r+0.088013g+0.895595b)nits)
	57	+	p[0], p[1], p[2] = byte(math.Round(ba255)), byte(math.Round(ga255)), byte(math.Round(ra255))
	58	+	}


@@ -13,4 +13,9 @@ func TestPQMath(t *testing.T) {
13	13		if pqEncode(0) != 0 \|\| math.Abs(pqEncode(10000)-1) > 1e-9 {
14	14		t.Fatal("PQ endpoints")
15	15		}
	16	+	p := []byte{255, 255, 255, 255}
	17	+	hdrCursorPixel(p, 203)
	18	+	if p[3] != 255 \|\| math.Abs(float64(p[0])-148) > 1 \|\| p[0] != p[1] \|\| p[1] != p[2] {
	19	+	t.Fatalf("cursor white: %v", p)
	20	+	}
16	21		}


@@ -9,7 +9,6 @@ import (
9	9		"strconv"
10	10		"unsafe"
11	11
12		-	"github.com/bnema/neferwl/internal/adapters/hdrcursor"
13	12		"github.com/bnema/neferwl/internal/adapters/hintlabel"
14	13		"github.com/bnema/neferwl/internal/ports"
15	14		"github.com/bnema/zerowrap"

@@ -56,7 +55,7 @@ type Renderer struct {
56	55		virtual bool
57	56		physical vk.PhysicalDevice
58	57		// One converted cursor image is kept; changes replace it in bounded memory.
59		-	cursorCache hdrcursor.Cache
	58	+	cursorCache cursorConversion
60	59		// lastHDRTarget is the index in targets of the exported PQ target the
61	60		// last HDR frame rendered into; -1 when the current targets hold none.
62	61		lastHDRTarget int

 	"strconv"
 	"unsafe"
-	"github.com/bnema/neferwl/internal/adapters/hdrcursor"
 	"github.com/bnema/neferwl/internal/adapters/hintlabel"
 	"github.com/bnema/neferwl/internal/ports"
 	"github.com/bnema/zerowrap"
 	virtual  bool
 	physical vk.PhysicalDevice
 	// One converted cursor image is kept; changes replace it in bounded memory.
-	cursorCache hdrcursor.Cache
+	cursorCache cursorConversion
 	// lastHDRTarget is the index in targets of the exported PQ target the
 	// last HDR frame rendered into; -1 when the current targets hold none.
 	lastHDRTarget int


@@ -5,7 +5,7 @@ pkgrel=1
5	5		pkgdesc='A Wayland compositor that spends its frames on your apps, not on itself'
6	6		arch=('x86_64')
7	7		url='https://github.com/bnema/neferwl'
8		-	license=('AGPL-3.0-only')
	8	+	license=('GPL-3.0-only')
9	9		# Loaded at runtime (purego, no cgo): not seen by makepkg's library scan.
10	10		depends=('glibc' 'libinput' 'libxkbcommon' 'seatd' 'systemd-libs' 'vulkan-icd-loader'
11	11		'vulkan-driver' 'wayland' 'dbus' 'libcap')


@@ -5,7 +5,7 @@ pkgrel=1
5		pkgdesc='A Wayland compositor that spends its frames on your apps, not on itself'	5		pkgdesc='A Wayland compositor that spends its frames on your apps, not on itself'
6		arch=('x86_64')	6		arch=('x86_64')
7		url='https://github.com/bnema/neferwl'	7		url='https://github.com/bnema/neferwl'
8	-	license=('AGPL-3.0-only')	8	+	license=('GPL-3.0-only')
9		# Loaded at runtime (purego, no cgo): not seen by makepkg's library scan.	9		# Loaded at runtime (purego, no cgo): not seen by makepkg's library scan.
10		depends=('glibc' 'libinput' 'libxkbcommon' 'seatd' 'systemd-libs' 'vulkan-icd-loader'	10		depends=('glibc' 'libinput' 'libxkbcommon' 'seatd' 'systemd-libs' 'vulkan-icd-loader'
11		'vulkan-driver' 'wayland' 'dbus' 'libcap')	11		'vulkan-driver' 'wayland' 'dbus' 'libcap')


@@ -7,7 +7,7 @@ pkgrel=1
7	7		pkgdesc='A Wayland compositor that spends its frames on your apps, not on itself (git version)'
8	8		arch=('x86_64' 'aarch64')
9	9		url='https://git.bnema.dev/neferwl'
10		-	license=('AGPL-3.0-only')
	10	+	license=('GPL-3.0-only')
11	11		# Loaded at runtime (purego, no cgo): not seen by makepkg's library scan.
12	12		depends=('glibc' 'libinput' 'libxkbcommon' 'seatd' 'systemd-libs' 'vulkan-icd-loader'
13	13		'vulkan-driver' 'wayland' 'dbus' 'libcap')


@@ -7,7 +7,7 @@ pkgrel=1
7		pkgdesc='A Wayland compositor that spends its frames on your apps, not on itself (git version)'	7		pkgdesc='A Wayland compositor that spends its frames on your apps, not on itself (git version)'
8		arch=('x86_64' 'aarch64')	8		arch=('x86_64' 'aarch64')
9		url='https://git.bnema.dev/neferwl'	9		url='https://git.bnema.dev/neferwl'
10	-	license=('AGPL-3.0-only')	10	+	license=('GPL-3.0-only')
11		# Loaded at runtime (purego, no cgo): not seen by makepkg's library scan.	11		# Loaded at runtime (purego, no cgo): not seen by makepkg's library scan.
12		depends=('glibc' 'libinput' 'libxkbcommon' 'seatd' 'systemd-libs' 'vulkan-icd-loader'	12		depends=('glibc' 'libinput' 'libxkbcommon' 'seatd' 'systemd-libs' 'vulkan-icd-loader'
13		'vulkan-driver' 'wayland' 'dbus' 'libcap')	13		'vulkan-driver' 'wayland' 'dbus' 'libcap')

Problem

Change

Checks

Merge settings

Comments1 open / 1