Initial ADS implementation

resources/lib/services/nfsession/msl/converter.py

@@ -21,49 +21,104 @@ def convert_to_dash(manifest):
     """Convert a Netflix style manifest to MPEG-DASH manifest"""
     # If a CDN server has stability problems it may cause errors with streaming,
     # we allow users to select a different CDN server
-    # (should be managed by ISA but is currently is not implemented)
+    # (should be managed automatically by add more MPD "BaseURL" tags, but is currently is not implemented in ISA)
     cdn_index = int(G.ADDON.getSettingString('cdn_server')[-1]) - 1
+    mpd_tag = _create_mpd_tag()
+
+    # Netflix ADS appear to have a complex customization with the browser/player this leads us to several headaches
+    # to be able to implement it in the add-on.
+    # Things to solve to have a decent ADS playback implementation:
+    # - Their player, once an ad is displayed is removed from the video timeline in real time, there is no way to do
+    #   a similar thing with Kodi platform. But could be not a big problem, but we need somewhat find a solution
+    #   to know when same ads is played multiple times to avoid send multiple MSL events (see next point)
+    # - Every time an ADS is played the website player send a MSL event like adStart/adProgress/... in similar way
+    #   as done to send playback progress updates, his data should be related to "adverts/adBreaks" json path
+    #   from MSL manifest data, i think this is used by netflix to know when an ad is displayed for their business.
+    #   Here its difficult know when a specific ads is played and then make a callback to send the MSL event, due to:
+    #   Problem 1: There is a Kodi bug that when a chapter change cause JSON RPC Player.GetProperties api
+    #              to provide wrong info, this problem is reflected also on Kodi GUI
+    #   Problem 2: we should not send multiple times these events because with kodi same ads may be played more times.
+    # - Manifest DASH conversion problem: Im not sure how to split the main stream in the manifest in to multiple
+    #   periods by injecting the ads in the middle of stream, because usually DASH SegmentBase needs to know the
+    #   segments ranges (e.g. init) that we dont have(?). For now as workaround all ads (periods) are add before the movie.
+    # - JSON RPC Player.GetProperties chapter bug prevent to have a good management of action_controller.py features
+    #   (such as language track selection) however a bad workaround has been found,
+    #   in addition to being not 100% reliable makes the code more mess...
+    # - When ADS is played you should prevent the user from skipping ads and also prevent them from forwarding the video
+    #   now this should be managed by InputStream Adaptive addon, then changes to ISA will be required to fix this.
+
+    ads_manifest_list = []
+    if 'auxiliaryManifests' in manifest and manifest['auxiliaryManifests']:
+        # Find auxiliary ADS manifests
+        ads_manifest_list = [m for m in manifest['auxiliaryManifests'] if 'isAd' in m and m['isAd']]
+
+    total_duration_secs = 0
+    for ads_man in ads_manifest_list:
+        total_duration_secs += _add_period(mpd_tag, ads_man, cdn_index, total_duration_secs, False)
+
+    total_duration_secs += _add_period(mpd_tag, manifest, cdn_index, total_duration_secs, True)
+
+    mpd_tag.attrib['mediaPresentationDuration'] = _convert_secs_to_time(total_duration_secs)
+
+    xml = ET.tostring(mpd_tag, encoding='utf-8', method='xml')
+    if LOG.is_enabled:
+        common.save_file_def('manifest.mpd', xml)
+    return xml.decode('utf-8').replace('\n', '').replace('\r', '').encode('utf-8')
 
-    seconds = manifest['duration'] / 1000
-    duration = "PT" + str(int(seconds)) + ".00S"
 
-    root = _mpd_manifest_root(duration)
-    period = ET.SubElement(root, 'Period', start='PT0S', duration=duration)
+def _add_period(mpd_tag, manifest, cdn_index, start_pts, add_pts_to_track_name):
+    seconds = int(manifest['duration'] / 1000)
+    movie_id = str(manifest['movieId'])
+    is_ads_stream = 'isAd' in manifest and manifest['isAd']
+    if is_ads_stream:
+        movie_id += '_ads'
+    period_tag = ET.SubElement(mpd_tag, 'Period', id=movie_id, start=_convert_secs_to_time(start_pts),
+                               duration=_convert_secs_to_time(seconds))
+
+    if is_ads_stream:  # Custom ADS signal
+        # todo: could be used in future by ISAdaptive to identify ADS period, will require ISAdaptive implementation
+        ET.SubElement(period_tag,  # Parent
+                      'EventStream',  # Tag
+                      schemeIdUri='urn:scte:scte35:2013:xml',
+                      value='ads')
 
     has_video_drm_streams = manifest['video_tracks'][0].get('hasDrmStreams', False)
     video_protection_info = _get_protection_info(manifest['video_tracks'][0]) if has_video_drm_streams else None
 
