Multi channel

go.mod

@@ -1,3 +1,5 @@
 module github.com/edgeware/v2l-example-scheduler
 
 go 1.17
+
+require github.com/edgeware/sbgo v0.0.0-20220517144721-cf8cceab4ebd

main.go

@@ -4,25 +4,44 @@ import (
 	"log"
 	"os"
 	"os/signal"
+	"strconv"
 	"time"
 
 	"github.com/edgeware/v2l-example-scheduler/v2l"
 )
 
 const (
-	assetDir             = "assets"
-	server               = "http://localhost:8090"
-	channelName          = "ch1"
-	gopDurMS             = 2000                    // Note, all content must have this same GoP duration
-	nrGopsPerSegment     = 2                       // Decides how long output segments will be in average
-	slidingWindowNrGops  = 40                      // Should be at least a minute before removing stuff
-	futureScheduleNrGops = 15                      // Threshold for when to add new entries in schedule
-	contentTemplatePath  = "content_template.json" // Template describing input and output
-	updatePeriodS        = 2                       // How often the schedule should be checked for updates in seconds
+	assetDir                   = "assets"
+	server                     = "http://localhost:8090"
+	channelName                = "ch1"
+	gopDurMS                   = 2000                    // Note, all content must have this same GoP duration
+	nrGopsPerSegment           = 2                       // Decides how long output segments will be in average
+	slidingWindowNrGopsDefault = 40                      // Should be at least a minute before removing stuff
+	futureScheduleNrGops       = 15                      // Threshold for when to add new entries in schedule
+	contentTemplatePath        = "content_template.json" // Template describing input and output
+	updatePeriodS              = 2                       // How often the schedule should be checked for updates in seconds
 )
 
 func main() {
-	err := v2l.DeleteChannel(server, channelName) // Delete any old channel and schedule
+	nrChannels := 1
+	var slidingWindowNrGops int64 = slidingWindowNrGopsDefault
+	var err error
+	if len(os.Args) > 1 {
+		nrChannels, err = strconv.Atoi(os.Args[1])
+		if err != nil {
+			printUsage()
+		}
+	}
+
+	if len(os.Args) > 2 {
+		slidingWindowS, err := strconv.Atoi(os.Args[2])
+		if err != nil {
+			printUsage()
+		}
+		slidingWindowNrGops = int64(slidingWindowS) * 1000 / gopDurMS
+	}
+
+	err = v2l.DeleteChannels(nrChannels, server) // Delete any old channel and schedule
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -43,26 +62,37 @@ func main() {
 	}
 
 	// Create channel with a few assets and get state back
-	channel, err := v2l.CreateChannel(server, channelName, contentTemplatePath, gopDurMS, nrGopsPerSegment,
+	channels, err := v2l.CreateChannels(nrChannels, server, contentTemplatePath, gopDurMS, nrGopsPerSegment,
 		slidingWindowNrGops, futureScheduleNrGops, assetPaths)
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	signalCh := make(chan os.Signal, 1)
 	signal.Notify(signalCh, os.Interrupt)
-	ticker := time.NewTicker(updatePeriodS * time.Second)
+
+	ticker := time.NewTicker(updatePeriodS * time.Second / time.Duration(nrChannels))
+	chIndex := 0
 TickerLoop:
 	for {
 		select {
 		case <-signalCh:
 			log.Printf("Stopping loop\n")
 			break TickerLoop
 		case t := <-ticker.C:
-			err = v2l.UpdateSchedule(server, channel, assetPaths, t)
+			err = channels[chIndex].UpdateSchedule(server, assetPaths, t)
 			if err != nil {
 				log.Fatal(err)
 			}
 		}
+		chIndex++
+		if chIndex == nrChannels {
+			chIndex = 0
+		}
 	}
 }
+
+func printUsage() {
+	println("Usage: ", os.Args[0], "[<number-of-channels>] [<sliding-window-S>] defaults:1 channel, 80 sec ")
+	os.Exit(1)
+}

v2l/assetpaths.go

@@ -3,10 +3,14 @@ package v2l
 import (
 	"bytes"
 	"encoding/json"
+	"fmt"
 	"io/fs"
 	"math/rand"
+	"os"
 	"path/filepath"
 	"strings"
+
+	"github.com/edgeware/sbgo/pkg/esf"
 )
 
 // DeleteAllAssetPaths - delete all asset paths from server
@@ -54,56 +58,63 @@ func DiscoverAssetPaths(dir string) ([]AssetPath, error) {
 			}
 			assetPath := filepath.Dir(absAssetPath) // The dir containing content_info.json
 			assetName := filepath.Base(assetPath)
-			aps = append(aps, AssetPath{assetName, assetPath})
+			assetLen, err := getAssetLen(absAssetPath)
+			if err != nil {
+				return err
+			}
+			aps = append(aps, AssetPath{assetName, assetPath, assetLen})
 		}
 		return nil
 	})
 	return aps, err
 }
 
 // randomEntry - return a random entry given kind and assetPaths. Set offset, length, sctedID
-func randomEntry(assetPaths []AssetPath, kind string, offset, length, scteID int64) Entry {
-	var programs []string
-	var ads []string
-	var fillers []string
-	var slates []string
+func randomEntry(assetPaths []AssetPath, kind string, scteID int64) Entry {
+	var selectedAssets []AssetPath
+	var subPath = "/" + kind + "s/"
 	for _, ap := range assetPaths {
-		if strings.Contains(ap.Path, "/filler") {
-			fillers = append(fillers, ap.ID)
-			continue
-		}
-		if strings.Contains(ap.Path, "/slates/") {
-			fillers = append(fillers, ap.ID)
-			continue
-		}
-		if strings.Contains(ap.Path, "/ads/") {
-			ads = append(ads, ap.ID)
-			continue
+		if strings.Contains(ap.Path, subPath) {
+			selectedAssets = append(selectedAssets, ap)
 		}
-		programs = append(programs, ap.ID)
 	}
-	var assetID string
-	switch kind {
-	case "filler":
-		idx := rand.Intn(len(fillers))
-		assetID = fillers[idx]
-	case "slates":
-		idx := rand.Intn(len(slates))
-		assetID = slates[idx]
-	case "program":
-		idx := rand.Intn(len(programs))
-		assetID = programs[idx]
-	case "ad":
-		idx := rand.Intn(len(ads))
-		assetID = ads[idx]
-	default:
-		panic("Unknown kind of asset")
+
+	if len(selectedAssets) == 0 {
+		panic("No  such asset kind: " + kind)
 	}
+
+	asset := selectedAssets[rand.Intn(len(selectedAssets))]
+
 	return Entry{
-		Name:        assetID,
-		AssetID:     assetID,
-		Offset:      offset,
-		Len:         length,
+		Name:        asset.ID,
+		AssetID:     asset.ID,
+		Offset:      0,
+		Len:         asset.len,
 		SCTEEventID: scteID,
 	}
 }
+
+// getAssetLen -- get length in number of GoPs
+func getAssetLen(assetPath string) (int64, error) {
+	bytes, err := os.ReadFile(assetPath)
+	if err != nil {
+		return 0, err
+	}
+
+	ci, err := esf.ParseContentInfo(bytes)
+	if err != nil {
+		return 0, err
+	}
+
+	cd := ci.ContentDurationMS
+	if cd == 0 {
+		return 0, fmt.Errorf("\"content_duration_ms\" not found")
+	}
+
+	gd := ci.GOPDurationMS
+	if gd == 0 {
+		return 0, fmt.Errorf("\"constant_gop_duration_ms\" not found")
+	}
+
+	return cd / gd, nil
+}