1package vulkan
2
3import (
4 "fmt"
5 "image"
6 "math"
7 "os"
8 "runtime"
9 "slices"
10 "unsafe"
11
12 "github.com/bnema/neferwl/internal/ports"
13 vk "github.com/bnema/purego-vulkan/vulkan"
14)
15
16// Frames are recorded into a ring of slots, one per frame in flight. The
17// CPU never waits for a frame it just submitted: Render returns a sync
18// file the display waits on (KMS IN_FENCE_FD). A slot's fence is waited
19// only when the slot is reused, and objects a frame read (imports, GPU
20// buffers, client semaphores) are freed only once that frame completed.
21
22// frameSlots is how many frames may be in flight: one per output target.
23const frameSlots = 2
24
25// frameSlot is the command buffer and sync objects of one frame in flight.
26type frameSlot struct {
27 cmd vk.CommandBuffer
28 fence vk.Fence
29 // done is signalled with the frame and exported as its sync file.
30 done vk.Semaphore
31 frame uint64 // the frame recorded last, 0 before any
32 busy bool // submitted, fence not yet seen signalled
33}
34
35// deferredFree runs once frame completed.
36type deferredFree struct {
37 frame uint64
38 free func()
39}
40
41func (r *Renderer) createSlots() error {
42 d := r.dd
43 cmds := make([]vk.CommandBuffer, frameSlots)
44 ai := vk.CommandBufferAllocateInfo{SType: vk.StructureTypeCommandBufferAllocateInfo, CommandPool: r.pool, Level: vk.CommandBufferLevelPrimary, CommandBufferCount: frameSlots}
45 if err := checked("vkAllocateCommandBuffers", d.AllocateCommandBuffers(r.device, &ai, &cmds[0])); err != nil {
46 return err
47 }
48 for i := range r.slots {
49 s := &r.slots[i]
50 s.cmd = cmds[i]
51 fi := vk.FenceCreateInfo{SType: vk.StructureTypeFenceCreateInfo}
52 if err := checked("vkCreateFence", d.CreateFence(r.device, &fi, nil, &s.fence)); err != nil {
53 return err
54 }
55 if err := r.newDone(s); err != nil {
56 return err
57 }
58 }
59 return nil
60}
61
62// newDone creates a slot's frame semaphore, exportable as a sync file when
63// the device allows it; a device that refuses falls back to waiting for
64// frames on the CPU (syncFD off).
65func (r *Renderer) newDone(s *frameSlot) error {
66 d := r.dd
67 si := vk.SemaphoreCreateInfo{SType: vk.StructureTypeSemaphoreCreateInfo}
68 export := vk.ExportSemaphoreCreateInfo{SType: vk.StructureTypeExportSemaphoreCreateInfo, HandleTypes: vk.ExternalSemaphoreHandleTypeSyncFDBit}
69 if r.syncFD {
70 si.Next = unsafe.Pointer(&export)
71 if d.CreateSemaphore(r.device, &si, nil, &s.done) == vk.Success {
72 return nil
73 }
74 r.syncFD = false
75 si.Next = nil
76 }
77 return checked("vkCreateSemaphore", d.CreateSemaphore(r.device, &si, nil, &s.done))
78}
79
80func (r *Renderer) destroySlots() {
81 d := r.dd
82 for i := range r.slots {
83 s := &r.slots[i]
84 if s.fence != 0 {
85 d.DestroyFence(r.device, s.fence, nil)
86 }
87 if s.done != 0 {
88 d.DestroySemaphore(r.device, s.done, nil)
89 }
90 if s.cmd != 0 {
91 d.FreeCommandBuffers(r.device, r.pool, 1, &s.cmd)
92 }
93 *s = frameSlot{}
94 }
95}
96
97// waitFrame blocks until frame n completed. Frames not submitted yet and
98// frames known done return at once. Every slot holding a frame up to n
99// is waited and reset, so its fence is unsignalled before reuse.
100func (r *Renderer) waitFrame(n uint64) error {
101 n = min(n, r.submitted)
102 if n <= r.completed {
103 return nil
104 }
105 for i := range r.slots {
106 s := &r.slots[i]
107 if !s.busy || s.frame > n {
108 continue
109 }
110 if err := checked("vkWaitForFences", r.dd.WaitForFences(r.device, 1, &s.fence, 1, math.MaxUint64)); err != nil {
111 return err
112 }
113 if err := checked("vkResetFences", r.dd.ResetFences(r.device, 1, &s.fence)); err != nil {
114 return err
115 }
116 s.busy = false
117 }
118 r.completed = n
119 r.runDeferred()
120 return nil
121}
122
123// retire frees an object once the frame that last used it completed.
124func (r *Renderer) retire(frame uint64, free func()) {
125 if frame <= r.completed {
126 free()
127 return
128 }
129 r.deferred = append(r.deferred, deferredFree{frame: frame, free: free})
130}
131
132func (r *Renderer) runDeferred() {
133 r.deferred = slices.DeleteFunc(r.deferred, func(f deferredFree) bool {
134 if f.frame <= r.completed {
135 f.free()
136 return true
137 }
138 return false
139 })
140}
141
142// idle records that the device finished every submitted frame.
143func (r *Renderer) idle() {
144 for i := range r.slots {
145 s := &r.slots[i]
146 if s.busy {
147 _ = r.dd.ResetFences(r.device, 1, &s.fence)
148 s.busy = false
149 }
150 }
151 // Frames recorded but never submitted have no GPU work either.
152 r.completed = r.frame
153 r.runDeferred()
154}
155
156// Render draws a frame into the current target. done is signalled when
157// the GPU finished it; nil when the device cannot export a sync file,
158// then the frame is finished on return.
159func (r *Renderer) Render(s ports.Scene, contents map[ports.WindowID]ports.SurfaceContent) (done *os.File, err error) {
160 // A frame that fails before its submit keeps its number: objects it
161 // touched are freed once a later frame completes (never early).
162 r.frame++
163 slot := &r.slots[r.frame%frameSlots]
164 // The slot's previous frame must be done before its command buffer
165 // is recorded again.
166 if slot.busy {
167 if err := r.waitFrame(slot.frame); err != nil {
168 return nil, err
169 }
170 }
171 tg := r.target()
172 hdr := r.hdrNits > 0 && len(r.targets) > 0
173 if r.hdrNits > 0 && !hdr {
174 return nil, fmt.Errorf("HDR composition requires an exported target")
175 }
176 if hdr {
177 tg = &r.hdrOwn
178 }
179 dmg := r.frameDamage(tg, s, image.Rect(0, 0, r.width, r.height))
180 ds := r.draws(s, contents, dmg)
181 dmg.finish()
182 r.dropPools()
183 partial := !dmg.all()
184 if partial {
185 // The pass keeps the image: repaint the background under the
186 // region, then everything clipped to it.
187 // Keep the background first without allocating a second draw slice.
188 ds = append(ds, draw{})
189 copy(ds[1:], ds[:len(ds)-1])
190 ds[0] = r.fillDraw(dmg.area, parseColor(s.Background))
191 ds = dmg.clip(ds)
192 r.scratchDraws = ds
193 r.redrawn += dmg.area.Dx() * dmg.area.Dy()
194 } else {
195 r.redrawn += r.width * r.height
196 }
197 d := r.dd
198 cmd := slot.cmd
199 if err := checked("vkResetCommandBuffer", d.ResetCommandBuffer(cmd, 0)); err != nil {
200 return nil, err
201 }
202 begin := vk.CommandBufferBeginInfo{SType: vk.StructureTypeCommandBufferBeginInfo, Flags: vk.CommandBufferUsageOneTimeSubmitBit}
203 if err := checked("vkBeginCommandBuffer", d.BeginCommandBuffer(cmd, &begin)); err != nil {
204 return nil, err
205 }
206 // A full redraw clears the target: its old contents never matter
207 // (UNDEFINED). A partial one keeps them.
208 b := vk.ImageMemoryBarrier{SType: vk.StructureTypeImageMemoryBarrier, DstAccessMask: vk.AccessColorAttachmentWriteBit, OldLayout: vk.ImageLayoutUndefined, NewLayout: vk.ImageLayoutColorAttachmentOptimal, SrcQueueFamilyIndex: queueFamilyIgnored, DstQueueFamilyIndex: queueFamilyIgnored, Image: tg.image, SubresourceRange: colorRange}
209 if partial {
210 b.OldLayout = tg.layout
211 b.DstAccessMask |= vk.AccessColorAttachmentReadBit
212 }
213 if tg.exported {
214 // Acquire from the display (foreign queue family).
215 b.SrcQueueFamilyIndex, b.DstQueueFamilyIndex = vk.QueueFamilyForeignEXT, r.family
216 }
217 d.CmdPipelineBarrier(cmd, vk.PipelineStageTransferBit|vk.PipelineStageColorAttachmentOutputBit, vk.PipelineStageColorAttachmentOutputBit, 0, 0, nil, 0, nil, 1, &b)
218 // Client buffers come from the foreign queue family (their driver)
219 // and go back to it after the frame, so the next frame acquires them.
220 dmas := r.frameDMAs[:0]
221 if r.frameAcquires == nil {
222 r.frameAcquires = make(map[*imported]*os.File)
223 }
224 clear(r.frameAcquires)
225 acquires := r.frameAcquires
226 for _, dr := range ds {
227 if dr.im != nil && !slices.Contains(dmas, dr.im) {
228 dmas = append(dmas, dr.im)
229 dr.im.last = r.frame
230 }
231 if dr.acquire != nil {
232 acquires[dr.im] = dr.acquire
233 }
234 }
235 r.frameDMAs = dmas
236 r.ownership(cmd, dmas, true)
237 r.recordDraws(cmd, tg.view, parseColor(s.Background), ds, partial)
238 r.ownership(cmd, dmas, false)
239 if hdr {
240 r.recordHDR(cmd, r.targets[r.current])
241 }
242 if !hdr {
243 b.SrcAccessMask, b.OldLayout = vk.AccessColorAttachmentWriteBit, vk.ImageLayoutColorAttachmentOptimal
244 b.SrcQueueFamilyIndex, b.DstQueueFamilyIndex = queueFamilyIgnored, queueFamilyIgnored
245 if tg.exported {
246 // Release to the display: KMS scans it out after the fence.
247 b.NewLayout, b.DstAccessMask = vk.ImageLayoutGeneral, 0
248 b.SrcQueueFamilyIndex, b.DstQueueFamilyIndex = r.family, vk.QueueFamilyForeignEXT
249 d.CmdPipelineBarrier(cmd, vk.PipelineStageColorAttachmentOutputBit, vk.PipelineStageBottomOfPipeBit, 0, 0, nil, 0, nil, 1, &b)
250 } else {
251 b.NewLayout, b.DstAccessMask = vk.ImageLayoutTransferSrcOptimal, vk.AccessTransferReadBit
252 d.CmdPipelineBarrier(cmd, vk.PipelineStageColorAttachmentOutputBit, vk.PipelineStageTransferBit, 0, 0, nil, 0, nil, 1, &b)
253 }
254 }
255 if err := checked("vkEndCommandBuffer", d.EndCommandBuffer(cmd)); err != nil {
256 return nil, err
257 }
258 // Wait for the client's GPU writes to each buffer: its explicit
259 // acquire fence, else the buffer's implicit fences.
260 waits := r.frameWaits[:0]
261 for _, im := range dmas {
262 if f := acquires[im]; f != nil {
263 if sem := r.importFence(f); sem != 0 {
264 waits = append(waits, sem)
265 }
266 } else {
267 waits = r.appendReadFences(waits, im)
268 }
269 }
270 r.frameWaits = waits
271 frame := r.frame
272 for _, sem := range waits {
273 sem := sem
274 r.retire(frame, func() { d.DestroySemaphore(r.device, sem, nil) })
275 }
276 submit := vk.SubmitInfo{SType: vk.StructureTypeSubmitInfo, CommandBufferCount: 1, CommandBuffers: &cmd}
277 if cap(r.frameStages) < len(waits) {
278 r.frameStages = make([]vk.PipelineStageFlags, len(waits))
279 }
280 stages := r.frameStages[:len(waits)]
281 if len(waits) > 0 {
282 for i := range stages {
283 stages[i] = vk.PipelineStageFragmentShaderBit
284 }
285 submit.WaitSemaphoreCount, submit.WaitSemaphores, submit.WaitDstStageMask = uint32(len(waits)), &waits[0], &stages[0]
286 }
287 if r.syncFD {
288 submit.SignalSemaphoreCount, submit.SignalSemaphores = 1, &slot.done
289 }
290 if err := checked("vkQueueSubmit", d.QueueSubmit(r.queue, 1, &submit, slot.fence)); err != nil {
291 return nil, err
292 }
293 runtime.KeepAlive(stages)
294 runtime.KeepAlive(waits)
295 slot.frame, slot.busy, r.submitted = frame, true, frame
296 if hdr {
297 // recordHDR left the composed linear image in TRANSFER_SRC for capture.
298 tg.layout = vk.ImageLayoutTransferSrcOptimal
299 r.targets[r.current].layout = vk.ImageLayoutGeneral
300 } else {
301 tg.layout = b.NewLayout
302 }
303 oldWindows := tg.windows
304 tg.hold(s, dmg)
305 r.damageDrawn = oldWindows
306 r.last = tg
307 r.dropUnused()
308 r.dropShm()
309 if !r.syncFD {
310 return nil, r.waitFrame(frame)
311 }
312 var fd int32
313 get := vk.SemaphoreGetFdInfoKHR{SType: vk.StructureTypeSemaphoreGetFDInfoKHR, Semaphore: slot.done, HandleType: vk.ExternalSemaphoreHandleTypeSyncFDBit}
314 if d.GetSemaphoreFdKHR(r.device, &get, &fd) != vk.Success {
315 // The frame is drawn: finish it on the CPU. The semaphore stays
316 // signalled: replace it, so the slot's next submit signals a
317 // fresh one.
318 if err := r.waitFrame(frame); err != nil {
319 return nil, err
320 }
321 d.DestroySemaphore(r.device, slot.done, nil)
322 slot.done = 0
323 return nil, r.newDone(slot)
324 }
325 if fd < 0 {
326 // Already signalled: the driver may return -1.
327 return nil, r.waitFrame(frame)
328 }
329 f := os.NewFile(uintptr(fd), "neferwl-frame")
330 if f == nil {
331 return nil, fmt.Errorf("invalid frame sync file %d", fd)
332 }
333 return f, nil
334}
335
336// ownership moves client images between their driver (foreign queue
337// family, GENERAL: their contents survive) and the fragment shader.
338func (r *Renderer) ownership(cmd vk.CommandBuffer, dmas []*imported, acquire bool) {
339 for _, im := range dmas {
340 b := vk.ImageMemoryBarrier{SType: vk.StructureTypeImageMemoryBarrier, Image: im.image, SubresourceRange: colorRange}
341 if im.yuv {
342 b.SubresourceRange.AspectMask = aspectPlane0 | aspectPlane1
343 }
344 if acquire {
345 b.OldLayout, b.NewLayout = vk.ImageLayoutGeneral, vk.ImageLayoutShaderReadOnlyOptimal
346 b.SrcQueueFamilyIndex, b.DstQueueFamilyIndex = vk.QueueFamilyForeignEXT, r.family
347 b.DstAccessMask = vk.AccessShaderReadBit
348 // The frame waits on the client's fence at the fragment
349 // stage: the transfer must come after that wait.
350 r.dd.CmdPipelineBarrier(cmd, vk.PipelineStageFragmentShaderBit, vk.PipelineStageFragmentShaderBit, 0, 0, nil, 0, nil, 1, &b)
351 } else {
352 b.OldLayout, b.NewLayout = vk.ImageLayoutShaderReadOnlyOptimal, vk.ImageLayoutGeneral
353 b.SrcQueueFamilyIndex, b.DstQueueFamilyIndex = r.family, vk.QueueFamilyForeignEXT
354 b.SrcAccessMask = vk.AccessShaderReadBit
355 r.dd.CmdPipelineBarrier(cmd, vk.PipelineStageFragmentShaderBit, vk.PipelineStageBottomOfPipeBit, 0, 0, nil, 0, nil, 1, &b)
356 }
357 }
358}
359
360// oneShot records and runs commands outside the frame ring and waits for
361// them (setup and screenshots only, never per frame).
362func (r *Renderer) oneShot(record func(vk.CommandBuffer)) error {
363 d := r.dd
364 var cmd vk.CommandBuffer
365 ai := vk.CommandBufferAllocateInfo{SType: vk.StructureTypeCommandBufferAllocateInfo, CommandPool: r.pool, Level: vk.CommandBufferLevelPrimary, CommandBufferCount: 1}
366 if err := checked("vkAllocateCommandBuffers", d.AllocateCommandBuffers(r.device, &ai, &cmd)); err != nil {
367 return err
368 }
369 defer d.FreeCommandBuffers(r.device, r.pool, 1, &cmd)
370 var fence vk.Fence
371 fi := vk.FenceCreateInfo{SType: vk.StructureTypeFenceCreateInfo}
372 if err := checked("vkCreateFence", d.CreateFence(r.device, &fi, nil, &fence)); err != nil {
373 return err
374 }
375 defer d.DestroyFence(r.device, fence, nil)
376 begin := vk.CommandBufferBeginInfo{SType: vk.StructureTypeCommandBufferBeginInfo, Flags: vk.CommandBufferUsageOneTimeSubmitBit}
377 if err := checked("vkBeginCommandBuffer", d.BeginCommandBuffer(cmd, &begin)); err != nil {
378 return err
379 }
380 record(cmd)
381 if err := checked("vkEndCommandBuffer", d.EndCommandBuffer(cmd)); err != nil {
382 return err
383 }
384 submit := vk.SubmitInfo{SType: vk.StructureTypeSubmitInfo, CommandBufferCount: 1, CommandBuffers: &cmd}
385 if err := checked("vkQueueSubmit", d.QueueSubmit(r.queue, 1, &submit, fence)); err != nil {
386 return err
387 }
388 return checked("vkWaitForFences", d.WaitForFences(r.device, 1, &fence, 1, math.MaxUint64))
389}
390
391// Clear draws a background-only frame and waits for it.
392func (r *Renderer) Clear(rgb [3]uint8) error {
393 done, err := r.Render(ports.Scene{Background: fmt.Sprintf("#%02x%02x%02x", rgb[0], rgb[1], rgb[2])}, nil)
394 if done != nil {
395 done.Close()
396 }
397 if err != nil {
398 return err
399 }
400 return r.waitFrame(r.frame)
401}