-    for video_track in manifest['video_tracks']:
-        _convert_video_track(video_track, period, video_protection_info, has_video_drm_streams, cdn_index)
+    if not add_pts_to_track_name:  # workaround for kodi bug, see action_controller.py
+        start_pts = 0
+    for index, video_track in enumerate(manifest['video_tracks']):
+        _convert_video_track(index, video_track, period_tag, video_protection_info, has_video_drm_streams, cdn_index,
+                             movie_id, start_pts)
 
     common.apply_lang_code_changes(manifest['audio_tracks'])
     common.apply_lang_code_changes(manifest['timedtexttracks'])
 
     has_audio_drm_streams = manifest['audio_tracks'][0].get('hasDrmStreams', False)
 
     id_default_audio_tracks = _get_id_default_audio_tracks(manifest)
-    for audio_track in manifest['audio_tracks']:
+    for index, audio_track in enumerate(manifest['audio_tracks']):
         is_default = audio_track['id'] == id_default_audio_tracks
-        _convert_audio_track(audio_track, period, is_default, has_audio_drm_streams, cdn_index)
+        _convert_audio_track(index, audio_track, period_tag, is_default, has_audio_drm_streams, cdn_index)
 
-    for text_track in manifest['timedtexttracks']:
+    for index, text_track in enumerate(manifest['timedtexttracks']):
         if text_track['isNoneTrack']:
             continue
         is_default = _is_default_subtitle(manifest, text_track)
-        _convert_text_track(text_track, period, is_default, cdn_index)
+        _convert_text_track(index, text_track, period_tag, is_default, cdn_index)
 
-    xml = ET.tostring(root, encoding='utf-8', method='xml')
-    if LOG.is_enabled:
-        common.save_file_def('manifest.mpd', xml)
-    return xml.decode('utf-8').replace('\n', '').replace('\r', '').encode('utf-8')
+    return seconds
+
+
+def _convert_secs_to_time(secs):
+    return "PT" + str(int(secs)) + ".00S"
 
 
-def _mpd_manifest_root(duration):
-    root = ET.Element('MPD')
-    root.attrib['xmlns'] = 'urn:mpeg:dash:schema:mpd:2011'
-    root.attrib['xmlns:cenc'] = 'urn:mpeg:cenc:2013'
-    root.attrib['mediaPresentationDuration'] = duration
-    return root
+def _create_mpd_tag():
+    mpd_tag = ET.Element('MPD')
+    mpd_tag.attrib['xmlns'] = 'urn:mpeg:dash:schema:mpd:2011'
+    mpd_tag.attrib['xmlns:cenc'] = 'urn:mpeg:cenc:2013'
+    return mpd_tag
 
 
 def _add_base_url(representation, base_url):
@@ -133,10 +188,11 @@ def _add_protection_info(video_track, adaptation_set, pssh, keyid):
         ET.SubElement(protection, 'cenc:pssh').text = pssh
 
 
-def _convert_video_track(video_track, period, protection, has_drm_streams, cdn_index):
+def _convert_video_track(index, video_track, period, protection, has_drm_streams, cdn_index, movie_id, pts_offset):
     adaptation_set = ET.SubElement(
         period,  # Parent
         'AdaptationSet',  # Tag
+        id=str(index),
         mimeType='video/mp4',
         contentType='video')
     if protection:
