')
end = d.find('')
testOutputFile = "SegTimeline1.txt"
segTimeline = d[start:end+18]
write_data_to_outfile(d[start:end+18].encode('utf-8'), testOutputFile)
dp2 = dash_proxy.DashProvider("streamtest.eu", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=15)
d2 = mpd_proxy.get_mpd(dp2)
start2 = d2.find('')
end2 = d2.find('')
testOutputFile = "SegTimeline2.txt"
segTimeline2 = d2[start2:end2+18]
write_data_to_outfile(d2[start2:end2+18].encode('utf-8'), testOutputFile)
self.assertEqual(segTimeline, segTimeline2)
def testNewSegmentsAdded(self):
urlParts = ['livesim', 'baseurl_u10_d20', 'segtimeline_1', 'segtimelineloss_1', 'testpic', 'Manifest.mpd']
dp = dash_proxy.DashProvider("streamtest.eu", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=10)
d = mpd_proxy.get_mpd(dp)
start = d.find('')
end = d.find('')
testOutputFile = "SegTimeline3.txt"
write_data_to_outfile(d[start:end+18].encode('utf-8'), testOutputFile)
segTimeline = d[start:end+18]
dp2 = dash_proxy.DashProvider("streamtest.eu", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=31)
d2 = mpd_proxy.get_mpd(dp2)
start2 = d2.find('')
end2 = d2.find('')
testOutputFile = "SegTimeline4.txt"
write_data_to_outfile(d2[start2:end2+18].encode('utf-8'), testOutputFile)
segTimeline2 = d2[start2:end2+18]
self.assertNotEqual(segTimeline, segTimeline2)
================================================
FILE: dashlivesim/tests/test_segmentmuxer.py
================================================
# The copyright in this software is being made available under the BSD License,
# included below. This software may be subject to other third party and contributor
# rights, including patent rights, and no such rights are granted under this license.
#
# Copyright (c) 2015, Dash Industry Forum.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation and/or
# other materials provided with the distribution.
# * Neither the name of Dash Industry Forum nor the names of its
# contributors may be used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
import unittest
from os.path import join
from dashlivesim.tests.dash_test_util import rm_outfile, write_data_to_outfile, CONTENT_ROOT
from dashlivesim.dashlib import segmentmuxer
V1_INIT = join(CONTENT_ROOT, "testpic/V1/init.mp4")
A1_INIT = join(CONTENT_ROOT, "testpic/A1/init.mp4")
V1_1 = join(CONTENT_ROOT, "testpic/V1/1.m4s")
A1_1 = join(CONTENT_ROOT, "testpic/A1/1.m4s")
class TestInitMuxing(unittest.TestCase):
def testInitMuxing(self):
testOutputFile = "init_muxed.mp4"
rm_outfile(testOutputFile)
mi = segmentmuxer.MultiplexInits(V1_INIT, A1_INIT)
muxed = mi.construct_muxed()
write_data_to_outfile(muxed, testOutputFile)
class TestSegmentMuxing(unittest.TestCase):
def testFragmentMuxing(self):
testOutputFile = "1_fmux.mp4s"
rm_outfile(testOutputFile)
ml = segmentmuxer.MultiplexMediaSegments(V1_1, A1_1)
fmux = ml.mux_on_fragment_level()
write_data_to_outfile(fmux, testOutputFile)
def testSampleMuxing(self):
testOutputFile = "1_smux.m4s"
rm_outfile(testOutputFile)
ml = segmentmuxer.MultiplexMediaSegments(V1_1, A1_1)
smux = ml.mux_on_sample_level()
write_data_to_outfile(smux, testOutputFile)
================================================
FILE: dashlivesim/tests/test_segmenttimeline.py
================================================
# The copyright in this software is being made available under the BSD License,
# included below. This software may be subject to other third party and contributor
# rights, including patent rights, and no such rights are granted under this license.
#
# Copyright (c) 2015, Dash Industry Forum.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation and/or
# other materials provided with the distribution.
# * Neither the name of Dash Industry Forum nor the names of its
# contributors may be used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
import unittest
from xml.etree import ElementTree
from dashlivesim.tests.dash_test_util import VOD_CONFIG_DIR, CONTENT_ROOT, rm_outfile, write_data_to_outfile
from dashlivesim.dashlib import dash_proxy, mpd_proxy
NAMESPACE = 'urn:mpeg:dash:schema:mpd:2011'
def node_ns(name):
return '{%s}%s' % (NAMESPACE, name)
class TestMPDWithSegmentTimeline(unittest.TestCase):
"Test that the MPD looks correct when segtimeline_1 is defined."
def setUp(self):
self.now = 6003
self.tsbd = 30
urlParts = ['livesim', 'segtimeline_1', 'tsbd_%d' % self.tsbd, 'testpic', 'Manifest.mpd']
dp = dash_proxy.DashProvider("server.org", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=self.now)
self.d = mpd_proxy.get_mpd(dp)
self.root = ElementTree.fromstring(self.d)
def testThatNumberTemplateFeaturesAreAbsent(self):
testOutputFile = "segtimeline.mpd"
rm_outfile(testOutputFile)
write_data_to_outfile(self.d.encode('utf-8'), testOutputFile)
self.assertTrue(self.d.find("startNumber") == -1) # There should be no startNumber in the MPD
self.assertTrue(self.d.find("duration") == -1) # There should be no duration in the segmentTemplate
self.assertTrue(self.d.find("$Number$") == -1) # There should be no $Number$ in template
self.assertTrue(self.d.find("maxSegmentDuration") == -1) # There should be no maxSegmentDuration in MPD
def testThatSegmentTimeLineDataIsPresent(self):
testOutputFile = "segtimeline.mpd"
rm_outfile(testOutputFile)
write_data_to_outfile(self.d.encode('utf-8'), testOutputFile)
self.assertTrue(self.d.find("$Time$") > 0) # There should be $Time$ in the MPD
def testThatTheLastSegmentReallyIsTheLatest(self):
"Check that the last segment's end is less than one duration from now."
period = self.root.find(node_ns('Period'))
for adaptation_set in period.findall(node_ns('AdaptationSet')):
segment_template = adaptation_set.find(node_ns('SegmentTemplate'))
timescale = int(segment_template.attrib['timescale'])
segment_timeline = segment_template.find(node_ns('SegmentTimeline'))
s_elements = segment_timeline.findall(node_ns('S'))
seg_start_time = None
seg_end_time = None
for s_elem in s_elements:
if seg_start_time is None:
seg_start_time = int(s_elem.attrib['t'])
else:
seg_start_time = seg_end_time
nr_repeat = int(s_elem.attrib.get('r', 0))
duration = int(s_elem.attrib['d'])
seg_end_time = seg_start_time + duration * (1 + nr_repeat)
last_end_time = seg_end_time / timescale
self.assertLess(last_end_time, self.now)
last_end_time_plus_duration = (seg_end_time + duration)/timescale
self.assertGreater(last_end_time_plus_duration, self.now)
def testThatTheLastSegmentReallyIsTheLatestAtWrapAround(self):
"Check that the last segment's end is less than one duration from now at wraparound."
self.now = 3603
self.tsbd = 30
urlParts = ['livesim', 'segtimeline_1', 'tsbd_%d' % self.tsbd, 'testpic', 'Manifest.mpd']
dp = dash_proxy.DashProvider("server.org", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=self.now)
self.d = mpd_proxy.get_mpd(dp)
self.root = ElementTree.fromstring(self.d)
period = self.root.find(node_ns('Period'))
for adaptation_set in period.findall(node_ns('AdaptationSet')):
segment_template = adaptation_set.find(node_ns('SegmentTemplate'))
timescale = int(segment_template.attrib['timescale'])
segment_timeline = segment_template.find(node_ns('SegmentTimeline'))
s_elements = segment_timeline.findall(node_ns('S'))
seg_start_time = None
seg_end_time = None
for s_elem in s_elements:
if seg_start_time is None:
seg_start_time = int(s_elem.attrib['t'])
else:
seg_start_time = seg_end_time
nr_repeat = int(s_elem.attrib.get('r', 0))
duration = int(s_elem.attrib['d'])
seg_end_time = seg_start_time + duration * (1 + nr_repeat)
last_end_time = seg_end_time / timescale
self.assertLess(last_end_time, self.now)
last_end_time_plus_duration = (seg_end_time + duration)/timescale
self.assertGreater(last_end_time_plus_duration, self.now)
def testThatFirstSegmentStartsJustBeforeTsbd(self):
"Check that the first segment starts less than one period before now-tsbd."
period = self.root.find(node_ns('Period'))
for adaptation_set in period.findall(node_ns('AdaptationSet')):
segment_template = adaptation_set.find(node_ns('SegmentTemplate'))
timescale = int(segment_template.attrib['timescale'])
segment_timeline = segment_template.find(node_ns('SegmentTimeline'))
first_s_elem = segment_timeline.find(node_ns('S'))
first_start = int(first_s_elem.attrib['t'])
duration = int(first_s_elem.attrib['d'])
start_time = first_start / timescale
start_time_plus_duration = (first_start + duration) / timescale
self.assertLess(start_time, self.now - self.tsbd)
self.assertGreater(start_time_plus_duration, self.now - self.tsbd)
def find_first_audio_t(root):
"""Return t and d from the first audio segment."""
period = root.find(node_ns('Period'))
for adaptation_set in period.findall(node_ns('AdaptationSet')):
content_type = adaptation_set.attrib['contentType']
if content_type != 'audio':
continue
segment_template = adaptation_set.find(node_ns('SegmentTemplate'))
# timescale = int(segment_template.attrib['timescale'])
segment_timeline = segment_template.find(node_ns('SegmentTimeline'))
first_s_elem = segment_timeline.find(node_ns('S'))
first_t = int(first_s_elem.attrib['t'])
first_d = int(first_s_elem.attrib['d'])
return first_t, first_d
raise ValueError("Could not find audio adaptation set")
class TestAvoidJump(unittest.TestCase):
def testThatTimesDontJump(self):
"Test that times don't jump as reported in ISSUE #91."
# First get the MPD corresponding to 5.mpd.txt
now = 1578681199
urlParts = ['livesim', 'segtimeline_1', 'testpic', 'Manifest.mpd']
dp = dash_proxy.DashProvider("server.org", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=now)
d = mpd_proxy.get_mpd(dp)
root = ElementTree.fromstring(d)
first_t, first_d = find_first_audio_t(root)
# tsbd = 300 # TimeShiftBufferDepth
self.assertTrue(now - first_t/48000 > 300, "Did not get before timeshift window start")
later = now + 6
urlParts = ['livesim', 'segtimeline_1', 'testpic', 'Manifest.mpd']
dp = dash_proxy.DashProvider("server.org", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=later)
d = mpd_proxy.get_mpd(dp)
root = ElementTree.fromstring(d)
second_t, second_d = find_first_audio_t(root)
self.assertEqual(second_t, first_t + first_d, "Second t is not first t + first d ")
class TestMPDWithSegmentTimelineWrap(unittest.TestCase):
"Test that the MPD looks correct when wrapping."
def testAfterWrap(self):
self.now = 3610
self.tsbd = 60
urlParts = ['livesim', 'segtimeline_1', 'tsbd_%d' % self.tsbd, 'testpic', 'Manifest.mpd']
dp = dash_proxy.DashProvider("server.org", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=self.now)
self.d = mpd_proxy.get_mpd(dp)
self.root = ElementTree.fromstring(self.d)
nrSegments = self.getNrSegments(self.root)
self.assertEqual(2*10, nrSegments)
write_data_to_outfile(self.d.encode('utf-8'), "AfterWrap.mpd")
def testBefore(self):
self.now = 3590
self.tsbd = 60
urlParts = ['livesim', 'segtimeline_1', 'tsbd_%d' % self.tsbd,
'testpic', 'Manifest.mpd']
dp = dash_proxy.DashProvider("server.org", urlParts, None,
VOD_CONFIG_DIR, CONTENT_ROOT,
now=self.now)
self.d = mpd_proxy.get_mpd(dp)
self.root = ElementTree.fromstring(self.d)
nrSegments = self.getNrSegments(self.root)
self.assertEqual(2*10, nrSegments)
write_data_to_outfile(self.d.encode('utf-8'), "BeforeWrap.mpd")
def getNrSegments(self, root):
nrSegments = 0
period = root.find(node_ns('Period'))
aSets = period.findall(node_ns('AdaptationSet'))
for aSet in aSets:
sTempl = aSet.find(node_ns('SegmentTemplate'))
sLines = sTempl.findall(node_ns('SegmentTimeline'))
for sLine in sLines:
sElems = sLine.findall(node_ns('S'))
for sElem in sElems:
if 'r' in sElem.attrib:
nrSegments += int(sElem.attrib['r']) + 1
else:
nrSegments += 1
return nrSegments
class TestSegmentTimelineInterval(unittest.TestCase):
"""SegmentTimeline with start, stop, timeoffset"""
def setUp(self):
self.now = 100
urlParts = ['livesim', 'segtimeline_1', 'start_60', 'stop_120',
'timeoffset_0', 'testpic', 'Manifest.mpd']
dp = dash_proxy.DashProvider("server.org", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=self.now)
self.d = mpd_proxy.get_mpd(dp)
self.root = ElementTree.fromstring(self.d)
def testSegmentList(self):
period = self.root.find(node_ns('Period'))
for adaptation_set in period.findall(node_ns('AdaptationSet')):
content_type = adaptation_set.attrib['contentType']
if content_type != "video":
continue
segment_template = adaptation_set.find(node_ns('SegmentTemplate'))
timescale = int(segment_template.attrib['timescale'])
segment_timeline = segment_template.find(node_ns('SegmentTimeline'))
s_elements = segment_timeline.findall(node_ns('S'))
seg_start_time = None
seg_end_time = None
for s_elem in s_elements:
if seg_start_time is None:
seg_start_time = int(s_elem.attrib['t'])
self.assertEqual(60 * timescale, seg_start_time)
else:
seg_start_time = seg_end_time
nr_repeat = int(s_elem.attrib.get('r', 0))
duration = int(s_elem.attrib['d'])
seg_end_time = seg_start_time + duration * (1 + nr_repeat)
last_end_time = seg_end_time / timescale
self.assertLess(last_end_time, self.now)
last_end_time_plus_duration = (seg_end_time + duration)/timescale
self.assertGreater(last_end_time_plus_duration, self.now)
class TestMultiPeriodSegmentTimeline(unittest.TestCase):
"Test that the MPD looks correct when segtimeline_1 and periods_60 are both defined."
def setUp(self):
self.now = 6003
self.tsbd = 90
urlParts = ['livesim', 'segtimeline_1', 'periods_60', 'tsbd_%d' % self.tsbd, 'testpic', 'Manifest.mpd']
dp = dash_proxy.DashProvider("server.org", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=self.now)
self.d = mpd_proxy.get_mpd(dp)
def testThatThereAreMultiplePeriods(self):
"Check that the first segment starts less than one period before now-tsbd."
testOutputFile = "segtimeline_periods.mpd"
rm_outfile(testOutputFile)
write_data_to_outfile(self.d.encode('utf-8'), testOutputFile)
self.root = ElementTree.fromstring(self.d)
periods = self.root.findall(node_ns('Period'))
self.assertGreater(len(periods), 1)
class TestMediaSegments(unittest.TestCase):
"Test that media segments are served properly."
def setUp(self):
self.seg_nr = 349
self.timescale = 48000
self.duration = 6
self.seg_time = self.seg_nr * self.duration * self.timescale
self.now = (self.seg_nr+2)*self.duration
def testThatTimeLookupWorks(self):
urlParts = ['livesim', 'segtimeline_1', 'testpic', 'A1', 't%d.m4s' % self.seg_time]
dp = dash_proxy.DashProvider("server.org", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=self.now)
d = dash_proxy.get_media(dp)
self.assertTrue(isinstance(d, bytes), "A segment is returned")
def testThatTimeSegmentIsSameAsNumber(self):
urlParts = ['livesim', 'segtimeline_1', 'testpic', 'A1', 't%d.m4s' % self.seg_time]
dp = dash_proxy.DashProvider("server.org", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=self.now)
time_seg = dash_proxy.get_media(dp)
urlParts = ['livesim', 'segtimeline_1', 'testpic', 'A1', '%d.m4s' % self.seg_nr]
dp = dash_proxy.DashProvider("server.org", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=self.now)
nr_seg = dash_proxy.get_media(dp)
self.assertEqual(len(time_seg), len(nr_seg))
self.assertEqual(time_seg, nr_seg)
class TestMPDWithSegmentTimelineNumber(unittest.TestCase):
"Test that the MPD looks correct when segtimelinenr_1 is defined."
def setUp(self):
self.now = 6003
self.tsbd = 30
urlParts = ['livesim', 'segtimelinenr_1', 'tsbd_%d' % self.tsbd,
'testpic', 'Manifest.mpd']
dp = dash_proxy.DashProvider("server.org", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=self.now)
self.d = mpd_proxy.get_mpd(dp)
self.root = ElementTree.fromstring(self.d)
def testThatSomeFeaturesAreAbsent(self):
testOutputFile = "segtimelinenr.mpd"
rm_outfile(testOutputFile)
write_data_to_outfile(self.d.encode('utf-8'), testOutputFile)
self.assertTrue(self.d.find("duration") == -1) # There should be no duration in the segmentTemplate
self.assertTrue(self.d.find("$Time$") == -1) # There should be no
# $Number$ in template
self.assertTrue(self.d.find("maxSegmentDuration") == -1) # There should be no maxSegmentDuration in MPD
def testThatSegmentTimeLineDataIsPresent(self):
testOutputFile = "segtimelinenr.mpd"
rm_outfile(testOutputFile)
write_data_to_outfile(self.d.encode('utf-8'), testOutputFile)
self.assertTrue(self.d.find("$Number$") > 0, "$Number$ missing")
def testThatFirstSegmentHasRightNumber(self):
"Check that the first segment has the right number."
duration_in_s = 6
period = self.root.find(node_ns('Period'))
for adaptation_set in period.findall(node_ns('AdaptationSet')):
segment_template = adaptation_set.find(node_ns('SegmentTemplate'))
timescale = int(segment_template.attrib['timescale'])
start_number = int(segment_template.attrib['startNumber'])
segment_timeline = segment_template.find(node_ns('SegmentTimeline'))
first_s_elem = segment_timeline.find(node_ns('S'))
first_start = int(first_s_elem.attrib['t'])
duration = duration_in_s * timescale
start_nr_from_time = int(round(1.0 * first_start / duration))
self.assertEqual(start_number, start_nr_from_time)
================================================
FILE: dashlivesim/tests/test_startnr.py
================================================
# The copyright in this software is being made available under the BSD License,
# included below. This software may be subject to other third party and contributor
# rights, including patent rights, and no such rights are granted under this license.
#
# Copyright (c) 2015, Dash Industry Forum.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation and/or
# other materials provided with the distribution.
# * Neither the name of Dash Industry Forum nor the names of its
# contributors may be used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
import unittest
from os.path import join
from dashlivesim.tests.dash_test_util import OUT_DIR
from dashlivesim.dashlib import dash_proxy, mpd_proxy
from dashlivesim.tests.dash_test_util import VOD_CONFIG_DIR, CONTENT_ROOT
from dashlivesim.tests.dash_test_util import findAllIndexes
class TestMpdChange(unittest.TestCase):
"Test that MPD gets startNr changed in an appropriate way"
def testMpdWithNormalStartNr(self):
"Check that startNumber=0."
urlParts = ['pdash', 'testpic', 'Manifest.mpd']
dp = dash_proxy.DashProvider("streamtest.eu", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=0)
d = mpd_proxy.get_mpd(dp)
with open(join(OUT_DIR, 'tmp.mpd'), 'wb') as ofh:
ofh.write(d.encode('utf-8'))
self.assertEqual(len(findAllIndexes('startNumber="0"', d)), 2)
self.assertTrue(d.find('availabilityStartTime="1970-01-01T00:00:00Z"') > 0)
def testMpdWitdStartNrIs111(self):
"Check that startNumber=111."
urlParts = ['pdash', 'snr_111', 'testpic', 'Manifest.mpd']
dp = dash_proxy.DashProvider("streamtest.eu", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=0)
d = mpd_proxy.get_mpd(dp)
self.assertEqual(len(findAllIndexes('startNumber="111"', d)), 2)
self.assertTrue(d.find('availabilityStartTime="1970-01-01T00:00:00Z"') > 0)
def testMpdWithStartNrIs1(self):
"Check that startNumber=1."
urlParts = ['pdash', 'snr_1', 'testpic', 'Manifest.mpd']
dp = dash_proxy.DashProvider("streamtest.eu", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=0)
d = mpd_proxy.get_mpd(dp)
self.assertEqual(len(findAllIndexes('startNumber="1"', d)), 2)
self.assertTrue(d.find('availabilityStartTime="1970-01-01T00:00:00Z"') > 0)
def testMpdWithImplicitStartNr(self):
"Check that startNumber is not present in MPD."
urlParts = ['pdash', 'snr_-1', 'testpic', 'Manifest.mpd']
dp = dash_proxy.DashProvider("streamtest.eu", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=0)
d = mpd_proxy.get_mpd(dp)
self.assertTrue(d.find('startNumber=') < 0)
self.assertTrue(d.find('availabilityStartTime="1970-01-01T00:00:00Z"') > 0)
# Could add tests to check availability time of segments depending on startNr
# Add test to check if segmentNumber and tfdt are OK depending on startNr.
# Just running the reference player with different values seems to show that it is working properly, though.
================================================
FILE: dashlivesim/tests/test_subtitles.py
================================================
# The copyright in this software is being made available under the BSD License,
# included below. This software may be subject to other third party and contributor
# rights, including patent rights, and no such rights are granted under this license.
#
# Copyright (c) 2015, Dash Industry Forum.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation and/or
# other materials provided with the distribution.
# * Neither the name of Dash Industry Forum nor the names of its
# contributors may be used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
import unittest
from dashlivesim.tests.dash_test_util import rm_outfile, write_data_to_outfile, VOD_CONFIG_DIR, CONTENT_ROOT
from dashlivesim.dashlib import ttml_timing_offset
from dashlivesim.dashlib import dash_proxy, mpd_proxy
TEST_STRING_1 = b'< begin="01:02:03.1234" end="10:59:43:29" >'
TEST_STRING_SEG_NR = b'... Segment # 12 ...'
class TestTtmlTimingChange(unittest.TestCase):
"Test that TTML string is changed properly."
def testNoChange(self):
"Offset is 0 seconds."
outString = ttml_timing_offset.adjust_ttml_content(TEST_STRING_1, 0, None)
self.assertEqual(outString, TEST_STRING_1)
def testAdd1Hour(self):
"Offset is 3600."
outString = ttml_timing_offset.adjust_ttml_content(TEST_STRING_1, 3600, None)
outGoal = b'< begin="02:02:03.1234" end="11:59:43:29" >'
self.assertEqual(outString, outGoal)
def testWrap(self):
"Add an offset that wraps."
outString = ttml_timing_offset.adjust_ttml_content(TEST_STRING_1, 360050, None)
outGoal = b'< begin="101:02:53.1234" end="111:00:33:29" >'
self.assertEqual(outString, outGoal)
class TestTtmlSegmentNrChange(unittest.TestCase):
"Test that TTML string is changed properly."
def testSetToRightNr(self):
"Output Nr should be what is input."
outString = ttml_timing_offset.adjust_ttml_content(TEST_STRING_SEG_NR, 360050, 22)
outGoal = b'... Segment # 22 ...'
self.assertEqual(outString, outGoal)
class TestSegmentModification(unittest.TestCase):
def testTtmlSegment(self):
testOutputFile = "sub.m4s"
rm_outfile(testOutputFile)
segmentNr = 718263000
segment = "%d.m4s" % segmentNr
now = segmentNr * 2 + 10
urlParts = ['livsim', 'ato_inf', 'testpic_stpp', 'S1', segment]
dp = dash_proxy.DashProvider("127.0.0.1", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=now)
d = dash_proxy.get_media(dp)
write_data_to_outfile(d, testOutputFile)
self.assertTrue(d.find(b'begin="399035:00:00.000"') > 0)
self.assertTrue(d.find(b'eng : UTC = 2015-07-10T11:00:00Z') > 0)
class TestMpdExtraction(unittest.TestCase):
def testStartNumber(self):
"Check that all 3 media components have startNumber=0"
urlParts = ['livesim', 'testpic_stpp', 'Manifest_stpp.mpd']
dp = dash_proxy.DashProvider("streamtest.eu", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=0)
d = mpd_proxy.get_mpd(dp)
self.assertEqual(d.count('startNumber="0'), 3)
================================================
FILE: dashlivesim/tests/test_suggested_presentation_delay.py
================================================
# The copyright in this software is being made available under the BSD License,
# included below. This software may be subject to other third party and contributor
# rights, including patent rights, and no such rights are granted under this license.
#
# Copyright (c) 2018, Dash Industry Forum.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation and/or
# other materials provided with the distribution.
# * Neither the name of Dash Industry Forum nor the names of its
# contributors may be used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
import unittest
from dashlivesim.dashlib import dash_proxy, mpd_proxy
from dashlivesim.tests.dash_test_util import VOD_CONFIG_DIR, CONTENT_ROOT
class TestSuggestedPresentationDelay(unittest.TestCase):
"Test that MPD gets startNr changed in an appropriate way"
def testSuggestedPresentationDelayNotPresent(self):
"Check that suggestedPresentationDelayIsNotPresent."
urlParts = ['pdash', 'testpic', 'Manifest.mpd']
dp = dash_proxy.DashProvider("streamtest.eu", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=0)
d = mpd_proxy.get_mpd(dp)
self.assertTrue(d.find('suggestedPresentationDelay') < 0)
def testSuggestedPresentationDelayPresent(self):
"Check that suggestedPresentationDelay get the right value."
urlParts = ['pdash', 'spd_10', 'testpic', 'Manifest.mpd']
dp = dash_proxy.DashProvider("streamtest.eu", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=0)
d = mpd_proxy.get_mpd(dp)
self.assertTrue(d.find('suggestedPresentationDelay="PT10S"') > 0)
================================================
FILE: dashlivesim/tests/test_ttml_update.py
================================================
# The copyright in this software is being made available under the BSD License,
# included below. This software may be subject to other third party and contributor
# rights, including patent rights, and no such rights are granted under this license.
#
# Copyright (c) 2020, Dash Industry Forum.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation and/or
# other materials provided with the distribution.
# * Neither the name of Dash Industry Forum nor the names of its
# contributors may be used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
import unittest
from dashlivesim.dashlib import ttml_timing_offset
TTML_IN = b'\d\d):(?P\d\d):(?P\d\d)')
# CONTENT_PATTERN_S = re.compile(rb'(?P\w+) : (?P\d\d):(?P\d\d):(?P\d\d)(\.\d+)?')
# CONTENT_PATTERN_SEGMENT = re.compile(rb'(?PSegment # )(?P\d+)')
class TestTTMLTimeUpdate(unittest.TestCase):
def testUpdateTTMLTime(self):
outbytes = ttml_timing_offset.adjust_ttml_content(TTML_IN, 22, 24)
self.assertEqual(outbytes, TTML_OUT)
================================================
FILE: dashlivesim/tests/test_xlinkperiod.py
================================================
# The copyright in this software is being made available under the BSD License,
# included below. This software may be subject to other third party and contributor
# rights, including patent rights, and no such rights are granted under this license.
#
# Copyright (c) 2015, Dash Industry Forum.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation and/or
# other materials provided with the distribution.
# * Neither the name of Dash Industry Forum nor the names of its
# contributors may be used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
import unittest
from re import findall
from operator import mul
from functools import reduce
from dashlivesim.tests.dash_test_util import VOD_CONFIG_DIR, CONTENT_ROOT
from dashlivesim.dashlib import dash_proxy, mpd_proxy
from dashlivesim.dashlib import mpdprocessor
class TestXlinkPeriod(unittest.TestCase):
def setUp(self):
self.old_set_baseurl = mpdprocessor.SET_BASEURL
mpdprocessor.SET_BASEURL = True
def tearDown(self):
mpdprocessor.SET_BASEURL = self.old_set_baseurl
def testMpdPeriodReplaced(self):
" Check whether appropriate periods have been replaced by in .mpd file"
collectresult = 1
for k in [1, 2, 5, 10]:
nr_period_per_hour = 10
nr_xlink_periods_per_hour = k
urlParts = ['livesim', 'periods_%s' % nr_period_per_hour, 'xlink_%s' % nr_xlink_periods_per_hour,
'testpic_2s', 'Manifest.mpd']
dp = dash_proxy.DashProvider("10.4.247.98", urlParts, None, VOD_CONFIG_DIR, CONTENT_ROOT, now=10000)
d = mpd_proxy.get_mpd(dp)
period_id_all = findall('Period id="([^"]*)"', d)
# Find all period ids in the .mpd file returned.
# We will check whether the correct periods have been xlinked here.
one_xlinks_for_how_many_periods = nr_period_per_hour/nr_xlink_periods_per_hour
period_id_xlinks = [int(x[1:]) % one_xlinks_for_how_many_periods for x in period_id_all]
# All the period ids.
# If there were any periods, that were not supposed to be there,
# then one of the elements in period_id_xlinks would be zero.
result = reduce(mul, period_id_xlinks, 1)
collectresult = result * collectresult
self.assertTrue(collectresult != 0)
================================================
FILE: dashlivesim/tests/testpic/Manifest.mpd
================================================
Media Presentation Description by MobiTV. Powered by MDL Team@Sweden.
================================================
FILE: dashlivesim/tests/testpic_2s/Manifest.mpd
================================================
Media Presentation Description by MobiTV. Powered by MDL Team@Sweden.
================================================
FILE: dashlivesim/tests/testpic_stpp/Manifest_stpp.mpd
================================================
Media Presentation Description by MobiTV. Powered by MDL Team@Sweden.
================================================
FILE: dashlivesim/tests/vod_cfg/testpic.cfg
================================================
[General]
version = 1.1
[Setup]
first_segment_in_loop = 1
nr_segments_in_loop = 600
segment_duration_s = 6
default_tsbd_secs = 300
[video]
representations = V1
timescale = 90000
total_duration = 324000000
dat_file = testpic_video.dat
[audio]
representations = A1
timescale = 48000
total_duration = 172800000
dat_file = testpic_audio.dat
================================================
FILE: dashlivesim/tests/vod_cfg/testpic_2s.cfg
================================================
[Setup]
default_tsbd_secs = 300
segment_duration_s = 2
first_segment_in_loop = 1
nr_segments_in_loop = 1800
[audio]
representations = A48
timescale = 48000
[video]
representations = V300
timescale = 90000
[subtitles]
representations = S1,sub_eng,sub_swe,sub_eng_cap,S1_one_region,S1_two_regions,sub_ttml_qbb,sub_nor, S1_two_regions_multi_color
timescale = 1000
[General]
version = 1.0
================================================
FILE: dashlivesim/tests/vod_cfg/testpic_stpp.cfg
================================================
[General]
version = 1.0
[Setup]
first_segment_in_loop = 1
nr_segments_in_loop = 1800
segment_duration_s = 2
default_tsbd_secs = 300
[video]
representations = V1
timescale = 90000
[audio]
representations = A1
timescale = 48000
[subtitles]
representations = S1
timescale = 1000
================================================
FILE: dashlivesim/vodanalyzer/__init__.py
================================================
# The copyright in this software is being made available under the BSD License,
# included below. This software may be subject to other third party and contributor
# rights, including patent rights, and no such rights are granted under this license.
#
# Copyright (c) 2015, Dash Industry Forum.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation and/or
# other materials provided with the distribution.
# * Neither the name of Dash Industry Forum nor the names of its
# contributors may be used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: dashlivesim/vodanalyzer/dashanalyzer.py
================================================
"""Analyze DASH content in live profile and extract parameters for VoD-config file for live source simulator.
"""
# The copyright in this software is being made available under the BSD License,
# included below. This software may be subject to other third party and contributor
# rights, including patent rights, and no such rights are granted under this license.
#
# Copyright (c) 2015, Dash Industry Forum.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation and/or
# other materials provided with the distribution.
# * Neither the name of Dash Industry Forum nor the names of its
# contributors may be used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
import sys
import os
import time
import re
from struct import pack
from dashlivesim.dashlib import configprocessor
from dashlivesim.dashlib import initsegmentfilter, mediasegmentfilter
from dashlivesim.vodanalyzer.mpdprocessor import MpdProcessor
DEFAULT_DASH_NAMESPACE = "urn:mpeg:dash:schema:mpd:2011"
MUX_TYPE_NONE = 0
MUX_TYPE_FRAGMENT = 1
MUX_TYPE_SAMPLES = 2
## Utility functions
def makeTimeStamp(t):
return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(t))
def makeDurationFromS(nrSeconds):
return "PT%dS" % nrSeconds
class DashAnalyzerError(Exception):
"""Error in DashAnalyzer."""
class DashAnalyzer(object):
def __init__(self, mpd_filepath, verbose=1):
self.mpd_filepath = mpd_filepath
path_parts = mpd_filepath.split('/')
self.base_name = 'content'
if len(path_parts) >= 2:
self.base_name = path_parts[-2]
self.config_filename = self.base_name + ".cfg"
self.base_path = os.path.split(mpd_filepath)[0]
self.verbose = verbose
self.as_data = {} # List of adaptation sets (one for each media)
self.muxedRep = None
self.muxedPaths = {}
self.mpdSegStartNr = -1
self.segDuration = None
self.firstSegmentInLoop = -1
self.lastSegmentInLoop = -1
self.nrSegmentsInLoop = -1
self.mpdProcessor = MpdProcessor(self.mpd_filepath)
self.loopTime = self.mpdProcessor.media_presentation_duration_in_s
def analyze(self):
self.initMedia()
self.checkAndUpdateMediaData()
self.write_config(self.config_filename)
def initMedia(self):
"Init media by analyzing the MPD and the media files."
for adaptation_set in self.mpdProcessor.get_adaptation_sets():
content_type = adaptation_set.content_type
if content_type is None:
print("No contentType for adaptation set")
sys.exit(1)
if content_type in self.as_data:
raise DashAnalyzerError("Multiple adaptation sets for contentType " + content_type)
as_data = {'as' : adaptation_set, 'reps' : []}
as_data['presentationDurationInS'] = self.mpdProcessor.media_presentation_duration_in_s
self.as_data[content_type] = as_data
for rep in adaptation_set.representations:
rep_data = {'representation' : rep, 'id' : rep.rep_id}
as_data['reps'].append(rep_data)
initPath = rep.initialization_path
rep_data['relInitPath'] = initPath
rep_data['absInitPath'] = os.path.join(self.base_path, initPath)
init_filter = initsegmentfilter.InitFilter(rep_data['absInitPath'])
init_filter.filter()
rep_data['trackID'] = init_filter.track_id
print("%s trackID = %d" % (content_type, rep_data['trackID']))
rep_data['relMediaPath'] = rep.get_media_path()
rep_data['absMediaPath'] = os.path.join(self.base_path, rep.get_media_path())
rep_data['default_sample_duration'] = \
init_filter.default_sample_duration
self.getSegmentRange(rep_data)
track_timescale = init_filter.track_timescale
if 'track_timescale' not in as_data:
as_data['track_timescale'] = track_timescale
elif track_timescale != as_data['track_timescale']:
raise DashAnalyzerError("Timescales not consistent between %s tracks" % content_type)
if self.verbose:
print("%s data: " % content_type)
for (k, v) in rep_data.items():
print(" %s=%s" % (k, v))
def getSegmentRange(self, rep_data):
"Search the directory for the first and last segment and set firstNumber and lastNumber for this MediaType."
rep_id = rep_data['id']
mediaDir, mediaName = os.path.split(rep_data['absMediaPath'])
mediaRegexp = mediaName.replace("%d", "(\d+)").replace(".", "\.")
mediaReg = re.compile(mediaRegexp)
files = os.listdir(mediaDir)
numbers = []
for f in files:
matchObj = mediaReg.match(f)
if matchObj:
number = int(matchObj.groups(1)[0])
numbers.append(number)
numbers.sort()
for i in range(1, len(numbers)):
if numbers[i] != numbers[i-1] + 1:
raise DashAnalyzerError("%s segment missing between %d and %d" % (rep_id, numbers[i-1], numbers[i]))
print("Found %s segments %d - %d" % (rep_id, numbers[0], numbers[-1]))
rep_data['firstNumber'] = numbers[0]
rep_data['lastNumber'] = numbers[-1]
def checkAndUpdateMediaData(self):
"""Check all segments for good values and return startTimes and total duration."""
lastGoodSegments = []
print("Checking all the media segment durations for deviations.")
def writeSegTiming(ofh, firstSegmentInRepeat, firstStartTimeInRepeat, duration, repeatCount):
data = pack(configprocessor.SEGTIMEFORMAT, firstSegmentInRepeat, repeatCount,
firstStartTimeInRepeat, duration)
ofh.write(data)
for content_type in self.as_data.keys():
as_data = self.as_data[content_type]
as_data['datFile'] = "%s_%s.dat" % (self.base_name, content_type)
adaptation_set = as_data['as']
print("Checking %s with timescale %d" % (content_type, as_data['track_timescale']))
if self.segDuration is None:
self.segDuration = adaptation_set.duration
else:
assert self.segDuration == adaptation_set.duration
track_timescale = as_data['track_timescale']
with open(as_data['datFile'], "wb") as ofh:
for (rep_nr, rep_data) in enumerate(as_data['reps']):
rep_id = rep_data['id']
rep_data['endNr'] = None
rep_data['startTick'] = None
rep_data['endTick'] = None
if self.firstSegmentInLoop >= 0:
assert rep_data['firstNumber'] == self.firstSegmentInLoop
else:
self.firstSegmentInLoop = rep_data['firstNumber']
if self.mpdSegStartNr >= 0:
assert adaptation_set.start_number == self.mpdSegStartNr
else:
self.mpdSegStartNr = adaptation_set.start_number
segTicks = self.segDuration*track_timescale
maxDiffInTicks = int(track_timescale*0.1) # Max 100ms
segNr = rep_data['firstNumber']
repeatCount = -1
firstSegmentInRepeat = -1
firstStartTimeInRepeat = -1
lastDuration = 0
while (True):
segmentPath = rep_data['absMediaPath'] % segNr
if not os.path.exists(segmentPath):
if self.verbose:
print("\nLast good %s segment is %d, endTime=%.3fs, totalTime=%.3fs" % (
rep_id, rep_data['endNr'], rep_data['endTime'],
rep_data['endTime']-rep_data['startTime']))
break
msf = mediasegmentfilter.MediaSegmentFilter(
segmentPath, default_sample_duration = rep_data[
'default_sample_duration'])
msf.filter()
tfdt = msf.get_tfdt_value()
duration = msf.get_duration()
print("{0} {1:8d} {2} {3}".format(content_type, segNr, tfdt, duration))
if duration == lastDuration:
repeatCount += 1
else:
if lastDuration != 0 and rep_nr == 0:
writeSegTiming(ofh, firstSegmentInRepeat,
firstStartTimeInRepeat,
lastDuration, repeatCount)
repeatCount = 0
lastDuration = duration
firstSegmentInRepeat = segNr
firstStartTimeInRepeat = tfdt
if rep_data['startTick'] is None:
rep_data['startTick'] = tfdt
rep_data['startTime'] = rep_data['startTick']/float(track_timescale)
print("First %s segment is %d starting at time %.3fs" % (rep_id, segNr,
rep_data['startTime']))
# Check that there is not too much drift. We want to end with at most maxDiffInTicks
endTick = tfdt + duration
idealTicks = (segNr - rep_data['firstNumber'] + 1)*segTicks + rep_data['startTick']
absDiffInTicks = abs(idealTicks - endTick)
if absDiffInTicks < maxDiffInTicks:
# This is a good wrap point
rep_data['endTick'] = tfdt + duration
rep_data['endTime'] = rep_data['endTick']/float(track_timescale)
rep_data['endNr'] = segNr
else:
raise DashAnalyzerError("Too much drift in the duration of the segments")
segNr += 1
if self.verbose:
sys.stdout.write(".")
if rep_nr == 0:
writeSegTiming(ofh, firstSegmentInRepeat, firstStartTimeInRepeat, duration, repeatCount)
lastGoodSegments.append(rep_data['endNr'])
as_data['totalTicks'] = rep_data['endTick'] - rep_data['startTick']
self.lastSegmentInLoop = min(lastGoodSegments)
self.nrSegmentsInLoop = self.lastSegmentInLoop-self.firstSegmentInLoop+1
self.loopTime = self.nrSegmentsInLoop*self.segDuration
if self.verbose:
print("")
print("Will loop segments %d-%d with loop time %ds" % (self.firstSegmentInLoop, self.lastSegmentInLoop,
self.loopTime))
def write_config(self, config_file):
"""Write a config file for the analyzed content, that can then be used to serve it efficiently."""
cfg_data = {'version' : '1.1', 'first_segment_in_loop' : self.firstSegmentInLoop,
'nr_segments_in_loop' : self.nrSegmentsInLoop, 'segment_duration_s' : self.segDuration}
media_data = {}
for content_type in ('video', 'audio'):
if content_type in self.as_data:
mdata = self.as_data[content_type]
media_data[content_type] = {'representations' : [rep['id'] for rep in mdata['reps']],
'timescale' : mdata['track_timescale'],
'totalDuration' : mdata['totalTicks'],
'datFile' : mdata['datFile']}
cfg_data['media_data'] = media_data
vod_cfg = configprocessor.VodConfig()
vod_cfg.write_config(config_file, cfg_data)
def processMpd(self):
"""Process the MPD and make an appropriate live version."""
mpdData = {"availabilityStartTime" :makeTimeStamp(self.mpdAvailabilityStartTIme),
"timeShiftBufferDepth" : makeDurationFromS(self.timeShiftBufferDepthInS),
"minimumUpdatePeriod" : "PT30M"}
if not self.muxType != MUX_TYPE_NONE:
self.mpdProcessor.makeLiveMpd(mpdData)
else:
self.mpdProcessor.makeLiveMultiplexedMpd(mpdData, self.media_data)
self.muxedRep = self.mpdProcessor.getMuxedRep()
targetMpdNamespace = None
if self.fixNamespace:
targetMpdNamespace = DEFAULT_DASH_NAMESPACE
self.mpd = self.mpdProcessor.getCleanString(True, targetMpdNamespace)
def main():
from optparse import OptionParser
verbose = 0
usage = "usage: %prog [options] mpdPath"
parser = OptionParser(usage)
parser.add_option("-v", "--verbose", dest="verbose", action="store_true")
(options, args) = parser.parse_args()
if options.verbose:
verbose = 1
if len(args) != 1:
parser.error("incorrect number of arguments")
mpdFile = args[0]
dashAnalyzer = DashAnalyzer(mpdFile, verbose)
dashAnalyzer.analyze()
if __name__ == "__main__":
main()
================================================
FILE: dashlivesim/vodanalyzer/mpdprocessor.py
================================================
"""DASH MPD processor and classes for MPD elements."""
# The copyright in this software is being made available under the BSD License,
# included below. This software may be subject to other third party and contributor
# rights, including patent rights, and no such rights are granted under this license.
#
# Copyright (c) 2015, Dash Industry Forum.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation and/or
# other materials provided with the distribution.
# * Neither the name of Dash Industry Forum nor the names of its
# contributors may be used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
from xml.etree import ElementTree
import io
import re
from dashlivesim.dashlib import timeformatconversions as tfc
RE_DURATION = re.compile(r"PT((?P\d+)H)?((?P\d+)M)?((?P\d+)S)?")
RE_NAMESPACE_TAG = re.compile(r"({.*})?(.*)")
class MpdElementError(Exception):
"""General MpdElement Error."""
class MpdElement(object):
"""BaseClass for MPD elements."""
def __init__(self, node):
self.node = node
self.attribs = {}
# pylint: disable=no-self-use
def parse(self):
"""Parse the node and its children."""
raise MpdElementError("Not implemented")
# pylint: disable=no-self-use, unused-argument
def make_live(self, data):
"""Change attributes and values to make this MPD live. Use the data dictionary for this."""
raise MpdElementError("Not implemented")
#pylint: disable=no-self-use, unused-variable
def tag_and_namespace(self, full_tag):
"""Extract tag and namespace."""
match_obj = RE_NAMESPACE_TAG.match(full_tag)
tag = match_obj.group(2)
namespace = match_obj.group(1)
return (tag, namespace)
def compare_tag(self, full_tag, string):
"""Compare tag to see if it is equal."""
tag, namespace = self.tag_and_namespace(full_tag)
return tag == string
def check_and_add_attributes(self, node, attribs):
"""Check if node has attributes and add them to self.attribs."""
for attr in attribs:
if attr in node.attrib:
self.attribs[attr] = node.attrib[attr]
else:
if not attr in self.attribs:
self.attribs[attr] = None
def set_value(self, element, key, data):
"""Set attribute key of element to value data[key], if present."""
if key in data:
element.set(key, str(data[key]))
class Mpd(MpdElement):
"""Top level MPD element."""
def __init__(self, node):
MpdElement.__init__(self, node)
self.periods = []
def parse(self):
"""Parse the node and its children."""
self.check_and_add_attributes(self.node, ('profiles', 'maxSegmentDuration', 'minBufferTime',
'type', 'mediaPresentationDuration'))
for child in self.node:
if self.compare_tag(child.tag, 'Period'):
period = Period(child)
period.parse()
self.periods.append(period)
def make_live(self, data):
"""Change attributes and values to make this MPD live. Use the data dictionary for this."""
self.set_value(self.node, 'type', 'dynamic')
for attr in ('availabilityStartTime', 'availabilityEndTime'):
self.set_value(self.node, attr, data[attr])
for period in self.periods:
period.make_live(data)
class Period(MpdElement):
"Period element in MPD."
def __init__(self, node):
MpdElement.__init__(self, node)
self.adaptation_sets = []
def parse(self):
"Parse the node and its children."
self.check_and_add_attributes(self.node, ('id', 'start'))
for child in self.node:
if self.compare_tag(child.tag, 'AdaptationSet'):
adaptation_set = AdaptationSet(child)
adaptation_set.parse()
self.adaptation_sets.append(adaptation_set)
def make_live(self, data):
for attr in ('start'):
self.set_value(self.node, attr, data[attr])
for adaptation_set in self.adaptation_sets:
adaptation_set.make_live(data)
class AdaptationSet(MpdElement):
"AdaptationSet element in a Period."
def __init__(self, node):
MpdElement.__init__(self, node)
self.segment_template = None
self.representations = []
@property
def content_type(self):
"Get the contentType for the AdaptationSet."
return self.attribs['contentType']
@property
def media_pattern(self):
"Get the media pattern from SegmentTemplate."
return self.attribs['media']
@property
def initialization_pattern(self):
"Get the initialization pattern from SegmentTemplate."
return self.attribs['initialization']
@property
def start_number(self):
"StartNumber for segments (from SegmentTemplate)."
return int(self.attribs['startNumber'])
@property
def timescale(self):
"Timescale in units per seconds to be used for the derivation of different real-time duration values in the Segment Information"
return int(self.attribs['timescale'] or 1)
@property
def duration(self):
"Segment duration (in whole seconds)."
return int(self.attribs['duration']) // self.timescale
def parse(self):
"Parse the node and its children."
self.check_and_add_attributes(self.node, ('contentType', 'mimeType'))
for child in self.node:
if self.compare_tag(child.tag, 'SegmentTemplate'):
self.check_and_add_attributes(child, ('initialization', 'startNumber', 'media',
'duration', 'timescale'))
elif self.compare_tag(child.tag, 'Representation'):
rep = Representation(self, child)
rep.parse()
self.representations.append(rep)
def make_live(self, data):
for attr in ('startNr'):
self.set_value(self.node, attr, data[attr])
for adaptation_set in self.adaptation_sets:
adaptation_set.make_live(data)
class Representation(MpdElement):
"Representation element in an AdaptationSet."
def __init__(self, adaptation_set, node):
MpdElement.__init__(self, node)
self.adaptation_set = adaptation_set
@property
def initialization_path(self):
"The initialization path of this representation."
return self.get_initialization_path()
@property
def rep_id(self):
"Id of this representation."
return self.attribs['id']
def parse(self):
"Parse the node and its children."
self.check_and_add_attributes(self.node, ('id', 'bandwidth'))
def get_initialization_path(self):
"The initialization path of this representation."
init_pattern = self.adaptation_set.initialization_pattern
rep_id = self.attribs['id']
bandwidth = self.attribs['bandwidth']
init_path = init_pattern.replace("$RepresentationID$", rep_id).replace("$bandwidth$", bandwidth)
return init_path
def get_media_path(self, segNr="%d"):
"Return the media path for this representation and given segNr."
media_pattern = self.adaptation_set.media_pattern
rep_id = self.attribs['id']
bandwidth = self.attribs['bandwidth']
media_path = media_pattern.replace("$RepresentationID$", rep_id).replace("$bandwidth$", bandwidth)
media_path = media_path.replace("$Number$", str(segNr))
return media_path
class MpdProcessor(MpdElement):
"""Modify the mpd to become live. Whatever is input in data is set to these values."""
def __init__(self, infile):
self.tree = ElementTree.parse(infile)
self.mpd_namespace = None
self.root = self.tree.getroot()
self.is_base_url_set = False
self.adaptation_sets = []
self.media_presentation_duration = None
self.media_presentation_duration_in_s = None
self.muxed_rep = None
self.parse()
def parse(self):
"Parse and find all the adaptation sets and their representations."
mpd = self.root
tag, self.mpd_namespace = self.tag_and_namespace(mpd.tag)
assert tag == "MPD"
if 'mediaPresentationDuration' in mpd.attrib:
self.media_presentation_duration = mpd.attrib['mediaPresentationDuration']
self.media_presentation_duration_in_s = tfc.iso_duration_to_seconds(self.media_presentation_duration)
print("Found mediaPresentationDuration = %ds" % self.media_presentation_duration_in_s)
for child in mpd:
if self.compare_tag(child.tag, 'Period'):
for grand_child in child:
if self.compare_tag(grand_child.tag, 'AdaptationSet'):
AS = AdaptationSet(grand_child)
AS.parse()
self.adaptation_sets.append(AS)
def get_adaptation_sets(self):
return self.adaptation_sets
def getMuxedRep(self):
return self.muxed_rep
def getMuxedInitPath(self):
initPath = None
for AS in self.adaptation_sets:
if AS.contentType == "video":
print(AS.initialization)
initPath = AS.initialization.replace("$RepresentationID$", self.muxed_rep)
return initPath
def getMuxedMediaPath(self):
mediaPath = None
for AS in self.adaptation_sets:
if AS.contentType == "video":
mediaPath = AS.media.replace("$RepresentationID$", self.muxed_rep).replace("$Number$", "%d")
return mediaPath
def process(self, mpdData={}):
MPD = self.root
self.processMPD(MPD, mpdData)
def makeLiveMpd(self, data):
"""Process the root element (MPD) and set values from data dictionary.
Typical keys are: availabilityStartTime, timeShiftBufferDepth, minimumUpdatePeriod."""
MPD = self.root
MPD.set('type', "dynamic")
for key in data.keys():
self.setValue(MPD, key, data)
if 'mediaPresentationDuration' in MPD.attrib:
del MPD.attrib['mediaPresentationDuration']
for child in MPD:
if self.compare_tag(child.tag, 'Period'):
child.set("start", "PT0S") # Set Period start to 0
def makeLiveMultiplexedMpd(self, data, mediaData):
self.makeLiveMpd(data)
MPD = self.root
audioAS = None
videoAS = None
period = None
audioRep = None
vidoeRep = None
for child in MPD:
if self.compare_tag(child.tag, 'Period'):
period = child
for grandChild in child:
if self.compare_tag(grandChild.tag, 'AdaptationSet'):
AS = AdaptationSet(grandChild)
AS.parse()
if AS.contentType == "audio":
audioAS = grandChild
elif AS.contentType == "video":
videoAS = grandChild
for contentType, mData in mediaData.items():
trackID = mData['trackID']
cc = self.makeContentComponent(contentType, trackID)
videoAS.insert(0, cc)
del videoAS.attrib['contentType']
audioRep = audioAS.find(self.mpd_namespace+"Representation")
videoRep = videoAS.find(self.mpd_namespace+"Representation")
videoRep.set("id", self.muxed_rep)
try:
audioCodec = audioRep.attrib["codecs"]
videoCodec = videoRep.attrib["codecs"]
combinedCodecs = "%s,%s" % (audioCodec, videoCodec)
videoRep.set("codecs", combinedCodecs)
except KeyError:
print("Could not combine codecs")
period.remove(audioAS)
def makeContentComponent(self, contentType, trackID):
"Create and insert a contentComponent element."
elem = ElementTree.Element('%sContentComponent' % self.mpd_namespace)
elem.set("id", str(trackID))
elem.set("contentType", contentType)
elem.tail = "\n"
return elem
def getCleanString(self, clean=True, targetMpdNameSpace=None):
"Get a string of all XML cleaned (no ns0 namespace)"
ofh = io.StringIO()
self.tree.write(ofh)#, default_namespace=NAMESPACE)
value = ofh.getvalue()
if clean:
value = value.replace("ns0:", "").replace("xmlns:ns0=", "xmlns=")
if targetMpdNameSpace is not None:
newStr = 'xmlns="%s"' % targetMpdNameSpace
value = re.sub('xmlns="[^"]+"', newStr, value)
xmlIntro = '\n'
return xmlIntro + value
================================================
FILE: dashlivesim/vodanalyzer/parse_dat_file.py
================================================
import sys
from struct import unpack
import argparse
from dashlivesim.dashlib.configprocessor import SEGTIMEFORMAT, SegTimeEntry
def parse_dat_file(infile_handle, verbosity_level):
data = infile_handle.read(12)
lste = None
while data:
ste = SegTimeEntry(*unpack(SEGTIMEFORMAT, data))
if lste:
last_end = lste.start_time + lste.duration * (lste.repeats + 1)
if last_end != ste.start_time:
print("Mismatch in end vs start time %d %d" % (ste.start_time, last_end))
if verbosity_level > 0:
print(ste)
lste = ste
data = infile_handle.read(12)
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Check segment datfile')
parser.add_argument('infile', nargs=1, type=argparse.FileType('rb'))
parser.add_argument('--verbose', '-v', action='count', default=0)
args = parser.parse_args()
parse_dat_file(args.infile[0], args.verbose)
================================================
FILE: doc/content.mdown
================================================
DASH-IF live source simulator test content.
=========================================
"Live" content from test server
---------------------
**Test live content with clock synchronized to wall clock (modulo hour)**
* [livesim/testpic_2s/Manifest.mpd](pdash/testpic_2s/Manifest.mpd) A live stream synchronized with wall clock with 2s segments. Max video bitrate: 348kbps, audio: 60kbps
VoD
---
VoD content used for the live content above (generated by MobiTV VoD segmenter).
* [dash/vod/testpic_2s/Manifest.mpd](dash/vod/testpic_2s/Manifest.mpd) A VoD test stream for AV sync (one representation with 2s segments). Max video bitrate: 348kbps, audio: 60kbps
Subtitles
---
VoD and live content:
* [dash/vod/testpic_2s/Manifest_stpp.mpd](dash/vod/testpic_2s/Manifest_stpp.mpd) One subtitle track.
* [dash/vod/testpic_2s/multi_subs.mpd](dash/vod/testpic_2s/multi_subs.mpd) Three subtitle tracks.
* [livesim/testpic_2s/Manifest_stpp.mpd](livsim/testpic_2s/Manifest_stpp.mpd) One subtitle track.
* [livesim/testpic_2s/multi_subs.mpd](livesim/testpic_2s/multi_subs.mpd) Three subtitle tracks.
================================================
FILE: doc/dashlivesim.mdown
================================================
DASH-IF configurable live content simulator
==================================================
Purpose
-------
The purpose of the DASH live simulator is to provide well-controlled live time-synced content for testing.
The main link to the content is [http://vm2.dashif.org/livesim/testpic_2s/Manifest.mpd][testpic_2s_base].
You can test it directly with Chrome (version>=38), Safari 8+, IE 11 (on Windows 8.1), Edge, and FireFox >=42 using
the [DASH-IF reference player][dashif_player].
It provides an infinite source that is synced with the wall clock at the source side (modulo 1 hour).
Time-synced content
--------------
The content testpic\_2s shows pictures with a clock and frame number.
The content wraps every hour, and is synchronized with the server clock, so that the content for a
specific time is made available when the end the corresponding segment has passed.
For example, the segment containing the data for 2min to 2min and ss passed a full hour,
is available at 2min and ss after the hour.
By watching the screen and noting the time and comparing it to a synchronized clock,
it is possible to measure the delay in the transport and rendering system. It is typically
longer for longer segments.
Options
---------
The test server offers the following features where some are turned on by modifying the URL path to the MPD.
* Live content simulation by providing segments from VoD content in a looped fashion
* Synchronization with wall-clock, so that a particular media segment is made available at a specific time.
This can be used for e2e delay estimation, see below.
* Full control over the bitrate and duration of the segments, since these are preproduced.
There are thus no surprises due to network problems in the live content stream towards the segmenter.
* Compliance with DASH264 Interoperability Guidelines
* Support for many different scenarios by specifying modifiers in the path
* Support for infinite sessions (no change in the MPD, and no duration set)
* Support for time-limited services and updated MPD which is configured in the URL
* Support for configuration of minimumUpdatePeriod, timeShiftBufferDepth, startNumber (including implicit)
* Support for periodic services which repeat every 10min or similar.
* Support for multiple periods and one period that started later that the session.
* Feedback on too early or too late segment fetching attempts by explicit text in HTTP 404 return messages
* Support for availability time offset in BaseURL element
* Disabling of all timing checks of segments by specifying the `ato_inf` modifier.
* On the fly multiplexing of audio and video (for eMBMS testing, rather than DASH-IF)
* Insertion of SCTE-35 ad signaling as emsg messages following the DASH-IF guidelines.
* Support for client-server time-sync using UTCTiming (head and direct methods). This reduces dash.js startup time.
* Support for choosing the startNumber in the MPD. All timing will be appropriately shifted so the content will be in sync, independent of the startNumber value.
* Support for live subtitling in TTML and more specifically in EBU-TT-D format.
* Support for signalling continuous adaptationSets over period boundaries.
* Support for SegmentTimeline manifests
* Support for xlink periods for ad insertion
* Support for ntp and sntp UTC timing
* Support for early-terminated periods
* Support for availabilityTimeOffset
Links and usage
---------------
The DASH-IF server is in the Amazon cloud at vm2.dashif.org.
There is currently only one test sequence, which is 1 hour long and provides a clock.
It is available with 2s segments in DASH live profile.
The content is available as `http://[serveraddress]/livesim/[contentName]/[Manifest].mpd`
and, in particular, the 2s source is [http://vm2.dashif.org/livesim/testpic_2s/Manifest.mpd][testpic_2s_base].
There are multiple modifiers that can be used. They need to be placed before `/testpic_2s` and are all of the form `/option_n`.
Events and other time-limited content
-------------------------------------
To control availabilityStartTime (AST) and availabilityEndTime (AET), one can add extra parts to the URL after pdash.
http:////start_ut/... will set the AST to the UNIX time ut (clipped to a multiple of duration)
http:////dur_dt/... will set the AET as well (ut+dt)
http:////dur_dt1/dur_dt2/ will set the AET and then updated it 2*minimumUpdatePeriod before the first has duration has been reached
The minimumUpdatePeriod is set to 1min by default in this mode.
One can also make the initialization segments available earlier than AST, by specifying init_ot where ot is an offset time in seconds.
An example
http:////start_1370809900/dur_1800/dur_300/init_10800/testpic_2s/Manifest.mpd
will set the availabilityStartTime to `2013-06-09T20:31:40 (UTC)`, and set the availabilityEndTime to
`013-06-09T21:01:40`, and the update it to `2013-06-09T21:06:40`. The initialization segments are set to be available 3 hours in advance.
The last media segments in a timelimited session, (with duration) will have the `lmsg` compatibility brand set,
to signal that they are last and that there are no more segments to fetch.
Note that one can influence the
`minimumUpdatePeriod`by the parameter `mup_x` in the path and `timeShiftBufferDepth` by the parameter `tsbd_x`. Here `x` is the value in seconds.
Too facilitate the creation of URLs for timelimited content, there is an online link generator [urlgen.html](urlgen.html).
There is also a command-line tool written in Python [generate_dashif_url.py](generate_dashif_url).
Dynamic MPD with static URLs
-----------------------------
To allow for testing of dynamic MPD updates without the need to construct a time-specific MPD, the following scheme is supported:
http:////modulo_x//
Here, `modulo_x` denotes that the content is available module `x` minutes,
the `availabilityStartTime` and the `mediaPresentationDuration` vary in an `x`-minute periodic pattern.
The number `x` must be a divisor of 60, i.e. on of 1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60.
For example, if `x=10`, the following happens (mpd = mediaPresentationDuration, mup=minimumUpdatePeriod):
hh:00:00-hh:00:59 ast = hh:00:00 mpd = 120s mup = 30s
hh:01:00-hh:02:59 ast = hh:00:00 mpd = 240s
hh:03:00-hh:04:59 ast = hh:00:00 mpd = 360s
hh:05:00-hh:08:59 ast = hh:00:00 mpd = 480s
hh:09:00-hh:10:59 ast = hh:10:00 mpd = 120s
In other words:
mup = 5% of the interval
0-10% of the interval, the mpd=20% of interval
10-30% of the interval, the mpd=40% of the interval
30-50% of the interval, the mpd=60% of the interval
50-90% of the interval, the mpd=80% of the interval
90-100% of the interval, the mpd=20% of the next interval
Thus, beyond the media session getting longer and longer during the first 50% of the session,
from 80-90% of the interval, the MPD will describe an expired session, and
from 90-100% of the interval, the MPD will describe a future session.
Multiple periods
----------------
Multiple periods are generated by specifying `periods_n` which results in the following:
* n = 0 One period but it starts 1000h after AST, so Period@start and presentatimeOffset are non-zero
* n > 0 n periods per hour (n = 1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60) and
`minimumUpdatePeriod` adjusted to be 5s less than half the period duration. The number of previous periods presented
depends on the `timeShiftBufferDepth`
The `presentationTimeOffset` is signalled in the `SegmentTemplate`. By specifying the option `/peroff_1`,
the `PTO` is instead signaled in a `SegmentBase` element in top level of the `Period`.
Ad insertion
------------
For testing of App-based ad-insertion, the server can add SCTE35 Splice Insert signals for one-three 10s ad insertions per minute.
Turn this on by specifying scte35_ where is 1,2, or 3 in the path before the content.
The ad timing is the following
* 1 ad per minute, start 10s past full minute
* 2 ads per minute, start at 10s and 40s past full minute
* 3 ads per minute, start at 10s, 30s, and 50s past full minute
The presence of such an event-stream is indicated in the manifest.
UTCTiming
---------
By specifying utc_head, utc_direct or a combination like utc_direct-head extra information will be added in the MPD
to provide the timing information. This is used by the dash.js to get a shorter startup time.
Multiplexed Content
-------------------
For eMBMS, better robustness can be achieved by multiplexing audio and video segments.
This can be done automatically by the server. It happens if the path to a segment has two underscores in the
next to last path component, like `.../V1__A1/123.m4s`. In this case the two segments `V1/123.m4s` and `V2/123.m4s` are fetched and multiplexed.
The corresponding thing happens for the init segments. For this to work, the MPD must be manually changed to have
a multiplexed representation.
How it works
------------
The module is stateless, and uses the URL to find out what content to serve.
The content must have an MPD with extension .mpd, initialization segments with extension .mp4 and
media segments with extension .m4s. Depending on the extension, the server will deliver read the
corresponding data from the VoD content and modify it. The modifications to the various
data server are:
*MPD file:*
@MPD level
set type dynamic
set publishTime /* Configurable in code */
set timeShiftBufferDepth
set availabilityStartTime
set minimumUpdatePeriod
set maxSegmentDuration
set mediaPresentationDuration if time-limited
set availabilityEndTime if time-limited
set startNumber (depending on snr_ parameter. Default is 0).
@Period level
set start
set periodname
@BaseURL
adding BaseURL if not present, or modifying if present
@SegmentTemplate level
set startNumber
set presentationTimeOffset if needed
*Initialization segments:*
No change (actually setting duration to 0, but it should already be 0)
*Media segments:*
Mapped from live number to VoD number and multiplexed if needed
sequenceNumber updated to be continuous (and identical to segment number)
earliest presentation time in tfdt is changed to be continuously grown with start at epoch.
Our basic service is a 24/7 service with no updates to the MPD. To facilitate calculations
we have chosen the epoch time to be the the anchor for calculations. Our default is:
startNumber = 0
availabilityStartTime = epochStart (Jan. 1 1970)
minimumUpdatePeriod = 100Y
period start = PT0s
presentationTimeOffset = 0
The availabilityStartTime tells when the initialization segments are available.
The first segments should be available one segmentDuration later.
The latest available segment number can be then be calculated as
latestSegmentNumber = (now - availabilityStartTime - duration)/duration + startNumber
The server makes sure that segments are only available from their startTime and for a period
corresponding to the timeShiftBufferDepth (the default is 5 min).
The media timeline shall be synchronized with the MPD. Thus, at the start of a period,
the offset of the presentationTime in the media segments should be equal to the period start time or rather
MediaTimeAtPeriodStart = AST + Period@Start - presentationTimeOffset
We fulfill this by having Period@start = 0 and presentationTimeOffset = 0, and relating the media timeline to AST.
However, when periods do not start at AST, we must adjust the presentationTimeOffset to be equal to the Period@start.
Some examples of this are the modifiers:
/periods_0 - one period that starts 1000hours after AST
/periods_n - multiple periods (n per hour)
/periods_0/peroff_1 - one period but presentationTimeOffset signaled in SegmentBase at Period level
/periods_n/peroff_1 - similar to /periods_n but SegmentBase used for presentationTimeOffset
In addition, one can turn on signalling of continuous periods, but adding the flag /continuous_1/`.
## Changelog
2.0.2 - May 17 2022: Fix EventStream/Event (Issue #105 & #109). Update vodanalyzer to Python 3
2.0.1 - May 24 2020: Fixed https detection (Issue #97)
2.0.0 - May 18 2020: Changed to Python3. Integrated low-latencu chunked mode triggered by chunkdur and ato parameters.
1.7.0 - Dec. 12 2019: Added two more UTCTiming modes, new mode
segtimelineloss, query-strings are neglected, possible session time limit and
id via redirect, fixed bug in segmenttimeline wraparound
1.6.0 - Dec. 18, 2018: Support for SegmentTimeline with Number, added suggestedPresentationDelay, propagates default-sample-duration from trex and tfhd, and can now generate sidx boxes.
1.5.1 - June 3, 2018: Fix: Removed timeShiftBufferDepth in start-over case.
1.5 - May 17, 2018: Added support for thumbnails and start-over use case.
* 1.4 - Sep. 29 2016: Added support for SegmentTimeline manifests, xlink periods for ad insertion, ntp and sntp UTC timing, early-terminated periods, availabilityTimeOffset, and MPD callback.
* 1.3 - Oct. 13, 2015: Added support for continuous periods (continuous_1) and https protocol fo`r BaseURL & UTCTiming. Moved some configuration to mod_wsgi. Also made the stand-alone wsgi server much better.
* 1.2 - Aug. 18, 2015: Added support for live subtitles in TTML format. Beyond segment renumbering, the content will also be changed. A tool for generating a sequence of such segments is also provided. Support for choosing the starNr. Added support for running using mod_wsgi and not only mod_python.
* 1.1 - Jun. 2, 2015: Added snr_ option to control startNumber in manifest. Fixed some bugs with availabilityStartTime and PTO._
* 1.0 - May 7, 2015: First public release. Available as http://vm2.dashif.org/livesim/
* - Changed init segment durations to 0.
* 0.9.9 - Apr. 29, 2015: First commit to DASH-IF/live-source-simulator Github project.
The following is the change-log for the code as internal MobiTV code.
* 0.9.5 - Apr. 13, 2015: Support for specifying UTCTiming methods (head or direct)
* 0.9.0 - Mar. 16, 2015: Added option of scte_35 signals 1, 2, or 3 times a minute, by specifying scte35_2 as option.
* - Changed duration in init segment to maxint (only 1's instead of 0) since the duration is unknown for live.
* 0.8.6 - Oct. 14, 2014: Added possibility of multiple periods and period not starting at AST.
* 0.8.5 - Mar. 4, 2014: Add presentationTimeOffset when AST is not start of epoch.
* 0.8.4 - Feb. 18, 2014: Corrected tfdt timing. Can now specify all\_1 as option to avoid timing checks.
* 0.8.3 - Feb. 13, 2014: The 404 responses do now include the a message of why content is not available including timing issues.
* 0.8.2 - Feb. 11, 2014: Fixed bug in BaseURL. Added error_logging for too early and too late segments.
* 0.8.1 - Jan. 28, 2014: Added modulo period
* 0.8.0 - Jan. 27, 2014: Supports multiplexing and aligned with DASH-IF contributed server with some extra functionality
* 0.6.8 - Oct. 30, 2013: One can now set another value for the availabilityStartTime for the bdash server.
* 0.6.7 - Sep. 30, 2013: Bugfixes for old namespace, range and non-existing segments.
* 0.6.6 - Sep. 27, 2013: Configurable to remove publishTime and substitute old namespace
* 0.6.5 - Sep. 20, 2013: Fixed byterange to handle open intervals and return 206.
* 0.6.4 - Sep. 16, 2013: Now uses tfdt for sync and removes sidx.
* 0.6.3 - Aug. 30, 2013: Added support for byte-range requests
* 0.6.2 - Aug. 23, 2013: Added support for additional directory structure for languages
* 0.6.1 - July 23, 2013: Added Z for GMT timezone in all dates in the MPD.
* 0.6 - June 5, 2013: Added support for events and other time-limited sessions.
[testpic_2s_base]: http://vm2.dashif.org/livesim/testpic_2s/Manifest.mpd "Live simulator infinite clock source."
[dashif_player]: http://dashif.org/reference/players/javascript/1.3.0/samples/dash-if-reference-player/index.html?url=http://vm2.dashif.org/livesim/testpic_2s/Manifest.mpd "DASH-IF Reference Player"
================================================
FILE: run_tests.sh
================================================
python3 -m unittest discover
================================================
FILE: setup/dash.conf
================================================
Header set Access-Control-Allow-Headers "origin,range"
Header set Access-Control-Expose-Headers "Server,range, Date"
Header set Access-Control-Allow-Methods "GET, HEAD, OPTIONS"
Header set Access-Control-Allow-Origin "*"
================================================
FILE: setup/installation.mdown
================================================
DASH-IF live source simulator installation
-------------------------------
The DASH live source simulator us using the wsgi HTTP API.
It is recommended to use Apache with mod_wsgi, and that is how the https://livesim.dashif.org server is run.
However, wsgi is cross-platform and should work with nginx as well.
For local testing, it is also possible to run the wsgi server itself by calling the script `tools/run_wsgi_server.sh`.
### Requirements:
Python >= 3.6, Apache2 with mod_wsgi(can also be run without Apache, or with nginx).
### Configuration for server static files (VoD mode)
The VoD content (in live profile) that serves as raw content for live should typically be as maps under
/var/www/html/dash/vod/
The directory is specified as `CONTENT_ROOT` to the simulator.
Example content that can be used for both VoD and live streaming is available as
https://livesim.dashif.org/dash/vod/testpic_2s.tar
https://livesim.dashif.org/dash/vod/testpic4_8s.tar
The main issue for browser players like dash.js is typically CORS.
For serving the VoD files using Apache2 from `/var/www/html/dash/vod` it is recommended to add the file
dash.conf to the Apache2 configuration.
The location depends on distribution, but in CentOS it is `/etc/httpd/conf.d/dash.conf`.
### Setup of simulated live streaming from Apache2 with mod_wsgi
This is the recommended way to run on a public server. For testing, it may easier to run a local server, see below.
How mod_wsgi is installed depends on the Linux distribution.
The mod_wsgi configuration goes into the configuration directory (for CentOS)
/etc/httpd/conf.d/mod_wsgi/dashlivesim.conf
or something similar on other Linux distributions.
As seen in the example file provided in this directory, `VOD_CONF_DIR` and `CONTENT_ROOT` must be set up,
and the source code tree `dashlivesim` must be found by the `WSGIPythonPath` and `WSGIScriptAlias`must point to
`mod_wsgi/mod_dashlivesim.py` must be specified.
To install the actual source code, get it from github and copy the `dashlivesim` directory recursively into
`/usr/local/bin/mod_wsgi/`.
Finally, the configuration files must be installed in `/var/www/html/livesim_vod_configs` or whatever `VOD_CONF_DIR`
points at.
### Setup for a locl wsgi server
To run a local wsgi http server use the script `tools/run_wsgi_server`. The `vod_config` and `content_root` directories need to specified on the command line.
### Configuration of live material
For each simulated live source directory containing manifest files , there must be a configuration
file with the corresponding name .cfg
For example, for testpic_2s there is a file
/testpic_2s.cfg
For files without subtitles, it can be automatically generated by running the tool
tools/run_vodanalyzer.sh
This runs the Python script `dashlivesim.vodanalyzer.dashanalyzer` and produces a file `.cfg`.
You can then edit the file, to include fewer segments, fewer representations, or more representations if there
are other manifests that contain other representations. In particular, all subtitle representations must be added by hand.
The corresponding content resides in
//
In such a directory there should one or more VoD MPDs and associated media files.
Note that the file extensions are critical, but the base names not.
[contentName]
-> [Manifest].mpd
-> [rep1]
-> [init].mp4
-> [seqNr].m4s
-> [rep2]
...
Sample content and configuration can be found at `https://livesim.dashif.org/dash/`.
The configurations can be copied from `https://livesim.dashif.org/dash/vod_configs/`.
### UTCTiming Head mode
For UTCTiming head mode to work, there must be file accessible via http:///dash/time.txt``.
The content is not relevant.
The CORS support for the header Date must be supported.
### Sample content and configurations
Sample content and configuration can be found at `https://livesim.dashif.org/dash/`.
Instead of downloading individual segments, it is recommended to download the `.tar` files when available.
The configurations can be copied from `https://livesim.dashif.org/dash/vod_configs/`.
================================================
FILE: setup/mod_wsgi_dashlivesim.conf
================================================
WSGIScriptAlias /livesim /usr/local/bin/mod_wsgi/dashlivesim/mod_wsgi/mod_dashlivesim.py
WSGIPythonPath /usr/local/bin/mod_wsgi
setEnv VOD_CONF_DIR /var/www/html/dash/vod_configs
setEnv CONTENT_ROOT /var/www/html/dash/vod
================================================
FILE: tools/run_cc_insert.py
================================================
export PYTHONPATH=${PYTHONPATH}:..
python3 -m dashlivesim.cc_inserter.cc_inserter $@
================================================
FILE: tools/run_stpp_generator.sh
================================================
export PYTHONPATH=${PYTHONPATH}:..
python -m dashlivesim.dashlib.stpp_generator.make_stpp_segments $@
================================================
FILE: tools/run_vodanalyzer.sh
================================================
export PYTHONPATH=${PYTHONPATH}:..
python3 -m dashlivesim.vodanalyzer.dashanalyzer $1
================================================
FILE: tools/run_wsgi_server.sh
================================================
# Run a local mod_wsgi server
export PYTHONPATH=${PYTHONPATH}:..
python3 -m dashlivesim.mod_wsgi.mod_dashlivesim $*