Dmitry Sergeev
588 lines
15 KiB
Go
588 lines
15 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"
|
|
pflag "github.com/spf13/pflag"
|
|
)
|
|
|
|
const (
|
|
APP_NAME = "MXL Player"
|
|
APP_VER = "0.1.0"
|
|
WIN_WIDTH int32 = 1280
|
|
WIN_HEIGHT int32 = 720
|
|
)
|
|
|
|
type CliArgs struct {
|
|
ShowHelp bool
|
|
Domain string
|
|
VideoFlowId string
|
|
AudioFlowId string
|
|
IsFullscreen bool
|
|
PlaybackId uint32
|
|
GpuId uint32
|
|
IsVerbose bool
|
|
ListAudio bool
|
|
ListGPU bool
|
|
}
|
|
|
|
func printCliHelp(fs *pflag.FlagSet) {
|
|
fmt.Printf("%s %s\n", APP_NAME, APP_VER)
|
|
fmt.Println("Usage: mxl-player -d <domain> (-v <uuid> | -a <uuid>) [-f] [-h]...")
|
|
fmt.Println(" [-g <gpu-id>] [-p <playback-id>] [--verbose]")
|
|
fmt.Println(" or: mxl-player [--list-playback] [--list-gpu]")
|
|
fmt.Println(" or: mxl-player (and set everything in GUI)")
|
|
fmt.Println()
|
|
fs.PrintDefaults()
|
|
}
|
|
|
|
func main() {
|
|
// CLI args TODO:
|
|
// help + sample of good usage
|
|
// domain (-d, --domain)
|
|
// video flow UUID (-v, --video)
|
|
// audio flow UUID (-a, --audio)
|
|
// list-audio for list audio playback devices (-la, --list-playback)
|
|
// list-video fpr list video playback devices (-lg, --list-gpu)
|
|
// gpu-id for GPU selection (-p, --playback-id)
|
|
// playback-id for playback id selection (-g, --gpu-id)
|
|
// verbose flag, which turn on logs (-vb,--verbose)
|
|
//
|
|
// video: 5fbec3b1-1b0f-417d-9059-8b94a47197ed
|
|
// audio: 5fbec3b1-1b0f-417d-9059-8b94a47197ec
|
|
|
|
var args CliArgs
|
|
flagSet := pflag.NewFlagSet(APP_NAME, pflag.ExitOnError)
|
|
flagSet.BoolVarP(&args.ShowHelp, "help", "h", false, "Show help message and exit")
|
|
flagSet.StringVarP(&args.Domain, "domain", "d", "", "MXL domain directory")
|
|
flagSet.StringVarP(&args.VideoFlowId, "video", "v", "", "Video flow UUID")
|
|
flagSet.StringVarP(&args.AudioFlowId, "audio", "a", "", "Audio flow UUID")
|
|
flagSet.BoolVarP(&args.IsFullscreen, "fullscreen", "f", false, "Run app in fullscreen mode")
|
|
flagSet.Uint32VarP(&args.GpuId, "gpu-id", "g", 0, "GPU id")
|
|
flagSet.Uint32VarP(&args.PlaybackId, "playback-id", "p", 0, "Playback audio device id")
|
|
flagSet.BoolVar(&args.IsVerbose, "verbose", false, "Verbose output")
|
|
flagSet.BoolVar(&args.ListAudio, "list-playback", false, "List audio playback devices and exit")
|
|
flagSet.BoolVar(&args.ListGPU, "list-gpu", false, "List GPU's and exit")
|
|
pflag.Parse()
|
|
|
|
if args.Domain == "" || args.ShowHelp {
|
|
// TODO. Fix after polishing GUI
|
|
// Cause required/optional will be changed
|
|
printCliHelp(flagSet)
|
|
}
|
|
return
|
|
|
|
var videoFlowId, audioFlowId string
|
|
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")
|
|
flag.Parse()
|
|
if *mxlVideoFlowID == "" && *mxlAudioFlowID == "" {
|
|
log.Fatal("need at least -v <video-flow> or -a <audio-flow>")
|
|
}
|
|
|
|
runtime.LockOSThread()
|
|
if err := sdl.Load(); err != nil {
|
|
panic(err)
|
|
}
|
|
if !sdl.Init(sdl.InitVideo | sdl.InitAudio) {
|
|
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()
|
|
|
|
var (
|
|
syncSrc *source.SyncSource
|
|
videoSrc *source.Source
|
|
audioSrc *source.AudioSource
|
|
audioStream uintptr
|
|
audioBatch uint64
|
|
aChans uint64
|
|
)
|
|
|
|
interleaveAudio := func(samples [][]byte) []byte {
|
|
frameBytes := int(audioBatch) * int(aChans) * 4
|
|
out := make([]byte, frameBytes)
|
|
for ch := uint64(0); ch < aChans; ch++ {
|
|
srcBytes := samples[ch]
|
|
for i := uint64(0); i < audioBatch; i++ {
|
|
srcOff := i * 4
|
|
dstOff := (i*aChans + ch) * 4
|
|
if srcOff+4 <= uint64(len(srcBytes)) {
|
|
copy(out[dstOff:dstOff+4], srcBytes[srcOff:srcOff+4])
|
|
}
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
switch {
|
|
case *mxlVideoFlowID != "" && *mxlAudioFlowID != "":
|
|
syncSrc, err = source.OpenSync(*mxlDomain, *mxlVideoFlowID, *mxlAudioFlowID)
|
|
if err != nil {
|
|
log.Fatalf("sync source: %v", err)
|
|
}
|
|
aChans = syncSrc.Channels()
|
|
audioBatch = uint64(syncSrc.AudioRate().Num) / uint64(syncSrc.Rate().Num)
|
|
if audioBatch == 0 {
|
|
audioBatch = 1
|
|
}
|
|
audioStream = sdl.OpenAudioDeviceStream(sdl.AudioDeviceDefaultPlayback, sdl.AudioSpec{
|
|
Format: sdl.AudioF32,
|
|
Channels: int32(aChans),
|
|
Freq: int32(syncSrc.AudioRate().Num / syncSrc.AudioRate().Den),
|
|
})
|
|
if audioStream == 0 {
|
|
log.Fatalf("audio: %s", sdl.GetError())
|
|
}
|
|
sdl.ResumeAudioStreamDevice(audioStream)
|
|
fmt.Printf("sync: video %dx%d audio %dch batch=%d\n",
|
|
syncSrc.Width(), syncSrc.Height(), aChans, audioBatch)
|
|
|
|
case *mxlVideoFlowID != "":
|
|
videoSrc, err = source.Open(*mxlDomain, *mxlVideoFlowID)
|
|
if err != nil {
|
|
log.Fatalf("source: %v", err)
|
|
}
|
|
fmt.Printf("video: %dx%d stride=%d\n", videoSrc.Width(), videoSrc.Height(), videoSrc.Stride())
|
|
|
|
default:
|
|
audioSrc, err = source.OpenAudio(*mxlDomain, *mxlAudioFlowID)
|
|
if err != nil {
|
|
log.Fatalf("audio source: %v", err)
|
|
}
|
|
aChans = audioSrc.Channels()
|
|
audioBatch = uint64(audioSrc.Rate().Num) / (100 * uint64(audioSrc.Rate().Den))
|
|
if audioBatch == 0 {
|
|
audioBatch = 1
|
|
}
|
|
audioStream = sdl.OpenAudioDeviceStream(sdl.AudioDeviceDefaultPlayback, sdl.AudioSpec{
|
|
Format: sdl.AudioF32,
|
|
Channels: int32(aChans),
|
|
Freq: int32(audioSrc.Rate().Num / audioSrc.Rate().Den),
|
|
})
|
|
if audioStream == 0 {
|
|
log.Fatalf("audio: %s", sdl.GetError())
|
|
}
|
|
sdl.ResumeAudioStreamDevice(audioStream)
|
|
fmt.Printf("audio: %dch %d/%d Hz\n", aChans, audioSrc.Rate().Num, audioSrc.Rate().Den)
|
|
}
|
|
|
|
defer func() {
|
|
if syncSrc != nil {
|
|
_ = syncSrc.Close()
|
|
}
|
|
if videoSrc != nil {
|
|
_ = videoSrc.Close()
|
|
}
|
|
if audioSrc != nil {
|
|
_ = audioSrc.Close()
|
|
}
|
|
}()
|
|
if audioStream != 0 {
|
|
defer sdl.DestroyAudioStream(audioStream)
|
|
}
|
|
|
|
var r *renderer.Renderer
|
|
if *mxlVideoFlowID != "" {
|
|
var w, h, stride uint32
|
|
if syncSrc != nil {
|
|
w, h, stride = syncSrc.Width(), syncSrc.Height(), syncSrc.Stride()
|
|
} else {
|
|
w, h, stride = videoSrc.Width(), videoSrc.Height(), videoSrc.Stride()
|
|
}
|
|
r, err = renderer.New(renderer.Config{
|
|
PhysDevice: vkPhysDevice,
|
|
Device: vkDevice,
|
|
Queue: vkQueue,
|
|
Surface: vkSurf,
|
|
Window: windowHandler,
|
|
GraphicsFamily: gfx,
|
|
VideoWidth: w,
|
|
VideoHeight: h,
|
|
VideoStride: 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 syncSrc != nil {
|
|
_ = syncSrc.Close()
|
|
}
|
|
if videoSrc != nil {
|
|
_ = videoSrc.Close()
|
|
}
|
|
if audioSrc != nil {
|
|
_ = audioSrc.Close()
|
|
}
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return ctx.Err()
|
|
default:
|
|
}
|
|
if syncSrc != nil {
|
|
s, e := source.OpenSync(*mxlDomain, *mxlVideoFlowID, *mxlAudioFlowID)
|
|
if e == nil {
|
|
if r != nil {
|
|
newSize := vk.DeviceSize(s.Stride()) * vk.DeviceSize(s.Height())
|
|
if newSize != r.FrameSize() {
|
|
if e = r.RecreateBuffers(newSize); e != nil {
|
|
return e
|
|
}
|
|
}
|
|
}
|
|
syncSrc = s
|
|
return nil
|
|
}
|
|
log.Printf("source: reopen retry: %v", e)
|
|
} else if videoSrc != nil {
|
|
s, e := source.Open(*mxlDomain, *mxlVideoFlowID)
|
|
if e == nil {
|
|
if r != nil {
|
|
newSize := vk.DeviceSize(s.Stride()) * vk.DeviceSize(s.Height())
|
|
if newSize != r.FrameSize() {
|
|
if e = r.RecreateBuffers(newSize); e != nil {
|
|
return e
|
|
}
|
|
}
|
|
}
|
|
videoSrc = s
|
|
return nil
|
|
}
|
|
log.Printf("source: reopen retry: %v", e)
|
|
} else if audioSrc != nil {
|
|
s, e := source.OpenAudio(*mxlDomain, *mxlAudioFlowID)
|
|
if e == nil {
|
|
audioSrc = s
|
|
return nil
|
|
}
|
|
log.Printf("source: reopen retry: %v", e)
|
|
}
|
|
time.Sleep(500 * time.Millisecond)
|
|
}
|
|
}
|
|
|
|
go func() {
|
|
// Audio-only mode: independent loop, no grant/staged handshake.
|
|
if audioSrc != nil && syncSrc == nil && videoSrc == nil {
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
default:
|
|
}
|
|
queued := sdl.GetAudioStreamQueued(audioStream)
|
|
maxQueued := int32(audioBatch) * int32(aChans) * 4 * 20
|
|
if queued > maxQueued {
|
|
select {
|
|
case <-time.After(10 * time.Millisecond):
|
|
case <-ctx.Done():
|
|
return
|
|
}
|
|
continue
|
|
}
|
|
f, err := audioSrc.NextAudio(ctx, audioBatch, 20*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
|
|
}
|
|
continue
|
|
}
|
|
log.Printf("source: %v", err)
|
|
cancel()
|
|
return
|
|
}
|
|
if f.Samples != nil && audioStream != 0 {
|
|
sdl.PutAudioStreamData(audioStream, interleaveAudio(f.Samples))
|
|
}
|
|
}
|
|
}
|
|
|
|
// Video (with or without sync) mode: grant/staged handshake.
|
|
for {
|
|
select {
|
|
case <-grant:
|
|
case <-ctx.Done():
|
|
return
|
|
}
|
|
|
|
var payload []byte
|
|
var grainIdx uint64
|
|
|
|
if syncSrc != nil {
|
|
vFrame, aFrame, err := syncSrc.NextSync(ctx, audioBatch, 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
|
|
}
|
|
payload = vFrame.Payload
|
|
grainIdx = vFrame.Index
|
|
if aFrame.Samples != nil && audioStream != 0 {
|
|
sdl.PutAudioStreamData(audioStream, interleaveAudio(aFrame.Samples))
|
|
}
|
|
|
|
} else if videoSrc != nil {
|
|
f, err := videoSrc.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
|
|
}
|
|
payload = f.Payload
|
|
grainIdx = f.Index
|
|
|
|
}
|
|
|
|
if r != nil {
|
|
vk.CopyToMapped(r.StagingMapped(), payload)
|
|
}
|
|
select {
|
|
case staged <- grainIdx:
|
|
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 && r != nil {
|
|
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
|
|
}
|
|
|
|
if r != nil {
|
|
var w, h, stride uint32
|
|
if syncSrc != nil {
|
|
w, h, stride = syncSrc.Width(), syncSrc.Height(), syncSrc.Stride()
|
|
} else if videoSrc != nil {
|
|
w, h, stride = videoSrc.Width(), videoSrc.Height(), videoSrc.Stride()
|
|
}
|
|
err := r.DrawFrame(w, h, 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
|
|
}
|
|
} else {
|
|
time.Sleep(10 * time.Millisecond)
|
|
}
|
|
}
|
|
}
|