@@ -151,12 +207,17 @@ def _convert_video_track(video_track, period, protection, has_drm_streams, cdn_i
             if int(downloadable['res_h']) > limit_res:
                 continue
         _convert_video_downloadable(downloadable, adaptation_set, cdn_index)
+    # Set the name to the AdaptationSet tag
+    # this will become the name of the video stream, that can be read in the Kodi GUI on the video stream track list
+    # and can be read also by using jsonrpc Player.GetProperties "videostreams" used by action_controller.py
+    name = f"(Id {movie_id})(pts offset {pts_offset})"
     # Calculate the crop factor, will be used on am_playback.py to set zoom viewmode
     try:
         factor = video_track['maxHeight'] / video_track['maxCroppedHeight']
-        adaptation_set.set('name', f'(Crop {factor:0.2f})')
+        name += f'(Crop {factor:0.2f})'
     except Exception as exc:  # pylint: disable=broad-except
         LOG.error('Cannot calculate crop factor: {}', exc)
+    adaptation_set.set('name', name)
 
 
 def _limit_video_resolution(video_tracks, has_drm_streams):
@@ -210,12 +271,12 @@ def _determine_video_codec(content_profile):
     if content_profile.startswith('vp9'):
         return f'vp9.{content_profile[11:12]}'
     if 'av1' in content_profile:
-        return 'av1'
+        return 'av01'
     return 'h264'
 
 
 # pylint: disable=unused-argument
-def _convert_audio_track(audio_track, period, default, has_drm_streams, cdn_index):
+def _convert_audio_track(index, audio_track, period, default, has_drm_streams, cdn_index):
     channels_count = {'1.0': '1', '2.0': '2', '5.1': '6', '7.1': '8'}
     impaired = 'true' if audio_track['trackType'] == 'ASSISTIVE' else 'false'
     original = 'true' if audio_track['isNative'] else 'false'
@@ -224,6 +285,7 @@ def _convert_audio_track(audio_track, period, default, has_drm_streams, cdn_inde
     adaptation_set = ET.SubElement(
         period,  # Parent
         'AdaptationSet',  # Tag
+        id=str(index),
         lang=audio_track['language'],
         contentType='audio',
         mimeType='audio/mp4',
@@ -242,7 +304,7 @@ def _convert_audio_track(audio_track, period, default, has_drm_streams, cdn_inde
 
 
 def _convert_audio_downloadable(downloadable, adaptation_set, channels_count, cdn_index):
-    codec_type = 'aac'
+    codec_type = 'mp4a.40.5' # he-aac
     if 'ddplus-' in downloadable['content_profile'] or 'dd-' in downloadable['content_profile']:
         codec_type = 'ec-3'
     representation = ET.SubElement(
@@ -261,7 +323,7 @@ def _convert_audio_downloadable(downloadable, adaptation_set, channels_count, cd
     _add_segment_base(representation, downloadable)
 
 
-def _convert_text_track(text_track, period, default, cdn_index):
+def _convert_text_track(index, text_track, period, default, cdn_index):
     # Only one subtitle representation per adaptationset
     downloadable = text_track.get('ttDownloadables')
     if not text_track:
@@ -274,6 +336,7 @@ def _convert_text_track(text_track, period, default, cdn_index):
     adaptation_set = ET.SubElement(
         period,  # Parent
         'AdaptationSet',  # Tag
+        id=str(index),
         lang=text_track['language'],
         codecs=('stpp', 'wvtt')[is_ios8],
         contentType='text',

resources/lib/services/nfsession/msl/events_handler.py

@@ -146,7 +146,7 @@ def _build_event_params(self, event_type, event_data, player_state, manifest, lo
         # else:
         #     list_id = G.LOCAL_DB.get_value('last_menu_id', 'unknown')
 
-        position = player_state['elapsed_seconds']
+        position = player_state['current_pts']
         if position != 1:
             position *= 1000
 

resources/lib/services/nfsession/msl/msl_handler.py

@@ -123,10 +123,12 @@ def get_manifest(self, viewable_id, challenge, sid):
                            'This problem could be solved in the future, but at the moment there is no solution.')
                 raise ErrorMsgNoReport(err_msg) from exc
             raise
-        if manifest.get('adverts', {}).get('adBreaks', []):
-            # Todo: manifest converter should handle ads streams with additional DASH periods
-            raise ErrorMsgNoReport('This add-on dont support playback videos with ads. '
-                                   'Please use an account plan without ads.')
+        if G.KODI_VERSION < 20 and manifest.get('adverts', {}).get('adBreaks', []):
+            # InputStream Adaptive version on Kodi 19 is too old and dont handle correctly these manifests
+            raise ErrorMsgNoReport('On Kodi 19 the Netflix ADS plans are not supported. \n'
+                                   'You must use Kodi 20 or higher versions.')
+        if manifest.get('streamingType', 'VOD') != 'VOD':
+            raise ErrorMsgNoReport('Live videos are not supported.')
         return self._tranform_to_dash(manifest)
 
     @measure_exec_time_decorator(is_immediate=True)
@@ -285,7 +287,7 @@ def _build_manifest_v2(self, **kwargs):
             'requestSegmentVmaf': False,
             'supportsPartialHydration': False,
             'contentPlaygraph': ['start'],
-            'supportsAdBreakHydration': False,
+            'supportsAdBreakHydration': True, # True if this client support separate ADS management, false to use ADS merged on stream (next future?) currently disallowed due to feature not implemented on server side
             'liveMetadataFormat': 'INDEXED_SEGMENT_TEMPLATE',
             'useBetterTextUrls': True,
             'profileGroups': [{

resources/lib/services/nfsession/msl/msl_utils.py

@@ -84,7 +84,7 @@ def is_media_changed(previous_player_state, player_state):
 
 def update_play_times_duration(play_times, player_state):
     """Update the playTimes duration values"""
-    duration = player_state['elapsed_seconds'] * 1000
+    duration = player_state['current_pts'] * 1000
     play_times['total'] = duration
     play_times['audio'][0]['duration'] = duration
     play_times['video'][0]['duration'] = duration