use property changed event to update playback position/duration/volum…

…e, huge cpu savings because we don't update our UI with 10fps anymore

event_loop.go

@@ -36,9 +36,18 @@ func (ui *Ui) runEventLoops() {
 // handle ui updates
 func (ui *Ui) guiEventLoop() {
 	ui.addStarredToList()
+	events := 0.0
+	fpsTimer := time.NewTimer(0)
 
 	for {
+		events++
+
 		select {
+		case <-fpsTimer.C:
+			fpsTimer.Reset(10 * time.Second)
+			ui.logger.Printf("guiEventLoop: %f events per second", events/10.0)
+			events = 0
+
 		case msg := <-ui.logger.Prints:
 			// handle log page output
 			ui.app.QueueUpdateDraw(func() {
@@ -52,6 +61,8 @@ func (ui *Ui) guiEventLoop() {
 			})
 
 		case mpvEvent := <-ui.mpvEvents:
+			events++
+
 			// handle events from mpv wrapper
 			switch mpvEvent.Type {
 			case mpvplayer.EventStatus:

gui_helpers.go

@@ -17,13 +17,13 @@ func makeModal(p tview.Primitive, width, height int) tview.Primitive {
 		AddItem(p, 1, 1, 1, 1, 0, 0, true)
 }
 
-func formatPlayerStatus(volume int64, position float64, duration float64) string {
+func formatPlayerStatus(volume int64, position int64, duration int64) string {
 	if position < 0 {
-		position = 0.0
+		position = 0
 	}
 
 	if duration < 0 {
-		duration = 0.0
+		duration = 0
 	}
 
 	positionMin, positionSec := secondsToMinAndSec(position)

helpers.go

@@ -13,8 +13,8 @@ func stringOr(firstChoice string, secondChoice string) string {
 	return secondChoice
 }
 
-func secondsToMinAndSec(seconds float64) (int, int) {
-	minutes := math.Floor(seconds / 60)
+func secondsToMinAndSec(seconds int64) (int, int) {
+	minutes := math.Floor(float64(seconds) / 60)
 	remainingSeconds := int(seconds) % 60
 	return int(minutes), remainingSeconds
 }

mpvplayer/handler.go

@@ -8,10 +8,10 @@ import (
 )
 
 func (p *Player) EventLoop() {
-	if err := p.instance.ObserveProperty(0, "time-pos", mpv.FORMAT_DOUBLE); err != nil {
+	if err := p.instance.ObserveProperty(0, "playback-time", mpv.FORMAT_INT64); err != nil {
 		p.logger.PrintError("Observe1", err)
 	}
-	if err := p.instance.ObserveProperty(0, "duration", mpv.FORMAT_DOUBLE); err != nil {
+	if err := p.instance.ObserveProperty(0, "duration", mpv.FORMAT_INT64); err != nil {
 		p.logger.PrintError("Observe2", err)
 	}
 	if err := p.instance.ObserveProperty(0, "volume", mpv.FORMAT_INT64); err != nil {
@@ -22,6 +22,38 @@ func (p *Player) EventLoop() {
 		if evt == nil {
 			// quit signal
 			break
+		} else if evt.Event_Id == mpv.EVENT_PROPERTY_CHANGE {
+			// one of our observed properties changed. which one is probably extractable from evt.Data.. somehow.
+
+			position, err := p.instance.GetProperty("time-pos", mpv.FORMAT_INT64)
+			if err != nil {
+				p.logger.Printf("mpv.EventLoop (%s): GetProperty %s -- %s", evt.Event_Id.String(), "time-pos", err.Error())
+			}
+			duration, err := p.instance.GetProperty("duration", mpv.FORMAT_INT64)
+			if err != nil {
+				p.logger.Printf("mpv.EventLoop (%s): GetProperty %s -- %s", evt.Event_Id.String(), "duration", err.Error())
+			}
+			volume, err := p.instance.GetProperty("volume", mpv.FORMAT_INT64)
+			if err != nil {
+				p.logger.Printf("mpv.EventLoop (%s): GetProperty %s -- %s", evt.Event_Id.String(), "volume", err.Error())
+			}
+
+			if position == nil {
+				position = int64(0)
+			}
+			if duration == nil {
+				duration = int64(0)
+			}
+			if volume == nil {
+				volume = int64(0)
+			}
+
+			statusData := StatusData{
+				Volume:   volume.(int64),
+				Position: position.(int64),
+				Duration: duration.(int64),
+			}
+			p.sendGuiDataEvent(EventStatus, statusData)
 		} else if evt.Event_Id == mpv.EVENT_END_FILE && !p.replaceInProgress {
 			// we don't want to update anything if we're in the process of replacing the current track
 
@@ -66,38 +98,10 @@ func (p *Player) EventLoop() {
 			}
 		} else if evt.Event_Id == mpv.EVENT_IDLE || evt.Event_Id == mpv.EVENT_NONE {
 			continue
+		} else {
+			p.logger.Printf("mpv.EventLoop: unhandled event id %v", evt.Event_Id)
+			continue
 		}
-
-		position, err := p.instance.GetProperty("time-pos", mpv.FORMAT_DOUBLE)
-		if err != nil {
-			p.logger.Printf("mpv.EventLoop (%s): GetProperty %s -- %s", evt.Event_Id.String(), "time-pos", err.Error())
-		}
-		// TODO only update these as needed
-		duration, err := p.instance.GetProperty("duration", mpv.FORMAT_DOUBLE)
-		if err != nil {
-			p.logger.Printf("mpv.EventLoop (%s): GetProperty %s -- %s", evt.Event_Id.String(), "duration", err.Error())
-		}
-		volume, err := p.instance.GetProperty("volume", mpv.FORMAT_INT64)
-		if err != nil {
-			p.logger.Printf("mpv.EventLoop (%s): GetProperty %s -- %s", evt.Event_Id.String(), "volume", err.Error())
-		}
-
-		if position == nil {
-			position = 0.0
-		}
-		if duration == nil {
-			duration = 0.0
-		}
-		if volume == nil {
-			volume = 0
-		}
-
-		statusData := StatusData{
-			Volume:   volume.(int64),
-			Position: position.(float64),
-			Duration: duration.(float64),
-		}
-		p.sendGuiDataEvent(EventStatus, statusData)
 	}
 }
 

mpvplayer/player.go

@@ -25,25 +25,31 @@ type Player struct {
 }
 
 func NewPlayer(logger logger.LoggerInterface) (player *Player, err error) {
-	mpvInstance := mpv.Create()
+	m := mpv.Create()
 
-	// TODO figure out what other mpv options we need
-	if err = mpvInstance.SetOptionString("audio-display", "no"); err != nil {
-		mpvInstance.TerminateDestroy()
+	// cargo-cult what supersonic does
+	if err = m.SetOptionString("audio-display", "no"); err != nil {
 		return
 	}
-	if err = mpvInstance.SetOptionString("video", "no"); err != nil {
-		mpvInstance.TerminateDestroy()
+	if err = m.SetOptionString("video", "no"); err != nil {
+		return
+	}
+	if err = m.SetOptionString("terminal", "no"); err != nil {
+		return
+	}
+	if err = m.SetOptionString("demuxer-max-bytes", "30MiB"); err != nil {
+		return
+	}
+	if err = m.SetOptionString("audio-client-name", "stmp"); err != nil {
 		return
 	}
 
-	if err = mpvInstance.Initialize(); err != nil {
-		mpvInstance.TerminateDestroy()
+	if err = m.Initialize(); err != nil {
 		return
 	}
 
 	player = &Player{
-		instance:          mpvInstance,
+		instance:          m,
 		mpvEvents:         make(chan *mpv.Event),
 		eventConsumer:     nil, // must be set by calling RegisterEventConsumer()
 		queue:             make([]QueueItem, 0),
@@ -52,7 +58,7 @@ func NewPlayer(logger logger.LoggerInterface) (player *Player, err error) {
 		stopped:           true,
 	}
 
-	go player.mpvEngineEventHandler(mpvInstance)
+	go player.mpvEngineEventHandler(m)
 	return
 }
 

mpvplayer/typed_shared.go

@@ -14,6 +14,6 @@ type QueueItem struct {
 // StatusData is a player progress report for the UI
 type StatusData struct {
 	Volume   int64
-	Position float64
-	Duration float64
+	Position int64
+	Duration int64
 }