231 lines
4.6 KiB
Go
231 lines
4.6 KiB
Go
package player
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"math"
|
|
"math/rand"
|
|
"os"
|
|
"os/exec"
|
|
"os/signal"
|
|
"strings"
|
|
"syscall"
|
|
"time"
|
|
|
|
"git.nemunai.re/nemunaire/reveil/config"
|
|
"git.nemunai.re/nemunaire/reveil/model"
|
|
)
|
|
|
|
var CommonPlayer *Player
|
|
|
|
type Player struct {
|
|
Playlist []string
|
|
MaxRunTime time.Duration
|
|
Stopper chan bool
|
|
currentCmd *exec.Cmd
|
|
currentCmdCh chan bool
|
|
|
|
claironTime time.Duration
|
|
claironFile string
|
|
|
|
ntick int64
|
|
hasClaironed bool
|
|
launched time.Time
|
|
volume uint16
|
|
dontUpdateVolume bool
|
|
reverseOrder bool
|
|
playedItem int
|
|
}
|
|
|
|
func WakeUp(cfg *config.Config) (err error) {
|
|
if CommonPlayer != nil {
|
|
return fmt.Errorf("Unable to start the player: a player is already running")
|
|
}
|
|
|
|
CommonPlayer, err = NewPlayer(cfg)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
go CommonPlayer.WakeUp()
|
|
return nil
|
|
}
|
|
|
|
func NewPlayer(cfg *config.Config) (*Player, error) {
|
|
// Load our settings
|
|
settings, err := reveil.ReadSettings(cfg.SettingsFile)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("Unable to read settings: %w", err)
|
|
}
|
|
|
|
p := Player{
|
|
Stopper: make(chan bool, 1),
|
|
currentCmdCh: make(chan bool, 1),
|
|
MaxRunTime: settings.MaxRunTime * time.Minute,
|
|
claironTime: settings.GongInterval * time.Minute,
|
|
claironFile: reveil.CurrentGongPath(cfg),
|
|
}
|
|
|
|
// Load our track list
|
|
tracks, err := reveil.LoadTracks(cfg)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("Unable to load tracks: %w", err)
|
|
}
|
|
|
|
var playlist []string
|
|
|
|
// Creating playlist
|
|
log.Println("Loading playlist...")
|
|
for _, track := range tracks {
|
|
if !track.Enabled {
|
|
continue
|
|
}
|
|
|
|
p.Playlist = append(p.Playlist, track.Path)
|
|
}
|
|
|
|
log.Println("Shuffling playlist...")
|
|
// Shuffle the playlist
|
|
rand.Shuffle(len(playlist), func(i, j int) {
|
|
playlist[i], playlist[j] = playlist[j], playlist[i]
|
|
})
|
|
|
|
return &p, nil
|
|
}
|
|
|
|
func (p *Player) playFile(filepath string) (err error) {
|
|
p.currentCmd = exec.Command("paplay", filepath)
|
|
if err = p.currentCmd.Start(); err != nil {
|
|
log.Println("Running paplay err: ", err.Error())
|
|
p.currentCmdCh <- true
|
|
return
|
|
}
|
|
|
|
log.Println("Running paplay ", filepath)
|
|
|
|
err = p.currentCmd.Wait()
|
|
p.currentCmdCh <- true
|
|
|
|
return
|
|
}
|
|
|
|
func (p *Player) WakeUp() {
|
|
log.Println("Playlist in use:", strings.Join(p.Playlist, " ; "))
|
|
|
|
// Prepare sound player
|
|
p.volume = 3500
|
|
|
|
ticker := time.NewTicker(time.Second)
|
|
defer ticker.Stop()
|
|
|
|
p.launched = time.Now()
|
|
|
|
// Prepare graceful shutdown
|
|
maxRun := time.After(p.MaxRunTime)
|
|
interrupt := make(chan os.Signal, 1)
|
|
signal.Notify(interrupt, os.Interrupt, syscall.SIGHUP)
|
|
|
|
p.currentCmdCh <- true
|
|
loop:
|
|
for {
|
|
select {
|
|
case <-p.currentCmdCh:
|
|
if !p.hasClaironed && time.Since(p.launched) >= p.claironTime {
|
|
log.Println("clairon time!")
|
|
p.claironTime += p.claironTime / 2
|
|
p.SetVolume(65535)
|
|
p.dontUpdateVolume = true
|
|
go p.playFile(p.claironFile)
|
|
} else {
|
|
p.dontUpdateVolume = false
|
|
p.volume = 3500 + uint16(math.Log(1+float64(p.ntick)/8)*9500)
|
|
p.SetVolume(p.volume)
|
|
|
|
if p.reverseOrder {
|
|
p.playedItem -= 1
|
|
} else {
|
|
p.playedItem += 1
|
|
}
|
|
|
|
if p.playedItem >= len(p.Playlist) {
|
|
p.playedItem = 0
|
|
} else if p.playedItem < 0 {
|
|
p.playedItem = len(p.Playlist) - 1
|
|
}
|
|
|
|
log.Println("Next track: ", p.Playlist[p.playedItem])
|
|
go p.playFile(p.Playlist[p.playedItem])
|
|
}
|
|
|
|
case <-ticker.C:
|
|
p.ntick += 1
|
|
if !p.dontUpdateVolume {
|
|
p.volume = 3500 + uint16(math.Log(1+float64(p.ntick)/8)*9500)
|
|
p.SetVolume(p.volume)
|
|
}
|
|
|
|
case <-p.Stopper:
|
|
log.Println("Stopper activated")
|
|
break loop
|
|
|
|
case <-maxRun:
|
|
log.Println("Max run time exhausted")
|
|
break loop
|
|
|
|
case <-interrupt:
|
|
break loop
|
|
}
|
|
}
|
|
|
|
log.Println("Stopping the player...")
|
|
|
|
// Calm down music
|
|
loopcalm:
|
|
for i := 0; i < 128 && p.volume >= 15000; i += 1 {
|
|
timer := time.NewTimer(40 * time.Millisecond)
|
|
|
|
p.volume -= 256
|
|
p.SetVolume(p.volume)
|
|
|
|
select {
|
|
case <-p.Stopper:
|
|
log.Println("Hard stop received...")
|
|
timer.Stop()
|
|
p.volume = 0
|
|
break loopcalm
|
|
case <-timer.C:
|
|
break
|
|
}
|
|
}
|
|
|
|
if p.currentCmd != nil && p.currentCmd.Process != nil {
|
|
p.currentCmd.Process.Kill()
|
|
}
|
|
|
|
p.SetVolume(65535)
|
|
|
|
if p == CommonPlayer {
|
|
log.Println("Destoying common player")
|
|
|
|
CommonPlayer = nil
|
|
}
|
|
}
|
|
|
|
func (p *Player) NextTrack() {
|
|
if p.currentCmd != nil && p.currentCmd.Process != nil {
|
|
p.currentCmd.Process.Kill()
|
|
}
|
|
}
|
|
|
|
func (p *Player) SetVolume(volume uint16) error {
|
|
cmd := exec.Command("amixer", "-D", "pulse", "set", "Master", fmt.Sprintf("%d", volume))
|
|
return cmd.Run()
|
|
}
|
|
|
|
func (p *Player) Stop() error {
|
|
log.Println("Trying to stop the player")
|
|
p.Stopper <- true
|
|
|
|
return nil
|
|
}
|