Dmitry Sergeev
308 lines
6.9 KiB
Go
308 lines
6.9 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"flag"
|
|
"fmt"
|
|
"log"
|
|
"mxl-player/internal/renderer"
|
|
"mxl-player/internal/sdl"
|
|
"mxl-player/internal/source"
|
|
"runtime"
|
|
"time"
|
|
"unsafe"
|
|
|
|
vk "github.com/christerso/vulkan-go/vk"
|
|
"github.com/qvest-digital/go-mxl/mxl"
|
|
)
|
|
|
|
const (
|
|
APP_NAME = "MXL Player"
|
|
APP_VER = "0.1.0"
|
|
WIN_WIDTH int32 = 1280
|
|
WIN_HEIGHT int32 = 720
|
|
)
|
|
|
|
func main() {
|
|
videoFlowId := "5fbec3b1-1b0f-417d-9059-8b94a47197ed"
|
|
audioFlowId := "5fbec3b1-1b0f-417d-9059-8b94a47197ec"
|
|
mxlDomain := flag.String("d", "/dev/shm/mxl", "MXL domain")
|
|
mxlVideoFlowID := flag.String("v", videoFlowId, "MXL video flow UUID")
|
|
mxlAudioFlowID := flag.String("a", audioFlowId, "MXL audio flow UUID")
|
|
fmt.Println(*mxlAudioFlowID)
|
|
flag.Parse()
|
|
|
|
runtime.LockOSThread()
|
|
if err := sdl.Load(); err != nil {
|
|
panic(err)
|
|
}
|
|
if !sdl.Init(sdl.InitVideo) {
|
|
log.Fatalf("SDL_Init: %s", sdl.GetError())
|
|
return
|
|
}
|
|
|
|
windowHandler := sdl.CreateWindow(fmt.Sprintf("%s %s", APP_NAME, APP_VER), WIN_WIDTH, WIN_HEIGHT, sdl.WindowVulkan|sdl.WindowResizable)
|
|
if windowHandler == 0 {
|
|
sdl.Quit()
|
|
log.Fatalf("SDL_CreateWindow: %s", sdl.GetError())
|
|
return
|
|
}
|
|
|
|
if err := vk.Load(); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
sdlExtensions := sdl.VulkanGetInstanceExtensions()
|
|
if len(sdlExtensions) == 0 {
|
|
log.Fatal("sdlVulkanGetInstanceExtensions is 0")
|
|
return
|
|
}
|
|
var vkLayers []string
|
|
vkExtensions := append(sdlExtensions, vk.ExtDebugUtils)
|
|
vkInstance, err := vk.CreateInstance(vk.InstanceConfig{
|
|
ApplicationName: APP_NAME,
|
|
EngineName: "no engine",
|
|
Extensions: vkExtensions,
|
|
Layers: vkLayers,
|
|
})
|
|
if err != nil {
|
|
log.Fatalf(err.Error())
|
|
panic(err)
|
|
}
|
|
defer vkInstance.Destroy()
|
|
|
|
var vkSurface uint64
|
|
if !sdl.VulkanCreateSurface(windowHandler, uintptr(vkInstance), 0, &vkSurface) {
|
|
log.Fatalf("SDL_Vulkan_CreateSurface: %s", sdl.GetError())
|
|
return
|
|
}
|
|
vkSurf := vk.SurfaceKHR(vkSurface)
|
|
defer vkInstance.DestroySurface(vkSurf)
|
|
|
|
devices, err := vkInstance.EnumeratePhysicalDevices()
|
|
if err != nil || len(devices) == 0 {
|
|
panic("No Vulkan devices")
|
|
}
|
|
for _, pd := range devices {
|
|
info := pd.Info()
|
|
fmt.Printf("%s (%s)\n", info.Name, info.Type)
|
|
}
|
|
vkPhysDevice := devices[0]
|
|
|
|
gfx, err := vkPhysDevice.GraphicsFamily()
|
|
if err != nil {
|
|
panic(err.Error())
|
|
}
|
|
if !vkPhysDevice.SurfaceSupport(gfx, vkSurf) {
|
|
log.Fatalf("graphics queue cannot present")
|
|
return
|
|
}
|
|
|
|
vkDevice, vkQueue, err := vkPhysDevice.CreateDevice(vk.DeviceConfig{
|
|
GraphicsFamily: gfx,
|
|
Extensions: []string{"VK_KHR_swapchain"},
|
|
})
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
defer vkDevice.Destroy()
|
|
|
|
mxlSrc, err := source.Open(*mxlDomain, *mxlVideoFlowID)
|
|
if err != nil {
|
|
log.Fatalf("source: %v", err)
|
|
}
|
|
defer func() { _ = mxlSrc.Close() }()
|
|
fmt.Printf("source: %dx%d stride=%d\n", mxlSrc.Width(), mxlSrc.Height(), mxlSrc.Stride())
|
|
|
|
r, err := renderer.New(renderer.Config{
|
|
PhysDevice: vkPhysDevice,
|
|
Device: vkDevice,
|
|
Queue: vkQueue,
|
|
Surface: vkSurf,
|
|
Window: windowHandler,
|
|
GraphicsFamily: gfx,
|
|
VideoWidth: mxlSrc.Width(),
|
|
VideoHeight: mxlSrc.Height(),
|
|
VideoStride: mxlSrc.Stride(),
|
|
})
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
defer r.Destroy()
|
|
defer vkDevice.WaitIdle()
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
grant := make(chan struct{}, 1)
|
|
staged := make(chan uint64)
|
|
failed := make(chan struct{})
|
|
|
|
reopen := func() error {
|
|
if err := mxlSrc.Close(); err != nil {
|
|
return fmt.Errorf("close old source: %w", err)
|
|
}
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return ctx.Err()
|
|
default:
|
|
}
|
|
s, err := source.Open(*mxlDomain, *mxlVideoFlowID)
|
|
if err == nil {
|
|
newSize := vk.DeviceSize(s.Stride()) * vk.DeviceSize(s.Height())
|
|
if newSize != r.FrameSize() {
|
|
if err := r.RecreateBuffers(newSize); err != nil {
|
|
return err
|
|
}
|
|
fmt.Printf("source: resolution changed, frameSize=%d\n", newSize)
|
|
}
|
|
mxlSrc = s
|
|
return nil
|
|
}
|
|
log.Printf("source: reopen retry: %v", err)
|
|
time.Sleep(500 * time.Millisecond)
|
|
}
|
|
}
|
|
|
|
go func() {
|
|
for {
|
|
select {
|
|
case <-grant:
|
|
case <-ctx.Done():
|
|
return
|
|
}
|
|
f, err := mxlSrc.NextCtx(ctx, 200*time.Millisecond)
|
|
if err != nil {
|
|
if errors.Is(err, context.Canceled) {
|
|
return
|
|
}
|
|
if errors.Is(err, mxl.ErrFlowInvalid) {
|
|
log.Printf("source: flow invalid, reopening")
|
|
if rerr := reopen(); rerr != nil {
|
|
log.Printf("source: reopen failed: %v", rerr)
|
|
cancel()
|
|
return
|
|
}
|
|
select {
|
|
case failed <- struct{}{}:
|
|
case <-ctx.Done():
|
|
return
|
|
}
|
|
continue
|
|
}
|
|
log.Printf("source: %v", err)
|
|
cancel()
|
|
return
|
|
}
|
|
vk.CopyToMapped(r.StagingMapped(), f.Payload)
|
|
select {
|
|
case staged <- f.Index:
|
|
case <-ctx.Done():
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
|
|
running := true
|
|
resized := false
|
|
granted := false
|
|
fullscreen := false
|
|
var (
|
|
lastIndex uint64
|
|
dropped uint64
|
|
frameCount uint64
|
|
lastReport time.Time
|
|
)
|
|
for running {
|
|
frameStart := time.Now()
|
|
var event [128]byte
|
|
for sdl.PollEvent(unsafe.Pointer(&event[0])) {
|
|
eventType := *(*uint32)(unsafe.Pointer(&event[0]))
|
|
switch eventType {
|
|
case sdl.EventQuit:
|
|
running = false
|
|
case sdl.EventWindowResized, sdl.EventPixelSizeChanged:
|
|
resized = true
|
|
case sdl.EventKeyDown:
|
|
key := *(*int32)(unsafe.Pointer(&event[28]))
|
|
switch uint32(key) {
|
|
case sdl.KeyEscape:
|
|
running = false
|
|
case sdl.KeyF:
|
|
fullscreen = !fullscreen
|
|
sdl.SetWindowFullscreen(windowHandler, fullscreen)
|
|
resized = true
|
|
}
|
|
}
|
|
}
|
|
if !running {
|
|
break
|
|
}
|
|
if resized {
|
|
if err := r.RecreateSwapchain(); err != nil {
|
|
if errors.Is(err, renderer.ErrMinimized) {
|
|
resized = true
|
|
continue
|
|
}
|
|
panic(err)
|
|
}
|
|
resized = false
|
|
}
|
|
if !granted {
|
|
select {
|
|
case grant <- struct{}{}:
|
|
granted = true
|
|
case <-ctx.Done():
|
|
running = false
|
|
continue
|
|
}
|
|
}
|
|
var shownIndex uint64
|
|
select {
|
|
case shownIndex = <-staged:
|
|
granted = false
|
|
case <-failed:
|
|
granted = false
|
|
continue
|
|
case <-ctx.Done():
|
|
running = false
|
|
continue
|
|
case <-time.After(100 * time.Millisecond):
|
|
continue
|
|
}
|
|
|
|
err := r.DrawFrame(mxlSrc.Width(), mxlSrc.Height(), mxlSrc.Stride())
|
|
if errors.Is(err, renderer.ErrOutOfDate) {
|
|
if rerr := r.RecreateSwapchain(); rerr != nil {
|
|
if errors.Is(rerr, renderer.ErrMinimized) {
|
|
resized = true
|
|
continue
|
|
}
|
|
panic(rerr)
|
|
}
|
|
continue
|
|
}
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
if lastIndex != 0 && shownIndex > lastIndex {
|
|
if g := shownIndex - lastIndex - 1; g > 0 {
|
|
dropped += g
|
|
}
|
|
}
|
|
lastIndex = shownIndex
|
|
frameCount++
|
|
if now := time.Now(); now.Sub(lastReport) >= time.Second {
|
|
dt := now.Sub(lastReport).Seconds()
|
|
fps := float64(frameCount) / dt
|
|
fmt.Printf("fps=%.1f dropped=%d idx=%d frameTime=%.2fms\n",
|
|
fps, dropped, shownIndex, float64(now.Sub(frameStart).Microseconds())/1000.0)
|
|
frameCount = 0
|
|
dropped = 0
|
|
lastReport = now
|
|
}
|
|
}
|
|
}
|