live-streamer/streamer/streamer.go
2024-10-24 05:06:19 +08:00

283 lines
5.9 KiB
Go

package streamer
import (
"bufio"
"context"
"errors"
"fmt"
"io"
"live-streamer/config"
"log"
"math"
"os/exec"
"strings"
"sync"
"time"
)
type Streamer struct {
videoList []config.InputItem
currentVideoIndex int
cmd *exec.Cmd
ctx context.Context
cancel context.CancelFunc
output strings.Builder
manualControl bool
mu sync.Mutex
}
var GlobalStreamer *Streamer
func NewStreamer(videoList []config.InputItem) *Streamer {
GlobalStreamer = &Streamer{
videoList: videoList,
currentVideoIndex: 0,
cmd: nil,
ctx: nil,
}
return GlobalStreamer
}
func (s *Streamer) start() {
s.mu.Lock()
s.ctx, s.cancel = context.WithCancel(context.Background())
currentVideo := s.videoList[s.currentVideoIndex]
videoPath := currentVideo.Path
s.cmd = exec.CommandContext(s.ctx, "ffmpeg", s.buildFFmpegArgs(currentVideo)...)
s.mu.Unlock()
s.writeOutput(fmt.Sprintln("start stream: ", videoPath))
pipe, err := s.cmd.StderrPipe()
if err != nil {
log.Printf("failed to get pipe: %v", err)
return
}
reader := bufio.NewReader(pipe)
if err := s.cmd.Start(); err != nil {
s.writeOutput(fmt.Sprintf("starting ffmpeg error: %v\n", err))
return
}
go s.log(reader)
<-s.ctx.Done()
s.writeOutput(fmt.Sprintf("stop stream: %s\n", videoPath))
if s.manualControl {
s.manualControl = false
} else {
// stream next video
s.currentVideoIndex++
if s.currentVideoIndex >= len(s.videoList) {
s.currentVideoIndex = 0
}
}
}
func (s *Streamer) Stream() {
for {
if len(s.videoList) == 0 {
time.Sleep(time.Second)
continue
}
s.start()
}
}
func (s *Streamer) Stop() {
s.mu.Lock()
defer s.mu.Unlock()
if s.cancel != nil {
stopped := make(chan error)
go func() {
if s.cmd != nil {
stopped <- s.cmd.Wait()
}
}()
s.cancel()
if s.cmd != nil && s.cmd.Process != nil {
select {
case <-stopped:
break
case <-time.After(3 * time.Second):
_ = s.cmd.Process.Kill()
break
}
s.cmd = nil
}
}
}
func (s *Streamer) writeOutput(str string) {
s.mu.Lock()
defer s.mu.Unlock()
s.output.WriteString(str)
}
func (s *Streamer) Add(videoPath string) {
s.mu.Lock()
defer s.mu.Unlock()
s.videoList = append(s.videoList, config.InputItem{Path: videoPath})
}
func (s *Streamer) Remove(videoPath string) {
s.mu.Lock()
defer s.mu.Unlock()
for i, item := range s.videoList {
if item.Path == videoPath {
s.videoList = append(s.videoList[:i], s.videoList[i+1:]...)
if s.currentVideoIndex >= len(s.videoList) {
s.currentVideoIndex = 0
}
if s.currentVideoIndex == i {
s.Stop()
}
break
}
}
}
func (s *Streamer) Prev() {
s.mu.Lock()
s.manualControl = true
s.currentVideoIndex--
if s.currentVideoIndex < 0 {
s.currentVideoIndex = len(s.videoList) - 1
}
s.mu.Unlock()
s.Stop()
}
func (s *Streamer) Next() {
s.mu.Lock()
s.manualControl = true
s.currentVideoIndex++
if s.currentVideoIndex >= len(s.videoList) {
s.currentVideoIndex = 0
}
s.mu.Unlock()
s.Stop()
}
func (s *Streamer) log(reader *bufio.Reader) {
select {
case <-s.ctx.Done():
return
default:
if !config.GlobalConfig.Log.PlayState {
return
}
buf := make([]byte, 1024)
for {
n, err := reader.Read(buf)
if n > 0 {
videoPath, _ := s.GetCurrentVideoPath()
buf = append([]byte(videoPath), buf...)
s.writeOutput(string(buf[:n+len(videoPath)]))
}
if err != nil {
if err != io.EOF {
s.writeOutput(fmt.Sprintf("reading ffmpeg output error: %v\n", err))
}
break
}
}
}
}
func (s *Streamer) GetCurrentVideoPath() (string, error) {
s.mu.Lock()
defer s.mu.Unlock()
if len(s.videoList) == 0 {
return "", errors.New("no video streaming")
}
return s.videoList[s.currentVideoIndex].Path, nil
}
func (s *Streamer) GetVideoList() []config.InputItem {
s.mu.Lock()
defer s.mu.Unlock()
return s.videoList
}
func (s *Streamer) GetVideoListPath() []string {
s.mu.Lock()
defer s.mu.Unlock()
var videoList []string
for _, item := range s.videoList {
videoList = append(videoList, item.Path)
}
return videoList
}
func (s *Streamer) GetCurrentIndex() int {
s.mu.Lock()
defer s.mu.Unlock()
return s.currentVideoIndex
}
func (s *Streamer) GetOutput() string {
s.mu.Lock()
defer s.mu.Unlock()
return s.output.String()
}
func (s *Streamer) TruncateOutput() int {
s.mu.Lock()
defer s.mu.Unlock()
currentSize := s.output.Len()
if currentSize > math.MaxInt {
newStart := currentSize - math.MaxInt
trimmedOutput := s.output.String()[newStart:]
s.output.Reset()
s.output.WriteString(trimmedOutput)
}
return currentSize
}
func (s *Streamer) Close() {
s.Stop()
}
func (s *Streamer) buildFFmpegArgs(videoItem config.InputItem) []string {
videoPath := videoItem.Path
args := []string{"-re"}
if videoItem.Start != "" {
args = append(args, "-ss", videoItem.Start)
}
args = append(args, "-i", videoPath)
if videoItem.End != "" {
args = append(args, "-to", videoItem.End)
}
args = append(args,
"-c:v", config.GlobalConfig.Play.VideoCodec,
"-preset", config.GlobalConfig.Play.Preset,
"-crf", fmt.Sprintf("%d", config.GlobalConfig.Play.CRF),
"-maxrate", config.GlobalConfig.Play.MaxRate,
"-bufsize", config.GlobalConfig.Play.BufSize,
"-vf", fmt.Sprintf("scale=%s", config.GlobalConfig.Play.Scale),
"-r", fmt.Sprintf("%d", config.GlobalConfig.Play.FrameRate),
"-c:a", config.GlobalConfig.Play.AudioCodec,
"-b:a", config.GlobalConfig.Play.AudioBitrate,
"-ar", fmt.Sprintf("%d", config.GlobalConfig.Play.AudioSampleRate),
"-f", config.GlobalConfig.Play.OutputFormat,
"-stats", "-loglevel", "info",
)
if config.GlobalConfig.Play.CustomArgs != "" {
customArgs := strings.Fields(config.GlobalConfig.Play.CustomArgs)
args = append(args, customArgs...)
}
args = append(args, fmt.Sprintf("%s/%s", config.GlobalConfig.Output.RTMPServer, config.GlobalConfig.Output.StreamKey))
// logger.GlobalLogger.Println("ffmpeg args: ", args)
return args
}