From cf38e94401354c102ffc77c8e44008b05e77f993 Mon Sep 17 00:00:00 2001
From: Zachary Cava <technogeek00@gmail.com>
Date: Sat, 2 Nov 2019 00:20:02 -0700
Subject: [PATCH 1/6] First pass at bringing in patch mode behavior

This introduces a new parameter "patching" which can be set to
"/patching_1" in the url which will enable patch playout mode for the
dynamic MPD.

During patch playout mode the MPD will contain a PatchLocation element
that points back to the server with an additional "/patch_<time>/"
reference to signify the last information given to the client.

When the client follows the PatchLocation URI it will receive a Patch
response that is applied to the existing in-memory MPD to create the
full form MPD at the original location.

Current pieces needing further investigation:
- Segment update consistency, unclear if we have overlap
- Empty segment timeline on join, periods with an empty segment timeline
should be omitted and included on the next update
---
 dashlivesim/dashlib/configprocessor.py |  14 +-
 dashlivesim/dashlib/dash_namespace.py  |   7 +-
 dashlivesim/dashlib/dash_proxy.py      |  14 +-
 dashlivesim/dashlib/mpdprocessor.py    | 302 +++++++++++++++++--------
 dashlivesim/dashlib/patch_ops.py       |  21 ++
 5 files changed, 255 insertions(+), 103 deletions(-)
 create mode 100644 dashlivesim/dashlib/patch_ops.py

diff --git a/dashlivesim/dashlib/configprocessor.py b/dashlivesim/dashlib/configprocessor.py
index 77ce480..ec453f0 100644
--- a/dashlivesim/dashlib/configprocessor.py
+++ b/dashlivesim/dashlib/configprocessor.py
@@ -107,6 +107,8 @@ def __init__(self, vod_cfg_dir, base_url=None):
         self.insert_sidx = False
         self.segtimelineloss= False #This flag is true only when there is /segtimelineloss_1/
         self.emsg_last_seg=False
+        self.patching = False # This flag is only true when there is /patching_1/ in the URL
+        self.patch_base = -1
 
     def __str__(self):
         lines = ["%s=%s" % (k, v) for (k, v) in self.__dict__.items() if not k.startswith("_")]
@@ -341,7 +343,7 @@ class ConfigProcessor(object):
                     "insertad", "mpdcallback", "continuous", "segtimeline",
                     "segtimelinenr", "baseurl", "peroff", "scte35", "utc",
                     "snr", "ato", "spd", "sidx", "segtimelineloss",
-                    "sts", "sid")
+                    "sts", "sid", "patching", "patch")
 
     def __init__(self, vod_cfg_dir, base_url):
         self.vod_cfg_dir = vod_cfg_dir
@@ -374,7 +376,9 @@ def get_mpd_data(self):
                'periodOffset' : self.cfg.period_offset,
                'publishTime' : self.cfg.publish_time,
                'mediaData' : self.cfg.media_data,
-               'segtimelineloss'  : self.cfg.segtimelineloss}
+               'segtimelineloss'  : self.cfg.segtimelineloss,
+               'patching': self.cfg.patching,
+               'originalPublishTime': self.cfg.patch_base}
         if self.cfg.availability_end_time:
             mpd['availabilityEndTime'] = self.cfg.availability_end_time
         return mpd
@@ -478,6 +482,12 @@ def process_url(self, url_parts, now_int=0):
             elif key == "segtimelineloss":  # If segment timeline loss case signalled.
                 if int(value) == 1:
                     cfg.segtimelineloss = True
+            elif key == "patching":
+                if int(value) == 1: # Only valid when it's set to 1
+                    cfg.patching = True
+            elif key == "patch":
+                cfg.patch_base = int(value)
+                cfg.patching = True # patch base will imply patching
             else:
                 raise ConfigProcessorError("Cannot interpret option %s properly" % key)
             url_pos += 1
diff --git a/dashlivesim/dashlib/dash_namespace.py b/dashlivesim/dashlib/dash_namespace.py
index a1e0288..eaa70f6 100644
--- a/dashlivesim/dashlib/dash_namespace.py
+++ b/dashlivesim/dashlib/dash_namespace.py
@@ -32,9 +32,14 @@
 
 RE_NAMESPACE_TAG = re.compile(r"({.*})?(.*)")
 DASH_NAMESPACE = "{urn:mpeg:dash:schema:mpd:2011}"
-
+DASH_PATCH_NAMESPACE = "{urn:mpeg:dash:schema:mpd-patch:2020}"
 
 def add_ns(element):
     "Add DASH namespace to element or to path."
     parts = element.split('/')
     return "/".join([DASH_NAMESPACE + e for e in parts])
+
+def add_patch_ns(element):
+    """Add Patch namespace to element or to path."""
+    parts = element.split('/')
+    return "/".join([DASH_PATCH_NAMESPACE + e for e in parts])
diff --git a/dashlivesim/dashlib/dash_proxy.py b/dashlivesim/dashlib/dash_proxy.py
index 5674233..11481c6 100644
--- a/dashlivesim/dashlib/dash_proxy.py
+++ b/dashlivesim/dashlib/dash_proxy.py
@@ -360,6 +360,14 @@ def parse_url(self):
             if nr_xlink_periods_per_hour > 0:
                 response = generate_response_with_xlink(response, cfg.ext, cfg.filename, nr_periods_per_hour,
                                                         nr_xlink_periods_per_hour, mpd_input_data['insertAd'])
+
+        # Manifest patch update, separate out here as the xlink logic is unsafe in assuming all periods will
+        # be present in response to perform the replacement
+        elif cfg.ext == ".patch":
+            mpd_filename = "%s/%s/%s.mpd" % (self.content_dir, cfg.content_name, cfg.filename.split('.')[0])
+            mpd_input_data = cfg_processor.get_mpd_data()
+            response = self.generate_dynamic_mpd(cfg, mpd_filename, mpd_input_data, self.now)
+
         elif cfg.ext == ".mp4":  # Init segment
             if self.now < cfg.availability_start_time_in_s - cfg.init_seg_avail_offset:
                 diff = (cfg.availability_start_time_in_s - cfg.init_seg_avail_offset) - self.now_float
@@ -443,11 +451,13 @@ def generate_dynamic_mpd(self, cfg, mpd_filename, in_data, now):
                         'continuous': in_data['continuous'],
                         'segtimeline': in_data['segtimeline'],
                         'segtimeline_nr': in_data['segtimeline_nr'],
+                        'patching': in_data['patching'],
                         'utc_timing_methods': cfg.utc_timing_methods,
                         'utc_head_url': self.utc_head_url,
