Revamped subtitle conversion

New version supports native segmenting from a webvtt file/piped output.

Each subtitle is independently encoded into webvtt through ffmpeg, and as ffmpeg outputs the resulting webvtt, a goroutine running for each encoding segments the outputs.

Signed-off-by: Alexandre Jouandin <[email protected]>

Author: allezxandre

converter/command_generator.go

@@ -65,37 +65,13 @@ func audioConversionArgs(variants []suggest.AudioVariant) (args []string) {
 	return
 }
 
-func subtitlesConversionArgs(variants []suggest.SubtitleVariant) (args []string) {
-	for outputIndex, variant := range variants {
-		indexS := strconv.Itoa(outputIndex)
-		// Map & codec
-		args = append(args,
-			"-map", variant.MapInput,
-			"-c:s:"+indexS, "webvtt")
-	}
-
-	return
-}
-
-func variantsMapArg(videoVariants []suggest.VideoVariant, audioVariants []suggest.AudioVariant, subtitleVariants []suggest.SubtitleVariant) string {
+func variantsMapArg(videoVariants []suggest.VideoVariant, audioVariants []suggest.AudioVariant) string {
 	mapArray := make([]string, 0, len(videoVariants)+len(audioVariants))
-	subIdx := 0
-	subIdxMax := len(subtitleVariants)
 	for variantIndex := range videoVariants {
-		subVariantString := ""
-		if subIdx < subIdxMax {
-			subVariantString = ",s:" + strconv.Itoa(subIdx)
-			subIdx += 1
-		}
-		mapArray = append(mapArray, "v:"+strconv.Itoa(variantIndex)+subVariantString)
+		mapArray = append(mapArray, "v:"+strconv.Itoa(variantIndex))
 	}
 	for variantIndex := range audioVariants {
-		subVariantString := ""
-		if subIdx < subIdxMax {
-			subVariantString = ",s:" + strconv.Itoa(subIdx)
-			subIdx += 1
-		}
-		mapArray = append(mapArray, "a:"+strconv.Itoa(variantIndex)+subVariantString)
+		mapArray = append(mapArray, "a:"+strconv.Itoa(variantIndex))
 	}
 	return strings.Join(mapArray, " ")
 }

converter/convert.go

@@ -13,12 +13,42 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
+	"syscall"
 )
 
 type Conversion struct {
-	StreamURLs      []string
-	Command         *exec.Cmd
-	OutputDirectory string
+	StreamURLs                 []string
+	mainCommand                *exec.Cmd
+	SubtitleConversionCommands []SubtitleVariantConversion
+	OutputDirectory            string
+}
+
+// Applies function f to all commands related to the conversion
+func (c Conversion) do(f func(cmd *exec.Cmd)) {
+	f(c.mainCommand)
+	for _, subConv := range c.SubtitleConversionCommands {
+		f(subConv.commands.EncoderCommand)
+	}
+}
+
+func (c Conversion) Signal(sig syscall.Signal) {
+	c.do(func(cmd *exec.Cmd) {
+		cmd.Process.Signal(sig)
+	})
+}
+
+func (c Conversion) SigInt() {
+	c.Signal(syscall.SIGINT)
+}
+
+// Exit Kills all remaining ongoing conversion
+func (c Conversion) Exit() {
+	c.do(func(cmd *exec.Cmd) {
+		if cmd.ProcessState == nil || !cmd.ProcessState.Exited() {
+			// Process is not done
+			cmd.Process.Kill()
+		}
+	})
 }
 
 var hlsSettings = []string{
@@ -32,6 +62,10 @@ var hlsSettings = []string{
 	"-hls_flags", "split_by_time",
 }
 
+func ffmpegDefaultArguments() []string {
+	return []string{"-hide_banner", "-y", "-stats", "-loglevel", "warning"}
+}
+
 func ConvertFile(outputDir, masterPlaylistName, streamPlaylistName string, additionalSubtitleInputs []input.SubtitleInput, inputs ...string) (*Conversion, error) {
 	// Probe data
 	probeData, err := probe.GetProbeData(inputs...)
@@ -42,35 +76,25 @@ func ConvertFile(outputDir, masterPlaylistName, streamPlaylistName string, addit
 	// Figure out variants
 	videoVariants := suggest.SuggestVideoVariants(probeData)
 	audioVariants := suggest.SuggestAudioVariants(probeData, false, true)
-	subtitleVariants := suggest.SuggestSubtitlesVariants(probeData, additionalSubtitleInputs, true)
-	maxSubs := len(videoVariants) + len(audioVariants) // FIXME
-	if maxSubs < len(subtitleVariants) {
-		subtitleVariants = subtitleVariants[:maxSubs]
-		log.Println("Warning: some subtitles won't be copied as you can't have " +
-			"subtitle-only variants and there aren't enough other video and audio variants.")
-	}
+	subtitleVariants := suggest.SuggestSubtitlesVariants(inputs, probeData, additionalSubtitleInputs, true)
 
 	// Generate FFMPEG command
-	args := []string{"-hide_banner", "-y", "-stats", "-loglevel", "warning"}
+	args := ffmpegDefaultArguments()
 	// ... add inputs
 	for _, input := range inputs {
 		args = append(args, "-i", input)
 	}
-	for _, additionalSubtitleInput := range additionalSubtitleInputs {
-		args = append(args, "-i", additionalSubtitleInput.InputURL)
-	}
+	// Additional subtitle inputs will be added later
 
-	// ... add variants
+	// ... add video and audio variants
 	args = append(args, videoConversionArgs(videoVariants)...)
 	args = append(args, audioConversionArgs(audioVariants)...)
-	args = append(args, subtitlesConversionArgs(subtitleVariants)...)
 	// ... add HLS options
 	args = append(args, hlsSettings...)
 	// ... add HLS variants mapping
-	args = append(args, "-var_stream_map", variantsMapArg(videoVariants, audioVariants, subtitleVariants))
+	args = append(args, "-var_stream_map", variantsMapArg(videoVariants, audioVariants))
 
 	// Create stream playlist
-
 	if err := os.MkdirAll(outputDir, 0700); err != nil {
 		log.Println("Cannot create conversion dir at path '"+outputDir+"':", err)
 		return nil, err // FIXME: return better error
@@ -80,7 +104,7 @@ func ConvertFile(outputDir, masterPlaylistName, streamPlaylistName string, addit
 	// HLS options
 	args = append(args, "-max_muxing_queue_size", "1024", outputFile)
 
-	// Start conversion
+	// Start video and audio conversion
 	var cmd *exec.Cmd
 	masterCh := make(chan string)
 	cmd, err = callFFmpeg(filepath.Join(outputDir, "conversion.log"), args, masterCh)
@@ -89,6 +113,9 @@ func ConvertFile(outputDir, masterPlaylistName, streamPlaylistName string, addit
 		return nil, err
 	}
 
+	// Start subtitles conversion
+	convertedSubtitles := convertSubtitles(subtitleVariants, outputDir)
+
 	// Generate master playlist
 	masterFilename := filepath.Join(outputDir, masterPlaylistName+".m3u8")
 	masterCh <- masterFilename
@@ -112,10 +139,10 @@ func ConvertFile(outputDir, masterPlaylistName, streamPlaylistName string, addit
 		}
 	}
 	// ... find subtitles groups
-	if len(subtitleVariants) > 0 {
+	if len(convertedSubtitles) > 0 {
 		subtitlesGroup = &suggest.DefaultSubtitlesGroupID
-		if subtitleVariants[0].GroupID != nil {
-			subtitlesGroup = subtitleVariants[0].GroupID
+		if convertedSubtitles[0].Variant.GroupID != nil {
+			subtitlesGroup = convertedSubtitles[0].Variant.GroupID
 		}
 	}
 	// ... write audio
@@ -127,8 +154,9 @@ func ConvertFile(outputDir, masterPlaylistName, streamPlaylistName string, addit
 	f.WriteString("\n")
 	// ... write subtitles
 	streamIndex = 0 // Subtitle playlists restart at 0
-	for _, variant := range subtitleVariants {
-		f.WriteString(variant.Stanza(playlistFilenameForSubtitlesStream(streamPlaylistName, streamIndex)) + "\n")
+	for _, c := range convertedSubtitles {
+		fmt.Printf("DEBUG: Adding subtitle %q to Master\n", c.Variant.Name)
+		f.WriteString(c.Variant.Stanza() + "\n")
 		streamIndex += 1
 	}
 	f.WriteString("\n\n")
@@ -149,9 +177,10 @@ func ConvertFile(outputDir, masterPlaylistName, streamPlaylistName string, addit
 	f.Close()
 
 	return &Conversion{
-		StreamURLs:      inputs,
-		Command:         cmd,
-		OutputDirectory: outputDir,
+		StreamURLs:                 inputs,
+		mainCommand:                cmd,
+		SubtitleConversionCommands: convertedSubtitles,
+		OutputDirectory:            outputDir,
 	}, nil
 }
 
@@ -208,7 +237,3 @@ func callFFmpeg(logFilename string, args []string, masterCh <-chan string) (*exe
 func playlistFilenameForStream(streamPlaylistName string, index int) string {
 	return streamPlaylistName + "_" + strconv.Itoa(index) + ".m3u8"
 }
-
-func playlistFilenameForSubtitlesStream(streamPlaylistName string, index int) string {
-	return streamPlaylistName + "_" + strconv.Itoa(index) + "_vtt.m3u8"
-}

suggest/stanza.go

@@ -68,7 +68,9 @@ func (v AudioVariant) Stanza(streamPlaylistFilename string) string {
 	return "#EXT-X-MEDIA:" + strings.Join(optionsList, ",")
 }
 
-func (v SubtitleVariant) Stanza(streamPlaylistFilename string) string {
+func (v SubtitleVariant) Stanza() string {
+	streamPlaylistFilename := v.PlaylistName("")
+
 	var optionsList []string // The list of options to create the entry
 	groupID := DefaultSubtitlesGroupID
 	if v.GroupID != nil {

suggest/subtitles.go

@@ -3,53 +3,64 @@ package suggest
 import (
 	"github.com/allezxandre/go-hls-encoder/input"
 	"github.com/allezxandre/go-hls-encoder/probe"
+	"path/filepath"
 	"strconv"
 )
 
 type SubtitleVariant struct {
-	MapInput string // The map value: in the form of $input:$stream
+	InputURL    string // The stream URL where the subtitle should be found
+	StreamIndex uint   // The stream index of the subtitle in the input from InputURL
 
 	// M3U8 Playlist options: https://tools.ietf.org/html/draft-pantos-http-live-streaming-23
 	Name            string  // Unique name for variant. Required.
 	GroupID         *string // Optional group ID. "subtitles" will be used if `nil`
 	HearingImpaired bool
 	Forced          bool
 	Language        input.Language // Primary language https://tools.ietf.org/html/rfc5646
+
+	// A unique output index for the subtitle file.
+	// Each subtitle variant should have its own.
+	OutputIndex uint
 }
 
 var DefaultSubtitlesGroupID = "subtitles"
 
-func SuggestSubtitlesVariants(probeDataInputs []*probe.ProbeData, additionalInputs []input.SubtitleInput, removeVFQ bool) []SubtitleVariant {
+func SuggestSubtitlesVariants(probeDataInputsURLs []string, probeDataInputs []*probe.ProbeData, additionalInputs []input.SubtitleInput, removeVFQ bool) []SubtitleVariant {
 	// Create a map of languages to their subtitles
 	languages := make(map[input.Language][]SubtitleVariant)
+	var outputIndex uint = 0
 
 	// First using the probe data...
 	for inputIndex, probeData := range probeDataInputs {
 		for streamIndex, stream := range probeData.Streams {
 			if stream.CodecType == "subtitle" && stream.CodecName != "hdmv_pgs_subtitle" {
+				outputIndex += 1
 				language := matchLanguage(stream)
 				variant := SubtitleVariant{
-					MapInput:        strconv.Itoa(inputIndex) + ":" + strconv.Itoa(streamIndex),
+					InputURL:        probeDataInputsURLs[inputIndex],
+					StreamIndex:     uint(streamIndex),
 					Language:        language,
-					Name:            "Subtitle " + strconv.Itoa(streamIndex),
+					Name:            "Subtitle" + strconv.Itoa(streamIndex),
 					HearingImpaired: matchHearingImpairedTag(stream),
 					Forced:          matchForcedTag(stream),
+					OutputIndex:     outputIndex,
 				}
 				languages[language] = append(languages[language], variant)
 			}
 		}
 	}
 
 	// Then using the additionalInputs, if any
-	nbInputs := len(probeDataInputs) // The number of streams already mapped
-	for inputIndex, subtitleInput := range additionalInputs {
-		realInputIndex := nbInputs + inputIndex
+	for _, subtitleInput := range additionalInputs {
+		outputIndex += 1
 		variant := SubtitleVariant{
-			MapInput:        strconv.Itoa(realInputIndex) + ":" + strconv.Itoa(int(subtitleInput.StreamIndex)),
+			InputURL:        subtitleInput.InputURL,
+			StreamIndex:     subtitleInput.StreamIndex,
 			Language:        subtitleInput.Language,
 			Name:            subtitleInput.Name,
 			HearingImpaired: subtitleInput.HearingImpaired,
 			Forced:          subtitleInput.Forced,
+			OutputIndex:     outputIndex,
 		}
 		languages[subtitleInput.Language] = append(languages[subtitleInput.Language], variant)
 	}
@@ -88,3 +99,13 @@ func cleanVariants(languages map[input.Language][]SubtitleVariant, removeVFQ boo
 	}
 	return variants
 }
+
+// PlaylistName Returns the name of the m3u8 playlist.
+// If `outputDir` is not "", joins the filename with the outputDir
+func (v SubtitleVariant) PlaylistName(outputDir string) string {
+	if len(outputDir) > 0 {
+		return filepath.Join(outputDir, v.PlaylistName(""))
+	} else {
+		return v.Name + ".m3u8"
+	}
+}

suggest/utils.go

@@ -11,7 +11,7 @@ func matchLanguage(stream *probe.ProbeStream) input.Language {
 	currentGuess := input.Unknown
 	// Match title
 	if len(stream.Tags.Title) > 0 {
-		matchVFF := regexp.MustCompile(`\b(vff|true(\b)*french)\b`)
+		matchVFF := regexp.MustCompile(`\b(vff|vfi|true(\b)*french)\b`)
 		matchVFQ := regexp.MustCompile(`\bvfq\b|\bqu[eé]bec[a-z]*\b`)
 		matchFrench := regexp.MustCompile(`(fre|french|fran[cç]ais)`)
 		matchEnglish := regexp.MustCompile(`(ang|angl|eng|engl|anglais|english|vo)`)

suggest/video.go

@@ -48,8 +48,8 @@ func SuggestVideoVariants(probeDataInputs []*probe.ProbeData) (variants []VideoV
 			// Found a video in this input
 			videoStream := probeData.Streams[masterVideoIndex]
 			bandwidth := 7000000 // FIXME: Handle unknown bandwidth
-			if bandwitdhInt, err := strconv.Atoi(videoStream.BitRate); err == nil {
-				bandwidth = bandwitdhInt
+			if videoStream.BitRate > 0 {
+				bandwidth = videoStream.BitRate
 			}
 			// Match codec
 			switch videoStream.CodecName {

webvtt/webvtt.go

@@ -6,6 +6,7 @@ package webvtt
 import (
 	"bytes"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"log"
 	"os"
@@ -18,7 +19,14 @@ type SubtitleBlock struct {
 	Lines              bytes.Buffer  // A buffer containing the whole block
 }
 
-func Segment(c <-chan SubtitleBlock, targetDuration time.Duration, outputDir, name string) error {
+// Segment Segments the webvtt input from `r`
+func Segment(r io.Reader, targetDuration time.Duration, outputDir, name string) error {
+	c := make(chan SubtitleBlock)
+	go ReadFromWebVTT(r, c)
+	return segment(c, targetDuration, outputDir, name)
+}
+
+func segment(c <-chan SubtitleBlock, targetDuration time.Duration, outputDir, name string) error {
 	playlistPath := filepath.Join(outputDir, name+".m3u8")
 	playlist, err := createPlaylistFile(playlistPath, targetDuration)
 	if err != nil {

webvtt/webvtt_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 func TestRead(t *testing.T) {
-	c := make(chan SubtitleBlock)
+	// This test comes from https://trac.ffmpeg.org/ticket/4048
 	f, err := os.Open("tests/test1.vtt")
 	if err != nil {
 		t.Error("Cannot read test vtt file:", err)
@@ -21,7 +21,8 @@ func TestRead(t *testing.T) {
 	}
 	fmt.Printf("Output directory: %q\n", outputDir)
 
+	c := make(chan SubtitleBlock)
 	go ReadFromWebVTT(f, c)
-	Segment(c, 5*time.Second, outputDir, "test1")
+	segment(c, 5*time.Second, outputDir, "test1")
 	// TODO: Test output
 }