feat: support l3d-dash (SSR)

Squash merge l3d-dash (#12)

* Add low delay config to urlgen

* Fix low delay config in urlgen and read it on livempd

* mpd profile DASHProfileLinear

* add SchemeIdUriSSR to essential property on representations

* Set Role as main in main Adaptation Set

* cleanup for fresh start

* update LowDelay flag to take value from url instead of query parameter

* add essential property, role and startWithSAP at Adaptation Set level

* PartialSegments configuracion added to ResponseConfig and urlgen form

* Revert "PartialSegments configuracion added to ResponseConfig and urlgen form"

This reverts commit 491b159.

* add SubNumber for Low Delay to SegmentTimeline with $Number$

* rename LowDelayFlag

* l3d-dash/S@k (#3)

* Add chunkDuration parameter to generateTimelineEntries and related functions, calculating s@k and adding it to mpd
* Add simple Unit Tests for Calculate K function
* Add unit test for generateTimelineEntries with chunkDuration cases
* Moved Low Delay Checkbox to Low Latency section
* Update code to only send `s@K` if Low Latency flag is on

* Add LowDelay support and refactor related configurations

* l3d-dash/calc_subsegment_part_unit_tests (#5)

* Enhance calcSubSegementPart function to handle errors and add comprehensive unit tests

* Refactor segment handling: split writeChunkedSegment into prepareChunks and setHeaders for improved readability and error handling

* Add TestWriteSubSegment for validating sub-segment handling and error cases

* Refactor TestWriteSubSegment: remove unused mediaTimescale and cancelContext fields for clarity

* Update cmd/livesim2/app/livesegment_test.go

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

* Refactor TestWriteSubSegment: add availabilityTimeOffsetS to test cases for improved accuracy

* Fix wrong chunk index generation

* Implement SegmentSequenceProperties for l3d

* Undo SegmentSequenceProperties implementation

* Implement single chunk generation in the sub segments

* Remove unused lowDelay config

* Remove unnecessary sleep on writing sub segemnts

* Add l3d testdata

* Fix writeSubSegment debug messages

* Fix wrong asset naming

* Update l3d dash to no-cmaf

* Fix return segements without a sub segment

* Add audio to de l3d-dash sample and fix template generation

* Fix unit test

* Update Low Delay sample

* Add SubNumber to $Time$ with SegmentTimeline

* feat: update dash-mpd to v0.13.0 and improve Makefile

* fix: use new S type struct from dash-mpd

* feat: add L3D to Number wo timeline

* fix: failing tests with K

* feat: Add SegmentSequenceProperties element

* fix: availabilityTimeOffset not defined issue

* fix: lint errors

* fix: lint errors

* remove unnecessary withe spaces

* refactor: rename chunk duration parameters for clarity

* refactor: update comments related with low-delay for clarity

* refactor: rename chunk duration in seconds variable for clarity

* refactor: rename DASH profile constant for consistency and update usage in LiveMPD function

* fix: remove duration attribute from Period element for clarity

* refactor: Add chunkIndex explanation comment in the chunkSegment generation

* rafactor: Update ssr schme uri constant naming aligment

* rafactor: update writeSubSegment comments for clarity

* rafactor: remove harcoded role for low delay assets

* refactor: rename low delay mode to SSR and update related configurations

* refactor ssr essential property

* switching implementation

* remove cfg EnableSSR from handler livesim

* fix

* test fix

* fix

* add lowdelay chunk duration config

* parse low dealy chunk duration

* add unit test cases

* add chunk duration for low delay

* bugfix

* bugfix - representation id regex update when the id string is a substring of other representation id

* update assets for low delay and regular renditions

* update assets for low delay and regular renditions

* refactor low delay flag and implement k for low latency

* code refactor

* code refactor

* remove unused parameter

* add comment

* condition refactor

* refactor segment template for low delay and added low latency  cadence

* fix linter issues

* ssr html name update

* remove segment sequence properties from low delay low latency

* remove cadence from low latency and add ssr

* low latency start with sap

* low delay audio

* rename low delay adaptation set to ssrAS

* rename low delay chunk duration to chunk dur ssr

* Fixed validation to ensure adaptationSetId is a non-negative integer

* Adding ProfileAdvancedLinear only if it is not already included

* Fix typo

* Error handling for pairs different than 2

* Error handling for extra spaces on configuration

* Error handling chunk duration greater than segment duration

* Error handling for empty and invalid configurations

* Fix chunking fallback

* AvailabilityTimeOffset left as default and ignored for SSR

* Remove availabilityTimeOffset from write sub segment test

* remove space

* fix chunkdurssr cant be used on its own

* Fix chunking fallback

* fix chunkdurssr cant be used on its own

* AvailabilityTimeOffset left as default and ignored for SSR

* remove space

* error handling for ssras not configured when using chunkdurssr

* unit test fix

* fixes after main merge

* revert anchor regex for matching representations

---------

Co-authored-by: Juan Manuel Gonzalez <[email protected]>
Co-authored-by: Sebastian Piquerez <[email protected]>
Co-authored-by: Juan Manuel Gonzalez <[email protected]>
Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
Co-authored-by: Sebastian Piquerez <[email protected]>
Co-authored-by: Emil Santurio <[email protected]>
Co-authored-by: Torbjörn Einarsson <[email protected]>

Author: 6 people

README.md

@@ -164,6 +164,7 @@ Then run
 ```sh
 > go mod tidy
 ```
+
 to fetch and install all dependencies.
 
 To build `dashfetcher` and `livesim2` you can use the `Makefile` like

cmd/dashfetcher/app/fetcher.go

@@ -325,7 +325,7 @@ func AutoDir(rawMPDurl, outDir string) (string, error) {
 		if outRange > len(uBaseParts) {
 			break
 		}
-		for i := 0; i < outRange; i++ {
+		for i := range outRange {
 			if outParts[outStart+i] != uBaseParts[i] {
 				match = false
 				break

cmd/livesim2/app/asset.go

@@ -453,9 +453,31 @@ func (l lastSegInfo) availabilityTime(ato float64) float64 {
 	return math.Round(float64(l.startTime+l.dur)/float64(l.timescale)) - ato
 }
 
+func calculateK(segmentDuration uint64, mediaTimescale int, chunkDurS *float64) (*uint64, error) {
+	if chunkDurS == nil || *chunkDurS <= 0 {
+		return nil, nil
+	}
+	chunkDurInTimescale := *chunkDurS * float64(mediaTimescale)
+	if chunkDurInTimescale <= 0 {
+		return nil, nil
+	}
+
+	// Validate that chunk duration is not greater than segment duration
+	segmentDurS := float64(segmentDuration) / float64(mediaTimescale)
+	if *chunkDurS > segmentDurS {
+		return nil, fmt.Errorf("chunk duration %.2fs must be less than or equal to segment duration %.2fs", *chunkDurS, segmentDurS)
+	}
+
+	kVal := uint64(math.Round(float64(segmentDuration) / chunkDurInTimescale))
+	if kVal > 1 {
+		return &kVal, nil
+	}
+	return nil, nil
+}
+
 // generateTimelineEntries generates timeline entries for the given representation.
 // If no segments are available, startNr and lsi.nr are set to -1.
-func (a *asset) generateTimelineEntries(repID string, wt wrapTimes, atoMS int) segEntries {
+func (a *asset) generateTimelineEntries(repID string, wt wrapTimes, atoMS int, explicitChunkDurS *float64) (segEntries, error) {
 	rep := a.Reps[repID]
 	segs := rep.Segments
 	nrSegs := len(segs)
@@ -497,14 +519,20 @@ func (a *asset) generateTimelineEntries(repID string, wt wrapTimes, atoMS int) s
 	if wt.nowWraps < 0 { // no segment finished yet. Return an empty list and set startNr and lsi.nr = -1
 		se.startNr = -1
 		se.lsi.nr = -1
-		return se
+		return se, nil
 	}
 
 	se.startNr = wt.startWraps*nrSegs + relStartIdx
 	nowNr := wt.nowWraps*nrSegs + relNowIdx
 	t := uint64(rep.duration()*wt.startWraps) + segs[relStartIdx].StartTime
 	d := segs[relStartIdx].dur()
-	s := &m.S{T: Ptr(t), D: d}
+
+	k, err := calculateK(d, rep.MediaTimescale, explicitChunkDurS)
+	if err != nil {
+		return se, err
+	}
+
+	s := &m.S{T: Ptr(t), D: d, CommonSegmentSequenceAttributes: m.CommonSegmentSequenceAttributes{K: k}}
 	lsi := lastSegInfo{
 		timescale: uint64(rep.MediaTimescale),
 		startTime: t,
@@ -522,18 +550,18 @@ func (a *asset) generateTimelineEntries(repID string, wt wrapTimes, atoMS int) s
 			continue
 		}
 		d = seg.dur()
-		s = &m.S{D: d}
+		s = &m.S{D: d, CommonSegmentSequenceAttributes: m.CommonSegmentSequenceAttributes{K: k}}
 		se.entries = append(se.entries, s)
 		lsi.dur = d
 		lsi.nr = nr
 	}
 	se.lsi = lsi
-	return se
+	return se, nil
 }
 
 // generateTimelineEntriesFromRef generates timeline entries for the given representation given reference.
 // This is based on sample duration and the type of media.
-func (a *asset) generateTimelineEntriesFromRef(refSE segEntries, repID string) segEntries {
+func (a *asset) generateTimelineEntriesFromRef(refSE segEntries, repID string, explicitChunkDurS *float64) (segEntries, error) {
 	rep := a.Reps[repID]
 	nrSegs := 0
 	for _, rs := range refSE.entries {
@@ -547,7 +575,7 @@ func (a *asset) generateTimelineEntriesFromRef(refSE segEntries, repID string) s
 	}
 
 	if refSE.startNr < 0 {
-		return se
+		return se, nil
 	}
 
 	sampleDur := uint64(rep.sampleDur())
@@ -562,7 +590,7 @@ func (a *asset) generateTimelineEntriesFromRef(refSE segEntries, repID string) s
 	editListOffset := uint64(rep.EditListOffset)
 	expectedTime := t // Track what the time should be without explicit T
 	var s *m.S
-
+	var k *uint64
 	for _, rs := range refSE.entries {
 		refD := rs.D
 		for j := 0; j <= rs.R; j++ {
@@ -571,6 +599,12 @@ func (a *asset) generateTimelineEntriesFromRef(refSE segEntries, repID string) s
 			d := nextT - t
 
 			if s == nil {
+				var err error
+				k, err = calculateK(d, rep.MediaTimescale, explicitChunkDurS)
+				if err != nil {
+					return se, err
+				}
+
 				// First segment: apply editListOffset adjustment
 				adjustedT := t
 				adjustedD := d
@@ -590,12 +624,18 @@ func (a *asset) generateTimelineEntriesFromRef(refSE segEntries, repID string) s
 					}
 				}
 
-				s = &m.S{T: m.Ptr(adjustedT), D: adjustedD}
+				s = &m.S{T: m.Ptr(adjustedT), D: adjustedD, CommonSegmentSequenceAttributes: m.CommonSegmentSequenceAttributes{K: k}}
 				se.entries = append(se.entries, s)
 				expectedTime = adjustedT + adjustedD // Update expected time after first segment
 			} else {
 				// Subsequent segments
 				if s.D != d {
+					var err error
+					k, err = calculateK(d, rep.MediaTimescale, explicitChunkDurS)
+					if err != nil {
+						return se, err
+					}
+
 					// New segment with different duration
 					adjustedT := t
 					if editListOffset > 0 && t >= editListOffset {
@@ -605,10 +645,10 @@ func (a *asset) generateTimelineEntriesFromRef(refSE segEntries, repID string) s
 					// Only add explicit T if the time is not continuous
 					if adjustedT == expectedTime {
 						// Time is continuous, no need for explicit T
-						s = &m.S{D: d}
+						s = &m.S{D: d, CommonSegmentSequenceAttributes: m.CommonSegmentSequenceAttributes{K: k}}
 					} else {
 						// Time is discontinuous, need explicit T
-						s = &m.S{T: m.Ptr(adjustedT), D: d}
+						s = &m.S{T: m.Ptr(adjustedT), D: d, CommonSegmentSequenceAttributes: m.CommonSegmentSequenceAttributes{K: k}}
 					}
 					se.entries = append(se.entries, s)
 					expectedTime = adjustedT + d
@@ -620,7 +660,7 @@ func (a *asset) generateTimelineEntriesFromRef(refSE segEntries, repID string) s
 			t = nextT
 		}
 	}
-	return se
+	return se, nil
 }
 
 func (a *asset) setReferenceRep() error {
@@ -822,6 +862,7 @@ type RepData struct {
 	ConstantSampleDuration *uint32          `json:"constantSampleDuration,omitempty"` // Non-zero if all samples have the same duration
 	EditListOffset         int64            `json:"editListOffset,omitempty"`
 	PreEncrypted           bool             `json:"preEncrypted"`
+	ChunkDurSSRS           *float64         `json:"chunkDurSSRS,omitempty"` // Low delay chunk duration in seconds
 	mediaRegexp            *regexp.Regexp   `json:"-"`
 	initSeg                *mp4.InitSegment `json:"-"`
 	initBytes              []byte           `json:"-"`

cmd/livesim2/app/asset_test.go

@@ -171,6 +171,103 @@ func TestAssetLookupForNameOverlap(t *testing.T) {
 	require.Equal(t, "assets/testpic_2s_1", a.AssetPath)
 }
 
+func TestCalculateK(t *testing.T) {
+	testCases := []struct {
+		description     string
+		segmentDuration uint64
+		mediaTimescale  int
+		chunkDuration   *float64
+		expectedK       *uint64
+		expectedError   string
+	}{
+		{
+			description:     "nil chunk duration",
+			segmentDuration: 192000,
+			mediaTimescale:  96000,
+			chunkDuration:   nil,
+			expectedK:       nil,
+		},
+		{
+			description:     "zero chunk duration",
+			segmentDuration: 192000,
+			mediaTimescale:  96000,
+			chunkDuration:   Ptr(0.0),
+			expectedK:       nil,
+		},
+		{
+			description:     "negative chunk duration",
+			segmentDuration: 192000,
+			mediaTimescale:  96000,
+			chunkDuration:   Ptr(-1.0),
+			expectedK:       nil,
+		},
+		{
+			description:     "zero media timescale",
+			segmentDuration: 192000,
+			mediaTimescale:  0,
+			chunkDuration:   Ptr(1.0),
+			expectedK:       nil,
+		},
+		{
+			description:     "k=4",
+			segmentDuration: 192000,
+			mediaTimescale:  96000,
+			chunkDuration:   Ptr(0.5),
+			expectedK:       Ptr(uint64(4)),
+		},
+		{
+			description:     "k=1, returns nil",
+			segmentDuration: 192000,
+			mediaTimescale:  96000,
+			chunkDuration:   Ptr(2.0),
+			expectedK:       nil,
+		},
+		{
+			description:     "rounding up",
+			segmentDuration: 192000,
+			mediaTimescale:  96000,
+			chunkDuration:   Ptr(0.57), // 3.5087... -> 4
+			expectedK:       Ptr(uint64(4)),
+		},
+		{
+			description:     "rounding down",
+			segmentDuration: 192000,
+			mediaTimescale:  96000,
+			chunkDuration:   Ptr(0.58), // 3.448... -> 3
+			expectedK:       Ptr(uint64(3)),
+		},
+		{
+			description:     "chunk duration greater than segment duration",
+			segmentDuration: 192000,
+			mediaTimescale:  96000,
+			chunkDuration:   Ptr(2.5), // 2.5s > 2.0s segment duration
+			expectedK:       nil,
+			expectedError:   "chunk duration 2.50s must be less than or equal to segment duration 2.00s",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.description, func(t *testing.T) {
+			gotK, err := calculateK(tc.segmentDuration, tc.mediaTimescale, tc.chunkDuration)
+
+			if tc.expectedError != "" {
+				require.Error(t, err)
+				require.Equal(t, tc.expectedError, err.Error())
+				require.Nil(t, gotK)
+				return
+			}
+
+			require.NoError(t, err)
+			if tc.expectedK == nil {
+				require.Nil(t, gotK)
+			} else {
+				require.NotNil(t, gotK)
+				require.Equal(t, *tc.expectedK, *gotK)
+			}
+		})
+	}
+}
+
 func copyDir(srcDir, dstDir string) error {
 	if err := os.MkdirAll(dstDir, 0755); err != nil {
 		return err

cmd/livesim2/app/cmaf-ingester.go

@@ -522,16 +522,26 @@ func (c *cmafIngester) sendMediaSegments(ctx context.Context, nextSegNr, nowMS i
 		atoMS := int(c.cfg.getAvailabilityTimeOffsetS() * 1000)
 		for idx, rd := range c.repsData {
 			var se segEntries
+			var err error
 			// The first representation is used as reference for generating timeline entries
 			if idx == 0 {
-				refSegEntries = c.asset.generateTimelineEntries(rd.repID, wTimes, atoMS)
+				refSegEntries, err = c.asset.generateTimelineEntries(rd.repID, wTimes, atoMS, nil)
+				if err != nil {
+					return err
+				}
 				se = refSegEntries
 			} else {
 				switch rd.contentType {
 				case "video", "text", "image":
-					se = c.asset.generateTimelineEntries(rd.repID, wTimes, atoMS)
+					se, err = c.asset.generateTimelineEntries(rd.repID, wTimes, atoMS, nil)
+					if err != nil {
+						return err
+					}
 				case "audio":
-					se = c.asset.generateTimelineEntriesFromRef(refSegEntries, rd.repID)
+					se, err = c.asset.generateTimelineEntriesFromRef(refSegEntries, rd.repID, nil)
+					if err != nil {
+						return err
+					}
 				default:
 					return fmt.Errorf("unknown content type %s", rd.contentType)
 				}

cmd/livesim2/app/config.go

@@ -27,6 +27,7 @@ const (
 	defaultReqIntervalS             = 24 * 3600
 	defaultAvailabilityStartTimeS   = 0
 	defaultAvailabilityTimeComplete = true
+	defaultSSRFlag                  = false
 	defaultTimeShiftBufferDepthS    = 60
 	defaultStartNr                  = 0
 	timeShiftBufferDepthMarginS     = 10

cmd/livesim2/app/configurl.go

@@ -65,7 +65,9 @@ const (
 )
 
 const (
-	UrlParamSchemeIdUri = "urn:mpeg:dash:urlparam:2014"
+	UrlParamSchemeIdUri               = "urn:mpeg:dash:urlparam:2014"
+	SsrSchemeIdUri                    = "urn:mpeg:dash:ssr:2023"
+	AdaptationSetSwitchingSchemeIdUri = "urn:mpeg:dash:adaptation-set-switching:2016"
 )
 
 type ResponseConfig struct {
@@ -110,6 +112,9 @@ type ResponseConfig struct {
 	SegStatusCodes               []SegStatusCodes  `json:"SegStatus,omitempty"`
 	Traffic                      []LossItvls       `json:"Traffic,omitempty"`
 	Query                        *Query            `json:"Query,omitempty"`
+	SSRFlag                      bool              `json:"SSRFlag,omitempty"`
+	SSRAS                        string            `json:"SSRAS,omitempty"`
+	ChunkDurSSR                  string            `json:"ChunkDurSSR,omitempty"`
 }
 
 // SegStatusCodes configures regular extraordinary segment response codes
@@ -241,6 +246,7 @@ func NewResponseConfig() *ResponseConfig {
 	c := ResponseConfig{
 		StartTimeS:                   defaultAvailabilityStartTimeS,
 		AvailabilityTimeCompleteFlag: defaultAvailabilityTimeComplete,
+		SSRFlag:                      defaultSSRFlag,
 		TimeShiftBufferDepthS:        Ptr(defaultTimeShiftBufferDepthS),
 		StartNr:                      Ptr(defaultStartNr),
 		TimeSubsDurMS:                defaultTimeSubsDurMS,
@@ -394,6 +400,11 @@ cfgLoop:
 			}
 		case "annexI":
 			cfg.Query = sc.ParseQuery(key, val)
+		case "ssras":
+			cfg.SSRAS = val
+			cfg.SSRFlag = true
+		case "chunkdurssr":
+			cfg.ChunkDurSSR = val
 		default:
 			contentStartIdx = i
 			break cfgLoop
@@ -447,6 +458,10 @@ func verifyAndFillConfig(cfg *ResponseConfig, nowMS int) error {
 	}
 	// We do not check here that the drm is one that has been configured,
 	// since pre-encrypted content will influence what is valid.
+	
+	if cfg.ChunkDurSSR != "" && cfg.SSRAS == "" {
+		return fmt.Errorf("chunkDurSSR requires ssrAS to be configured")
+	}
 	return nil
 }