-                        'now': now}
+                        'now': now,
+                        'patch_base': cfg.patch_base}
         full_url = self.base_url + '/'.join(self.url_parts)
-        mpmod = mpdprocessor.MpdProcessor(mpd_filename, mpd_proc_cfg, cfg,
+        mpmod = mpdprocessor.MpdProcessor(mpd_filename, mpd_proc_cfg, cfg, 
                                           full_url)
         period_data = generate_period_data(mpd_data, now, cfg)
         mpmod.process(mpd_data, period_data)
diff --git a/dashlivesim/dashlib/mpdprocessor.py b/dashlivesim/dashlib/mpdprocessor.py
index 2f011df..d9eeb4d 100644
--- a/dashlivesim/dashlib/mpdprocessor.py
+++ b/dashlivesim/dashlib/mpdprocessor.py
@@ -38,7 +38,8 @@
 from timeformatconversions import make_timestamp
 import scte35
 from segtimeline import SegmentTimeLineGenerator
-from dash_namespace import add_ns
+from dash_namespace import add_ns, add_patch_ns
+import patch_ops
 
 SET_BASEURL = True
 
@@ -58,6 +59,13 @@ def set_values_from_dict(element, keys, data):
         if data.has_key(key):
             element.set(key, str(data[key]))
 
+def find_template_period(mpd, pos=0):
+    children = mpd.getchildren()
+    for ch_nr in range(pos, len(children)):
+        if children[ch_nr].tag == add_ns("Period"):
+            return (mpd.getchildren()[ch_nr], ch_nr)
+
+    raise MpdModifierError("No period found.")
 
 class MpdModifierError(Exception):
     "Generic MpdModifier error."
@@ -76,6 +84,8 @@ def __init__(self, infile, mpd_proc_cfg, cfg=None, full_url=None):
         self.continuous = mpd_proc_cfg['continuous']
         self.segtimeline = mpd_proc_cfg['segtimeline']
         self.segtimeline_nr = mpd_proc_cfg['segtimeline_nr']
+        self.patching = mpd_proc_cfg['patching']
+        self.patch_base = mpd_proc_cfg['patch_base']
         self.mpd_proc_cfg = mpd_proc_cfg
         self.cfg = cfg
         self.full_url = full_url
@@ -89,8 +99,21 @@ def process(self, mpd_data, period_data):
         mpd = self.root
         self.availability_start_time_in_s = mpd_data[
             'availability_start_time_in_s']
-        self.process_mpd(mpd, mpd_data)
-        self.process_mpd_children(mpd, mpd_data, period_data)
+
+        if self.patching:
+            # when patching we avoid announcing future periods, filter them out
+            period_data = list(filter(lambda pdata: pdata['presentationTimeOffset'] <= self.mpd_proc_cfg['now'], period_data))
+
+        if self.patch_base == -1:
+            # generate full manifest if patch base absent
+            self.process_mpd(mpd, mpd_data)
+            self.process_mpd_children(mpd, mpd_data, period_data)
+        else:
+            # replace existing manifest with patch
+            patch = ElementTree.Element(add_patch_ns('Patch'))
+            self.tree = ElementTree.ElementTree(patch)
+            self.root = self.tree.getroot()
+            self.process_patch(patch, mpd, mpd_data, period_data)
 
     def process_mpd(self, mpd, mpd_data):
         """Process the root element (MPD)"""
@@ -125,7 +148,6 @@ def process_mpd(self, mpd, mpd_data):
             if mpd_data.get('type', 'dynamic') != 'static':
                 mpd.set('minimumUpdatePeriod', "PT0S")
 
-
     #pylint: disable = too-many-branches
     def process_mpd_children(self, mpd, data, period_data):
         """Process the children of the MPD element.
@@ -179,19 +201,91 @@ def process_mpd_children(self, mpd, data, period_data):
             self.insert_location(mpd, pos, loc_url)
             pos += 1
 
-        children = mpd.getchildren()
-        for ch_nr in range(pos, len(children)):
-            if children[ch_nr].tag == add_ns("Period"):
-                period = mpd.getchildren()[pos]
-                pos = ch_nr
-                break
-        else:
-            raise MpdModifierError("No period found.")
+        if self.patching:
+            # replace the original patching key with the in-memory manifest publish time
+            patch_url = re.sub(r"/patching_[-\d]+", "/patch_%d" % 
+                               self.mpd_proc_cfg['now'], self.full_url)
+            # also change the extension type to be patch instead of mpd
+            patch_url = re.sub(r"\.mpd$", ".patch", patch_url)
+            self.insert_patch_location(mpd, pos, patch_url)
+            pos += 1
+
+        (period, pos) = find_template_period(mpd, pos)
+
         for i in range(1, len(period_data)):
             new_period = copy.deepcopy(period)
             mpd.insert(pos+i, new_period)
         self.insert_utc_timings(mpd, pos+len(period_data))
-        self.update_periods(mpd, period_data, data['periodOffset'] >= 0)
+
+        periods = mpd.findall(add_ns('Period'))
+        last_period_id = '-1'
+        segtimeline_generators = self.create_timeline_generators()
+        for (period, pdata) in zip(periods, period_data):
+            self.update_period(mpd, period, pdata, last_period_id, data['periodOffset'] >= 0, segtimeline_generators)
+            last_period_id = pdata.get('id')
+
+    def process_patch(self, patch, mpd, mpd_data, period_data):
+        """Process the root element (Patch)"""
+        patch.set('mpdId', mpd.get('id', 'Config part of url maybe?'))
+        patch.set('publishTime', make_timestamp(self.mpd_proc_cfg['now']))
+        patch.set('originalPublishTime', make_timestamp(self.patch_base))
+
+        # Insert publish time update node
+        publish_replace = patch_ops.insert_replace_op(patch, '/MPD/@publishTime')
+        publish_replace.text = make_timestamp(self.mpd_proc_cfg['now'])
+
+        # Insert patch location update node
+        patch_location = re.sub(r"/patch_[-\d]+", "/patch_%d" % 
+                                self.mpd_proc_cfg['now'], self.full_url)
+        patch_replace = patch_ops.insert_replace_op(patch, '/MPD/PatchLocation[1]')
+        self.insert_patch_location(patch_replace, 0, patch_location)
+
+        # For this simulator we assume patches will not be announcing new high level structures
+        # it is completely possible for them to do that, but this simulator only needs basic
+        # timeline extension ability
+        
+        # Find the base period
+        (original_period, _) = find_template_period(mpd)
+
+        # Go through periods defined for update:
+        # - Periods before the patch base that have new segments have the segments patched in
+        # - Periods after the patch base are completely added
+
+        segtimeline_generators = self.create_timeline_generators()
+        last_period_id = '-1'
+        for pdata in period_data:
+            if pdata.get('presentationTimeOffset') > self.patch_base:
+                # Period is new with this patch, clone original, setup like normal
+                period = copy.deepcopy(original_period)
+                self.update_period(mpd, period, pdata, last_period_id, mpd_data['periodOffset'] >= 0, segtimeline_generators)
+
+                # create the actual insertion operation
+                period_add = patch_ops.insert_add_op(patch, '/MPD')
+                period_add.append(period)
+
+            elif segtimeline_generators:
+                # Period already exists in memory and we use segment timeline
+                # We therefore have to generate extensions to the inmemory timeline
+                # Note only one previous period should ever be added to, not gating on that explicitly here
+                adaptation_sets = original_period.findall(add_ns('AdaptationSet'))
+                for ad_set in adaptation_sets:
+                    content_type = ad_set.get('contentType')
+                    segtime_gen = segtimeline_generators[content_type]
+                    seg_templates = ad_set.findall(add_ns('SegmentTemplate'))
+                    for seg_template in seg_templates:
+                        (start_time, end_time, use_closest) = self.compute_period_times(pdata)
+                        start_time = self.patch_base # always force start to patch base for consistency
+                        seg_timeline = segtime_gen.create_segtimeline(
+                                            start_time, end_time, use_closest)
+                        
+                        # only append if there are children
+                        s_elems = seg_timeline.getchildren()
+                        if len(s_elems) > 0:
+                            timeline_location = "/MPD/Period[@id='%s']/AdaptationSet[@id='%s']/SegmentTemplate/SegmentTimeline" % (pdata.get('id'), ad_set.get('id'))
+                            timeline_add = patch_ops.insert_add_op(patch, timeline_location)
+                            timeline_add.extend(s_elems)
+
+            last_period_id = pdata.get('id')
 
     def insert_baseurl(self, mpd, pos, new_baseurl, new_ato):
         "Create and insert a new <BaseURL> element."
@@ -218,8 +312,15 @@ def insert_location(self, mpd, pos, location_url):
         location_elem.tail = "\n"
         mpd.insert(pos, location_elem)
 
+    def insert_patch_location(self, mpd, pos, patch_location_url):
+        patch_location_elem = ElementTree.Element(add_ns('PatchLocation'))
+        patch_location_elem.text = patch_location_url
+        patch_location_elem.tail = "\n"
+        patch_location_elem.set('ttl', str(60)) # todo config patch validity duration
+        mpd.insert(pos, patch_location_elem)
+
     #pylint: disable = too-many-statements
-    def update_periods(self, mpd, period_data, offset_at_period_level=False):
+    def update_period(self, mpd, period, pdata, last_period_id, offset_at_period_level=False, segtimeline_generators=None):
         "Update periods to provide appropriate values."
 
         def set_attribs(elem, keys, data):
@@ -257,97 +358,93 @@ def create_inline_mpdcallback_elem(BaseURLSegmented):
             "Create an EventStream element for MPD Callback."
             return self.create_descriptor_elem("EventStream", "urn:mpeg:dash:event:callback:2015", value=str(1),
                                                elem_id=None, messageData=BaseURLSegmented)
-        if self.segtimeline or self.segtimeline_nr:
-            segtimeline_generators = {}
-            for content_type in ('video', 'audio'):
-                segtimeline_generators[content_type] = SegmentTimeLineGenerator(self.cfg.media_data[content_type],
-                                                                                self.cfg)
-        periods = mpd.findall(add_ns('Period'))
         BaseURL = mpd.findall(add_ns('BaseURL'))
         if len(BaseURL) > 0:
             BaseURLParts = BaseURL[0].text.split('/')
             if len(BaseURLParts) > 3:
                 BaseURLSegmented = BaseURLParts[0] + '//' + BaseURLParts[2] + '/' + BaseURLParts[3] + '/mpdcallback/'
-        # From the Base URL
-        last_period_id = '-1'
-        for (period, pdata) in zip(periods, period_data):
-            set_attribs(period, ('id', 'start'), pdata)
-            if pdata.has_key('etpDuration'):
-                period.set('duration', "PT%dS" % pdata['etpDuration'])
-            if pdata.has_key('periodDuration'):
-                period.set('duration', pdata['periodDuration'])
-            segmenttemplate_attribs = ['startNumber']
-            pto = pdata['presentationTimeOffset']
-            if pto:
-                if offset_at_period_level:
-                    insert_segmentbase(period, pto)
-                else:
-                    segmenttemplate_attribs.append('presentationTimeOffset')
-            if pdata.has_key('mpdCallback'):
-                # Add the mpdCallback element only if the flag is raised.
-                mpdcallback_elem = create_inline_mpdcallback_elem(BaseURLSegmented)
-                period.insert(0, mpdcallback_elem)
-            adaptation_sets = period.findall(add_ns('AdaptationSet'))
-            for ad_set in adaptation_sets:
-                ad_pos = 0
-                content_type = ad_set.get('contentType')
-                if self.emsg_last_seg:
-                    inband_event_elem = create_inband_stream_elem()
-                    ad_set.insert(0, inband_event_elem)
-                if content_type == 'video' and self.scte35_present:
-                    scte35_elem = create_inband_scte35stream_elem()
-                    ad_set.insert(0, scte35_elem)
-                    ad_pos += 1
-                if self.continuous and last_period_id != '-1':
-                    supplementalprop_elem = self.create_descriptor_elem("SupplementalProperty", \
-                    "urn:mpeg:dash:period_continuity:2014", last_period_id)
-                    ad_set.insert(ad_pos, supplementalprop_elem)
-                seg_templates = ad_set.findall(add_ns('SegmentTemplate'))
-                for seg_template in seg_templates:
-                    set_attribs(seg_template, segmenttemplate_attribs, pdata)
-                    if pdata.get('startNumber') == '-1': # Default to 1
+
+        set_attribs(period, ('id', 'start'), pdata)
+        if pdata.has_key('etpDuration'):
+            period.set('duration', "PT%dS" % pdata['etpDuration'])
+        if pdata.has_key('periodDuration'):
+            period.set('duration', pdata['periodDuration'])
+        segmenttemplate_attribs = ['startNumber']
+        pto = pdata['presentationTimeOffset']
+        if pto:
+            if offset_at_period_level:
+                insert_segmentbase(period, pto)
+            else:
+                segmenttemplate_attribs.append('presentationTimeOffset')
+        if pdata.has_key('mpdCallback'):
+            # Add the mpdCallback element only if the flag is raised.
+            mpdcallback_elem = create_inline_mpdcallback_elem(BaseURLSegmented)
+            period.insert(0, mpdcallback_elem)
+        adaptation_sets = period.findall(add_ns('AdaptationSet'))
+        for ad_set in adaptation_sets:
+            ad_pos = 0
+            content_type = ad_set.get('contentType')
+            if self.emsg_last_seg:
+                inband_event_elem = create_inband_stream_elem()
+                ad_set.insert(0, inband_event_elem)
+            if content_type == 'video' and self.scte35_present:
+                scte35_elem = create_inband_scte35stream_elem()
+                ad_set.insert(0, scte35_elem)
+                ad_pos += 1
+            if self.continuous and last_period_id != '-1':
+                supplementalprop_elem = self.create_descriptor_elem("SupplementalProperty", \
+                "urn:mpeg:dash:period_continuity:2014", last_period_id)
+                ad_set.insert(ad_pos, supplementalprop_elem)
+            seg_templates = ad_set.findall(add_ns('SegmentTemplate'))
+            for seg_template in seg_templates:
+                set_attribs(seg_template, segmenttemplate_attribs, pdata)
+                if pdata.get('startNumber') == '-1': # Default to 1
+                    remove_attribs(seg_template, ['startNumber'])
+
+                if (self.segtimeline or self.segtimeline_nr) and segtimeline_generators:
+                    # add SegmentTimeline block in SegmentTemplate with timescale and window.
+                    segtime_gen = segtimeline_generators[content_type]
+                    (start_time, end_time, use_closest) = self.compute_period_times(pdata)
+                    seg_timeline = segtime_gen.create_segtimeline(
+                                        start_time, end_time, use_closest)
+                    remove_attribs(seg_template, ['duration'])
+                    seg_template.set('timescale', str(self.cfg.media_data[content_type]['timescale']))
+                    if pto != "0" and not offset_at_period_level:
+                        # rescale presentationTimeOffset based on the local timescale
+                        seg_template.set('presentationTimeOffset',
+                                         str(int(pto) * int(self.cfg.media_data[content_type]['timescale'])))
+                    media_template = seg_template.attrib['media']
+                    if self.segtimeline:
+                        media_template = media_template.replace('$Number$', 't$Time$')
                         remove_attribs(seg_template, ['startNumber'])
+                    elif self.segtimeline_nr:
+                        # Set number to the first number listed
+                        set_attribs(seg_template,
+                                    ('startNumber',),
+                                    {'startNumber': segtime_gen.start_number})
+
+                    seg_template.set('media', media_template)
+                    seg_template.text = "\n"
+                    seg_template.insert(0, seg_timeline)
+
+    def compute_period_times(self, pdata):
+        now = self.mpd_proc_cfg['now']
+        tsbd = self.cfg.timeshift_buffer_depth_in_s
+        ast = self.cfg.availability_start_time_in_s
+        start_time = max(ast + pdata['start_s'], now - tsbd)
+        if pdata.has_key('period_duration_s'):
+            end_time = min(ast + pdata['start_s'] + pdata['period_duration_s'], now)
+        else:
+            end_time = now
+        start_time -= self.cfg.availability_start_time_in_s
+        end_time -= self.cfg.availability_start_time_in_s
+        use_closest = False
+        if self.cfg.stop_time and self.cfg.timeoffset == 0:
+            start_time = self.cfg.start_time
+            end_time = min(now, self.cfg.stop_time)
+            use_closest = True
 
-                    if self.segtimeline or self.segtimeline_nr:
-                        # add SegmentTimeline block in SegmentTemplate with timescale and window.
-                        segtime_gen = segtimeline_generators[content_type]
-                        now = self.mpd_proc_cfg['now']
-                        tsbd = self.cfg.timeshift_buffer_depth_in_s
-                        ast = self.cfg.availability_start_time_in_s
-                        start_time = max(ast + pdata['start_s'], now - tsbd)
-                        if pdata.has_key('period_duration_s'):
-                            end_time = min(ast + pdata['start_s'] + pdata['period_duration_s'], now)
-                        else:
-                            end_time = now
-                        start_time -= self.cfg.availability_start_time_in_s
-                        end_time -= self.cfg.availability_start_time_in_s
-                        use_closest = False
-                        if self.cfg.stop_time and self.cfg.timeoffset == 0:
-                            start_time = self.cfg.start_time
-                            end_time = min(now, self.cfg.stop_time)
-                            use_closest = True
-                        seg_timeline = segtime_gen.create_segtimeline(
-                            start_time, end_time, use_closest)
-                        remove_attribs(seg_template, ['duration'])
-                        seg_template.set('timescale', str(self.cfg.media_data[content_type]['timescale']))
-                        if pto != "0" and not offset_at_period_level:
-                            # rescale presentationTimeOffset based on the local timescale
-                            seg_template.set('presentationTimeOffset',
-                                             str(int(pto) * int(self.cfg.media_data[content_type]['timescale'])))
-                        media_template = seg_template.attrib['media']
-                        if self.segtimeline:
-                            media_template = media_template.replace('$Number$', 't$Time$')
-                            remove_attribs(seg_template, ['startNumber'])
-                        elif self.segtimeline_nr:
-                            # Set number to the first number listed
-                            set_attribs(seg_template,
-                                        ('startNumber',),
-                                        {'startNumber': segtime_gen.start_number})
-
-                        seg_template.set('media', media_template)
-                        seg_template.text = "\n"
-                        seg_template.insert(0, seg_timeline)
-            last_period_id = pdata.get('id')
+        return (start_time, end_time, use_closest)
 
     def create_descriptor_elem(self, name, scheme_id_uri, value=None, elem_id=None, messageData=None):
         "Create an element of DescriptorType."
@@ -362,6 +459,15 @@ def create_descriptor_elem(self, name, scheme_id_uri, value=None, elem_id=None,
         elem.tail = "\n"
         return elem
 
+    def create_timeline_generators(self):
+        segtimeline_generators = None
+        if self.segtimeline or self.segtimeline_nr:
+            segtimeline_generators = {}
+            for content_type in ('video', 'audio'):
+                segtimeline_generators[content_type] = SegmentTimeLineGenerator(self.cfg.media_data[content_type],
+                                                                                self.cfg)
+        return segtimeline_generators
+
     def insert_utc_timings(self, mpd, start_pos):
         """Insert UTCTiming elements right after program information in order given by self.utc_timing_methods.
 
diff --git a/dashlivesim/dashlib/patch_ops.py b/dashlivesim/dashlib/patch_ops.py
new file mode 100644
index 0000000..3eec65c
--- /dev/null
+++ b/dashlivesim/dashlib/patch_ops.py
@@ -0,0 +1,21 @@
+from xml.etree import ElementTree
+PATCH_OP_NAMESPACE = "{urn:ietf:params:xml:schema:patch-ops}"
+
+def add_ns(element):
+    parts = element.split('/')
+    return "/".join([PATCH_OP_NAMESPACE + e for e in parts])
+
+def insert_replace_op(target, selector):
+    replace_elem = ElementTree.Element(add_ns('replace'))
+    replace_elem.tail = "\n"
+    replace_elem.set('sel', selector)
+    target.append(replace_elem)
+    return replace_elem
+
+def insert_add_op(target, selector, pos="after"):
+    add_elem = ElementTree.Element(add_ns('add'))
+    add_elem.tail = "\n"
+    add_elem.set('sel', selector)
+    add_elem.set('pos', pos)
+    target.append(add_elem)
+    return add_elem
\ No newline at end of file

From 71aaa502055752eeb3bf1844842ae1986f720b70 Mon Sep 17 00:00:00 2001
From: Zachary Cava <technogeek00@gmail.com>
Date: Fri, 8 Nov 2019 23:21:34 -0800
Subject: [PATCH 2/6] Use 'append' instead of 'after' for additions,
 PatchLocation should match first instance

---
 dashlivesim/dashlib/mpdprocessor.py | 6 +++---
 dashlivesim/dashlib/patch_ops.py    | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/dashlivesim/dashlib/mpdprocessor.py b/dashlivesim/dashlib/mpdprocessor.py
index d9eeb4d..491eee2 100644
--- a/dashlivesim/dashlib/mpdprocessor.py
+++ b/dashlivesim/dashlib/mpdprocessor.py
@@ -237,7 +237,7 @@ def process_patch(self, patch, mpd, mpd_data, period_data):
         # Insert patch location update node
         patch_location = re.sub(r"/patch_[-\d]+", "/patch_%d" % 
                                 self.mpd_proc_cfg['now'], self.full_url)
-        patch_replace = patch_ops.insert_replace_op(patch, '/MPD/PatchLocation[1]')
+        patch_replace = patch_ops.insert_replace_op(patch, '/MPD/PatchLocation[0]')
         self.insert_patch_location(patch_replace, 0, patch_location)
 
         # For this simulator we assume patches will not be announcing new high level structures
@@ -260,7 +260,7 @@ def process_patch(self, patch, mpd, mpd_data, period_data):
                 self.update_period(mpd, period, pdata, last_period_id, mpd_data['periodOffset'] >= 0, segtimeline_generators)
 
                 # create the actual insertion operation
-                period_add = patch_ops.insert_add_op(patch, '/MPD')
+                period_add = patch_ops.insert_add_op(patch, '/MPD', 'append')
                 period_add.append(period)
 
             elif segtimeline_generators:
@@ -282,7 +282,7 @@ def process_patch(self, patch, mpd, mpd_data, period_data):
                         s_elems = seg_timeline.getchildren()
                         if len(s_elems) > 0:
                             timeline_location = "/MPD/Period[@id='%s']/AdaptationSet[@id='%s']/SegmentTemplate/SegmentTimeline" % (pdata.get('id'), ad_set.get('id'))
-                            timeline_add = patch_ops.insert_add_op(patch, timeline_location)
+                            timeline_add = patch_ops.insert_add_op(patch, timeline_location, 'append')
                             timeline_add.extend(s_elems)
 
             last_period_id = pdata.get('id')
diff --git a/dashlivesim/dashlib/patch_ops.py b/dashlivesim/dashlib/patch_ops.py
index 3eec65c..e7a43e2 100644
--- a/dashlivesim/dashlib/patch_ops.py
+++ b/dashlivesim/dashlib/patch_ops.py
@@ -12,7 +12,7 @@ def insert_replace_op(target, selector):
     target.append(replace_elem)
     return replace_elem
 
-def insert_add_op(target, selector, pos="after"):
+def insert_add_op(target, selector, pos):
     add_elem = ElementTree.Element(add_ns('add'))
     add_elem.tail = "\n"
     add_elem.set('sel', selector)

From d310ecf01cbaaf4e5137dd2a6c4e6b5300c2bdab Mon Sep 17 00:00:00 2001
From: Zachary Cava <technogeek00@gmail.com>
Date: Thu, 5 Dec 2019 21:33:01 -0800
Subject: [PATCH 3/6] Set patch ttl relative to minimum update period

---
 dashlivesim/dashlib/dash_proxy.py   | 13 ++++++++++---
 dashlivesim/dashlib/mpdprocessor.py | 22 +++++++++++-----------
 2 files changed, 21 insertions(+), 14 deletions(-)

diff --git a/dashlivesim/dashlib/dash_proxy.py b/dashlivesim/dashlib/dash_proxy.py
index 11481c6..2b27d1d 100644
--- a/dashlivesim/dashlib/dash_proxy.py
+++ b/dashlivesim/dashlib/dash_proxy.py
@@ -75,8 +75,10 @@
 
 SECS_IN_DAY = 24 * 3600
 DEFAULT_MINIMUM_UPDATE_PERIOD = "P100Y"
+DEFAULT_MINIMUM_UPDATE_PERIOD_IN_S = SECS_IN_DAY * 365 * 100
 DEFAULT_PUBLISH_ADVANCE_IN_S = 7200
 EXTRA_TIME_AFTER_END_IN_S = 60
+PATCHING_MAXIMUM_UPDATE_LATENCY = 10
 
 UTC_HEAD_PATH = "dash/time.txt"
 
@@ -356,7 +358,7 @@ def parse_url(self):
                                 cfg.emsg_last_seg=True
                                 response = self.generate_dynamic_mpd(cfg, mpd_filename, mpd_input_data, self.now)
                                 cfg.emsg_last_seg=False
-                           
+
             if nr_xlink_periods_per_hour > 0:
                 response = generate_response_with_xlink(response, cfg.ext, cfg.filename, nr_periods_per_hour,
                                                         nr_xlink_periods_per_hour, mpd_input_data['insertAd'])
@@ -424,10 +426,14 @@ def generate_dynamic_mpd(self, cfg, mpd_filename, in_data, now):
         mpd_data = in_data.copy()
         if cfg.minimum_update_period_in_s is not None:
             mpd_data['minimumUpdatePeriod'] = seconds_to_iso_duration(cfg.minimum_update_period_in_s)
+            minimum_update_period_in_s = cfg.minimum_update_period_in_s
         else:
             mpd_data['minimumUpdatePeriod'] = DEFAULT_MINIMUM_UPDATE_PERIOD
+            minimum_update_period_in_s = DEFAULT_MINIMUM_UPDATE_PERIOD_IN_S
+
         if cfg.media_presentation_duration is not None:
             mpd_data['mediaPresentationDuration'] = seconds_to_iso_duration(cfg.media_presentation_duration)
+        mpd_data['id'] = cfg.content_name # default in case content has none, required for patching
         mpd_data['timeShiftBufferDepth'] = seconds_to_iso_duration(cfg.timeshift_buffer_depth_in_s)
         mpd_data['timeShiftBufferDepthInS'] = cfg.timeshift_buffer_depth_in_s
         mpd_data['startNumber'] = cfg.adjusted_start_number
@@ -455,9 +461,10 @@ def generate_dynamic_mpd(self, cfg, mpd_filename, in_data, now):
                         'utc_timing_methods': cfg.utc_timing_methods,
                         'utc_head_url': self.utc_head_url,
                         'now': now,
-                        'patch_base': cfg.patch_base}
+                        'patch_base': cfg.patch_base,
+                        'patch_ttl': minimum_update_period_in_s * PATCHING_MAXIMUM_UPDATE_LATENCY}
         full_url = self.base_url + '/'.join(self.url_parts)
