livestream/server/play.go

package main

import (
	"fmt"
	"log"
	"os/exec"
	"path"
	"strings"

	ffmpeg "github.com/u2takey/ffmpeg-go"
)

const OUTFILE = "stream.m3u8"

type ffmpegProcess struct {
	cancel func() error
	cmd    *exec.Cmd
}

func (f *ffmpegProcess) Stop() {
	c := f.cancel
	if c != nil {
		c()
	}
}

func playffmpeg(loop bool, input string, output string, WhenVideoEnds func(forcequit bool)) (f ffmpegProcess) {
	subtitle_stream_index, err := SelectPreferredSubtitle(input)
	if err != nil {
		log.Println(err)
	}

	inputArgs := ffmpeg.KwArgs{
		"re": "",
	}

	outputArgs := ffmpeg.KwArgs{
		"c:v":       "libx264",
		"c:a":       "aac",
		"b:a":       "128k",
		"ac":        "2",
		"pix_fmt":   "yuv420p",
		"preset":    "ultrafast",
		"hls_flags": "delete_segments+append_list+omit_endlist",
		"hls_time":  "1",
		"f":         "hls",
	}

	if subtitle_stream_index != nil {
		// Makes file with subtitles not spit them into .vtt file
		inputArgs["sn"] = ""
	}

	if loop {
		inputArgs["stream_loop"] = "-1"
	}

	if subtitle_stream_index != nil {
		// Burns subtitles into video
		outputArgs["vf"] = fmt.Sprintf("subtitles=%s:si=%d", input, *subtitle_stream_index)
	}

	ffmpegCmd := ffmpeg.Input(input, inputArgs).Output(output, outputArgs).Compile()
	f.cancel = ffmpegCmd.Cancel

	go func() {
		out, err := ffmpegCmd.CombinedOutput()

		var was_force_quit bool
		if err != nil && strings.Contains(err.Error(), "signal: killed") {
			was_force_quit = true
		} else if err != nil {
			log.Println(err.Error()+":", string(out))
		}

		log.Println("Playback ended")
		if WhenVideoEnds != nil {
			WhenVideoEnds(was_force_quit)
		}
	}()

	return
}

func (s *State) playFile(fileName string) (err error) {
	s.stopPlaying()
	log.Println("Playing", fileName)
	s.VideoProcess = playffmpeg(false, fileName, path.Join(s.StreamCacheDir, OUTFILE), func(forcequit bool) {
		if err := s.playFallback(); err != nil {
			log.Fatal(err)
		}
	})
	s.PlayState = PlayingVideo
	s.SetNowPlaying(path.Base(fileName))
	return
}

func (s *State) playFallback() (err error) {
	s.stopPlaying()
	log.Println("Playing fallback")
	s.VideoProcess = playffmpeg(true, s.FallbackFile, path.Join(s.StreamCacheDir, OUTFILE), nil)
	s.PlayState = PlayingFallback
	s.SetNowPlaying("")
	return
}

func (s *State) PlayRandom(autoplay bool) {
	s.stopPlaying()

	fileName, err := s.getRandomMediaFile()
	if err != nil {
		log.Println(err)
		return
	}

	log.Println("Playing random file", fileName)
	s.VideoProcess = playffmpeg(false, fileName, path.Join(s.StreamCacheDir, OUTFILE), func(forcequit bool) {
		if forcequit {
			return
		}

		if autoplay {
			s.PlayRandom(autoplay)
		} else {
			s.playFallback()
		}
	})
	s.PlayState = PlayingVideo

	s.SetNowPlaying(path.Base(fileName))
	return
}

func (s *State) stopPlaying() {
	s.VideoProcess.Stop()
	s.PlayState = NotPlaying

	switch s.PlayState {
	case PlayingVideo:
		log.Println("Stopping currently playing video")
	case PlayingFallback:
		log.Println("Stopping currently playing fallback video")
	}
}

func (s *State) SetNowPlaying(p string) {
	s.CurrentFile = p

	s.Websocket.Broadcast(WebsocketMessage{
		Type:    WebsocketMessageTypeCurrentlyPlaying,
		Message: s.NowPlaying(),
	}.Encode())
}