-        mpmod = mpdprocessor.MpdProcessor(mpd_filename, mpd_proc_cfg, cfg, 
+        mpmod = mpdprocessor.MpdProcessor(mpd_filename, mpd_proc_cfg, cfg,
                                           full_url)
         period_data = generate_period_data(mpd_data, now, cfg)
         mpmod.process(mpd_data, period_data)
diff --git a/dashlivesim/dashlib/mpdprocessor.py b/dashlivesim/dashlib/mpdprocessor.py
index 491eee2..ffa3aa8 100644
--- a/dashlivesim/dashlib/mpdprocessor.py
+++ b/dashlivesim/dashlib/mpdprocessor.py
@@ -141,7 +141,7 @@ def process_mpd(self, mpd, mpd_data):
         if mpd.attrib.has_key('mediaPresentationDuration') and not mpd_data.has_key('mediaPresentationDuration'):
             del mpd.attrib['mediaPresentationDuration']
         mpd.set('publishTime', make_timestamp(self.mpd_proc_cfg['now'])) #TODO Correlate time with change in MPD
-        mpd.set('id', 'Config part of url maybe?')
+        mpd.set('id', mpd.get('id', mpd_data.get('id')))
         if self.segtimeline or self.segtimeline_nr:
             if mpd.attrib.has_key('maxSegmentDuration'):
                 del mpd.attrib['maxSegmentDuration']
@@ -203,11 +203,11 @@ def process_mpd_children(self, mpd, data, period_data):
 
         if self.patching:
             # replace the original patching key with the in-memory manifest publish time
-            patch_url = re.sub(r"/patching_[-\d]+", "/patch_%d" % 
+            patch_url = re.sub(r"/patching_[-\d]+", "/patch_%d" %
                                self.mpd_proc_cfg['now'], self.full_url)
             # also change the extension type to be patch instead of mpd
             patch_url = re.sub(r"\.mpd$", ".patch", patch_url)
-            self.insert_patch_location(mpd, pos, patch_url)
+            self.insert_patch_location(mpd, pos, patch_url, self.mpd_proc_cfg['patch_ttl'])
             pos += 1
 
         (period, pos) = find_template_period(mpd, pos)
@@ -226,7 +226,7 @@ def process_mpd_children(self, mpd, data, period_data):
 
     def process_patch(self, patch, mpd, mpd_data, period_data):
         """Process the root element (Patch)"""
-        patch.set('mpdId', mpd.get('id', 'Config part of url maybe?'))
+        patch.set('mpdId', mpd.get('id', mpd_data.get('id')))
         patch.set('publishTime', make_timestamp(self.mpd_proc_cfg['now']))
         patch.set('originalPublishTime', make_timestamp(self.patch_base))
 
@@ -235,15 +235,15 @@ def process_patch(self, patch, mpd, mpd_data, period_data):
         publish_replace.text = make_timestamp(self.mpd_proc_cfg['now'])
 
         # Insert patch location update node
-        patch_location = re.sub(r"/patch_[-\d]+", "/patch_%d" % 
+        patch_location = re.sub(r"/patch_[-\d]+", "/patch_%d" %
                                 self.mpd_proc_cfg['now'], self.full_url)
         patch_replace = patch_ops.insert_replace_op(patch, '/MPD/PatchLocation[0]')
-        self.insert_patch_location(patch_replace, 0, patch_location)
+        self.insert_patch_location(patch_replace, 0, patch_location, self.mpd_proc_cfg['patch_ttl'])
 
         # For this simulator we assume patches will not be announcing new high level structures
         # it is completely possible for them to do that, but this simulator only needs basic
         # timeline extension ability
-        
+
         # Find the base period
         (original_period, _) = find_template_period(mpd)
 
@@ -277,7 +277,7 @@ def process_patch(self, patch, mpd, mpd_data, period_data):
                         start_time = self.patch_base # always force start to patch base for consistency
                         seg_timeline = segtime_gen.create_segtimeline(
                                             start_time, end_time, use_closest)
-                        
+
                         # only append if there are children
                         s_elems = seg_timeline.getchildren()
                         if len(s_elems) > 0:
@@ -312,11 +312,11 @@ def insert_location(self, mpd, pos, location_url):
         location_elem.tail = "\n"
         mpd.insert(pos, location_elem)
 
-    def insert_patch_location(self, mpd, pos, patch_location_url):
+    def insert_patch_location(self, mpd, pos, patch_location_url, ttl):
         patch_location_elem = ElementTree.Element(add_ns('PatchLocation'))
         patch_location_elem.text = patch_location_url
         patch_location_elem.tail = "\n"
-        patch_location_elem.set('ttl', str(60)) # todo config patch validity duration
+        patch_location_elem.set('ttl', str(ttl))
         mpd.insert(pos, patch_location_elem)
 
     #pylint: disable = too-many-statements
@@ -353,7 +353,7 @@ def create_inband_scte35stream_elem():
         def create_inband_stream_elem():
             "Create an InbandEventStream element for signalling emsg in Rep when encoder fails to generate new segments, IOP 4.11.4.3 scenario."
             return self.create_descriptor_elem("InbandEventStream", "urn:mpeg:dash:event:2012", value=str(1))
-        
+
         def create_inline_mpdcallback_elem(BaseURLSegmented):
             "Create an EventStream element for MPD Callback."
             return self.create_descriptor_elem("EventStream", "urn:mpeg:dash:event:callback:2015", value=str(1),

From 28cda685408fd8389b2894e9ffc419959d638501 Mon Sep 17 00:00:00 2001
From: Zachary Cava <technogeek00@gmail.com>
Date: Fri, 6 Dec 2019 08:36:00 -0800
Subject: [PATCH 4/6] Appropriately handle start/end/relative parameters and
 live stream termination case

---
 dashlivesim/dashlib/mpdprocessor.py | 38 ++++++++++++++++++++---------
 dashlivesim/dashlib/patch_ops.py    | 11 ++++++++-
 2 files changed, 37 insertions(+), 12 deletions(-)

diff --git a/dashlivesim/dashlib/mpdprocessor.py b/dashlivesim/dashlib/mpdprocessor.py
index ffa3aa8..e0eb40a 100644
--- a/dashlivesim/dashlib/mpdprocessor.py
+++ b/dashlivesim/dashlib/mpdprocessor.py
@@ -194,17 +194,14 @@ def process_mpd_children(self, mpd, data, period_data):
                 self.insert_baseurl(mpd, pos, data['BaseURL'], ato)
                 pos += 1
         if self.cfg and self.cfg.add_location and self.full_url is not None:
-            loc_url = re.sub(r"/startrel_[-\d]+", "/start_%d" %
-                             self.cfg.start_time, self.full_url)
-            loc_url = re.sub(r"/stoprel_[-\d]+", "/stop_%d" %
-                             self.cfg.stop_time, loc_url)
+            loc_url = self.update_proxy_url_parameters(self.full_url)
             self.insert_location(mpd, pos, loc_url)
             pos += 1
 
         if self.patching:
             # replace the original patching key with the in-memory manifest publish time
-            patch_url = re.sub(r"/patching_[-\d]+", "/patch_%d" %
-                               self.mpd_proc_cfg['now'], self.full_url)
+            patch_url = self.update_proxy_url_parameters(self.full_url, include_patch_base=True)
+
             # also change the extension type to be patch instead of mpd
             patch_url = re.sub(r"\.mpd$", ".patch", patch_url)
             self.insert_patch_location(mpd, pos, patch_url, self.mpd_proc_cfg['patch_ttl'])
@@ -234,11 +231,20 @@ def process_patch(self, patch, mpd, mpd_data, period_data):
         publish_replace = patch_ops.insert_replace_op(patch, '/MPD/@publishTime')
         publish_replace.text = make_timestamp(self.mpd_proc_cfg['now'])
 
-        # Insert patch location update node
-        patch_location = re.sub(r"/patch_[-\d]+", "/patch_%d" %
-                                self.mpd_proc_cfg['now'], self.full_url)
-        patch_replace = patch_ops.insert_replace_op(patch, '/MPD/PatchLocation[0]')
-        self.insert_patch_location(patch_replace, 0, patch_location, self.mpd_proc_cfg['patch_ttl'])
+        if mpd_data.get('type', 'dynamic') is 'dynamic':
+            # If MPD has remained dynamic update location update node
+            patch_location = self.update_proxy_url_parameters(self.full_url, include_patch_base=True)
+            patch_replace = patch_ops.insert_replace_op(patch, '/MPD/PatchLocation[0]')
+            self.insert_patch_location(patch_replace, 0, patch_location, self.mpd_proc_cfg['patch_ttl'])
+        else:
+            # otherwise the presentation has ended, update the MPD attributes
+            type_update = patch_ops.insert_replace_op(patch, '/MPD/@type')
+            type_update.text = 'static'
+            patch_ops.insert_remove_op(patch, '/MPD/@minimumUpdatePeriod')
+
+            # Additionally remove the previous patch locations, no updates necessary now
+            patch_ops.insert_remove_op(patch, '/MPD/PatchLocation[0]')
+
 
         # For this simulator we assume patches will not be announcing new high level structures
         # it is completely possible for them to do that, but this simulator only needs basic
@@ -459,6 +465,16 @@ def create_descriptor_elem(self, name, scheme_id_uri, value=None, elem_id=None,
         elem.tail = "\n"
         return elem
 
+    def update_proxy_url_parameters(self, loc_url, include_patch_base=False):
+        loc_url = re.sub(r"/startrel_[-\d]+", "/start_%d" %
+                         self.cfg.start_time, loc_url)
+        loc_url = re.sub(r"/stoprel_[-\d]+", "/stop_%d" %
+                         self.cfg.stop_time, loc_url)
+        if include_patch_base:
+            loc_url = re.sub(r"/patching_[-\d]+", "/patch_%d" %
+                             self.mpd_proc_cfg['now'], loc_url)
+        return loc_url
+
     def create_timeline_generators(self):
         segtimeline_generators = None
         if self.segtimeline or self.segtimeline_nr:
diff --git a/dashlivesim/dashlib/patch_ops.py b/dashlivesim/dashlib/patch_ops.py
index e7a43e2..082c28e 100644
--- a/dashlivesim/dashlib/patch_ops.py
+++ b/dashlivesim/dashlib/patch_ops.py
@@ -1,3 +1,4 @@
+# Generates nodes conformant with DASH restricted form of https://tools.ietf.org/html/rfc5261
 from xml.etree import ElementTree
 PATCH_OP_NAMESPACE = "{urn:ietf:params:xml:schema:patch-ops}"
 
@@ -18,4 +19,12 @@ def insert_add_op(target, selector, pos):
     add_elem.set('sel', selector)
     add_elem.set('pos', pos)
     target.append(add_elem)
-    return add_elem
\ No newline at end of file
+    return add_elem
+
+def insert_remove_op(target, selector):
+    remove_elem = ElementTree.Element(add_ns('remove'))
+    remove_elem.tail = "\n"
+    remove_elem.set('sel', selector)
+    # ws attribute omitted as it is not critical to MPDs
+    target.append(remove_elem)
+    return remove_elem
\ No newline at end of file

From 07f2227cfccabc9ec6bd8fefea80131b4cd17e51 Mon Sep 17 00:00:00 2001
From: Zachary Cava <technogeek00@gmail.com>
Date: Fri, 6 Dec 2019 11:07:00 -0800
Subject: [PATCH 5/6] Prevent xlink, segtimelineloss, and modulo with patching

There is no specification restriction that would prevent the combined
usage of patching and these options, however their implementation in the
simulator would require significant work in order to enable. To avoid
the options being used and getting invalid responses they are explicitly
detected with patching and an exception is raised. Issues can be filed
on github to ask for enablement of a scenario.

Minor fix for location production without fixed start/end times
---
 dashlivesim/dashlib/configprocessor.py |  3 ++-
 dashlivesim/dashlib/dash_proxy.py      | 14 ++++++++++++++
 dashlivesim/dashlib/mpdprocessor.py    | 10 ++++++----
 3 files changed, 22 insertions(+), 5 deletions(-)

diff --git a/dashlivesim/dashlib/configprocessor.py b/dashlivesim/dashlib/configprocessor.py
index ec453f0..bfe7d5b 100644
--- a/dashlivesim/dashlib/configprocessor.py
+++ b/dashlivesim/dashlib/configprocessor.py
@@ -66,7 +66,7 @@ def __init__(self, vod_cfg_dir, base_url=None):
         self.media_presentation_duration = None
         self.timeshift_buffer_depth_in_s = None
         self.minimum_update_period_in_s = None
-        self.modulo_period = None
+        self.modulo_period = False # True if modulo behavior active
         self.last_segment_numbers = [] # The last segment number in every period.
         self.init_seg_avail_offset = 0 # The number of secs before AST that one can fetch the init segments
         self.tfdt32_flag = False # Restart every 3 hours make tfdt fit into 32 bits.
@@ -430,6 +430,7 @@ def process_url(self, url_parts, now_int=0):
                 cfg.minimum_update_period_in_s = int(value)
             elif key == "modulo": # Make a number of time-limited sessions every hour
                 modulo_period = ModuloPeriod(int(value), now_int)
+                cfg.modulo_period = True
             elif key == "tfdt": # Use 32-bit tfdt (which means that AST must be more recent as well)
                 cfg.tfdt32_flag = True
             elif key == "cont": # Continuous update of MPD AST and seg_nr.
diff --git a/dashlivesim/dashlib/dash_proxy.py b/dashlivesim/dashlib/dash_proxy.py
index 2b27d1d..791927a 100644
--- a/dashlivesim/dashlib/dash_proxy.py
+++ b/dashlivesim/dashlib/dash_proxy.py
@@ -336,6 +336,20 @@ def parse_url(self):
             if mpd_input_data['insertAd'] > 0 and nr_xlink_periods_per_hour < 0:
                 raise Exception("Insert ad option can only be used in conjuction with the xlink option. To use the "
                                 "insert ad option, also set use xlink_m in your url.")
+
+            # based on simulator implementation there are a few option combinations with patching that have not
+            # been directly implemented, implementation can be requested with a github issue but we would prefer
+            # the scenario fail than improperly work
+            if mpd_input_data['patching']:
+                base_text = "The patching option cannot be used in conjunction with the %s option currently, please file a github issue to request implementation."
+                if nr_xlink_periods_per_hour != -1:
+                    raise Exception(base_text % "xlink")
+                if cfg.segtimelineloss:
+                    raise Exception(base_text % "segtimelineloss")
+                print cfg.modulo_period
+                if cfg.modulo_period:
+                    raise Exception(base_text % "modulo")
+
             response = self.generate_dynamic_mpd(cfg, mpd_filename, mpd_input_data, self.now)
             #The following 'if' is for IOP 4.11.4.3 , deployment scenario when segments not found.
             if len(cfg.multi_url) > 0 and cfg.segtimelineloss == True:  # There is one specific baseURL with losses specified
diff --git a/dashlivesim/dashlib/mpdprocessor.py b/dashlivesim/dashlib/mpdprocessor.py
index e0eb40a..370ca3c 100644
--- a/dashlivesim/dashlib/mpdprocessor.py
+++ b/dashlivesim/dashlib/mpdprocessor.py
@@ -466,10 +466,12 @@ def create_descriptor_elem(self, name, scheme_id_uri, value=None, elem_id=None,
         return elem
 
     def update_proxy_url_parameters(self, loc_url, include_patch_base=False):
-        loc_url = re.sub(r"/startrel_[-\d]+", "/start_%d" %
-                         self.cfg.start_time, loc_url)
-        loc_url = re.sub(r"/stoprel_[-\d]+", "/stop_%d" %
-                         self.cfg.stop_time, loc_url)
+        if self.cfg.start_time:
+            loc_url = re.sub(r"/startrel_[-\d]+", "/start_%d" %
+                             self.cfg.start_time, loc_url)
+        if self.cfg.stop_time:
+            loc_url = re.sub(r"/stoprel_[-\d]+", "/stop_%d" %
+                             self.cfg.stop_time, loc_url)
         if include_patch_base:
             loc_url = re.sub(r"/patching_[-\d]+", "/patch_%d" %
                              self.mpd_proc_cfg['now'], loc_url)

From ab000c75549f5541af69b9e149b6de42ca757798 Mon Sep 17 00:00:00 2001
From: Tomohiro Matsuzawa <thmatuza75@hotmail.com>
Date: Wed, 1 Jan 2020 17:32:19 +0900
Subject: [PATCH 6/6] Fixed mpd patch problems

---
 dashlivesim/dashlib/mpdprocessor.py | 2 ++
 dashlivesim/dashlib/segtimeline.py  | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/dashlivesim/dashlib/mpdprocessor.py b/dashlivesim/dashlib/mpdprocessor.py
index 370ca3c..9a25fe5 100644
--- a/dashlivesim/dashlib/mpdprocessor.py
+++ b/dashlivesim/dashlib/mpdprocessor.py
@@ -473,6 +473,8 @@ def update_proxy_url_parameters(self, loc_url, include_patch_base=False):
             loc_url = re.sub(r"/stoprel_[-\d]+", "/stop_%d" %
                              self.cfg.stop_time, loc_url)
         if include_patch_base:
+            loc_url = re.sub(r"/patch_[-\d]+", "/patch_%d" %
+                             self.mpd_proc_cfg['now'], loc_url)
             loc_url = re.sub(r"/patching_[-\d]+", "/patch_%d" %
                              self.mpd_proc_cfg['now'], loc_url)
         return loc_url
diff --git a/dashlivesim/dashlib/segtimeline.py b/dashlivesim/dashlib/segtimeline.py
index cc77bc8..e3c9633 100644
--- a/dashlivesim/dashlib/segtimeline.py
+++ b/dashlivesim/dashlib/segtimeline.py
@@ -170,7 +170,7 @@ def find_latest_starting_before(self, act_time):
         seg_data = self.segtimedata[index]
         repeats = 0
         accumulated_end_time = seg_data.start_time + seg_data.duration
-        while accumulated_end_time < rel_time:
+        while accumulated_end_time <= rel_time:
             accumulated_end_time += seg_data.duration
             repeats += 1
         return index, repeats, nr_wraps