Temporarily revert "Low latency dash support staging (#88)"

This reverts commit 4fc6d19.

The corresponding Packager release is not ready yet, so this feature
in Streamer is being temporarily reverted.  It will be restored after
the v0.4.0 release, with the intent of shipping it in v0.5.0 instead.

Change-Id: I3d660ff71fee84450576a4bd5672379dd9903fe7

CHANGELOG.md

@@ -53,8 +53,6 @@
    (https://github.com/google/shaka-streamer/pull/85)
  - Add HTTP url output support
    (https://github.com/google/shaka-streamer/pull/82)
- - Add LL-DASH support
-   (https://github.com/google/shaka-streamer/pull/88)
  - Fix accidental live-type DASH output in VOD mode
 
 

run_end_to_end_tests.py

@@ -91,17 +91,9 @@ def dashStreamsReady(manifest_path):
   pattern = re.compile(r'<Representation.*?((\n).*?)*?Representation>')
   with open(manifest_path) as manifest_file:
     for representation in pattern.finditer(manifest_file.read()):
-      if controller.is_low_latency_dash_mode():
-        # LL-DASH manifests do not contain the segment reference tag <S>.
-        # Check for the availabilityTimeOffset attribute instead.
-        if not re.search(r'availabilityTimeOffset', representation.group()):
-          # This Representation does not have a availabilityTimeOffset yet,
-          # meaning the first chunk is not yet ready for playout.
-          return False
-      else:
-        if not re.search(r'<S t', representation.group()):
-          # This Representation has no segments.
-          return False
+      if not re.search(r'<S t', representation.group()):
+        # This Representation has no segments.
+        return False
 
   return True
 

streamer/controller_node.py

@@ -36,7 +36,7 @@
 from streamer.node_base import NodeBase, ProcessStatus
 from streamer.output_stream import AudioOutputStream, OutputStream, TextOutputStream, VideoOutputStream
 from streamer.packager_node import PackagerNode
-from streamer.pipeline_configuration import ManifestFormat, PipelineConfig, StreamingMode
+from streamer.pipeline_configuration import PipelineConfig, StreamingMode
 from streamer.transcoder_node import TranscoderNode
 from streamer.periodconcat_node import PeriodConcatNode
 import streamer.subprocessWindowsPatch  # side-effects only
@@ -143,17 +143,6 @@ def start(self, output_location: str,
         raise RuntimeError(
             'Multiperiod input list support is incompatible with HTTP outputs.')
 
-    if self._pipeline_config.low_latency_dash_mode:
-      # Check some restrictions on LL-DASH packaging.
-      if ManifestFormat.DASH not in self._pipeline_config.manifest_format:
-        raise RuntimeError(
-            'low_latency_dash_mode is only compatible with DASH ouputs. ' +
-            'manifest_format must include DASH')
-
-      if not self._pipeline_config.utc_timings:
-        raise RuntimeError(
-            'For low_latency_dash_mode, the utc_timings must be set.')
-
     # Note that we remove the trailing slash from the output location, because
     # otherwise GCS would create a subdirectory whose name is "".
     output_location = output_location.rstrip('/')
@@ -300,14 +289,6 @@ def is_vod(self) -> bool:
 
     return self._pipeline_config.streaming_mode == StreamingMode.VOD
 
-  def is_low_latency_dash_mode(self) -> bool:
-    """Returns True if the pipeline is running in LL-DASH mode.
-
-    :rtype: bool
-    """
-
-    return self._pipeline_config.low_latency_dash_mode
-
 class VersionError(Exception):
   """A version error for one of Shaka Streamer's external dependencies.
 

streamer/packager_node.py

@@ -160,16 +160,6 @@ def _setup_stream(self, stream: OutputStream) -> str:
   def _setup_manifest_format(self) -> List[str]:
     args: List[str] = []
     if ManifestFormat.DASH in self._pipeline_config.manifest_format:
-      if self._pipeline_config.utc_timings:
-        args += [
-            '--utc_timings',
-            ','.join(timing.scheme_id_uri + '=' +
-                     timing.value for timing in self._pipeline_config.utc_timings)
-        ]
-      if self._pipeline_config.low_latency_dash_mode:
-        args += [
-            '--low_latency_dash_mode=true',
-        ]
       if self._pipeline_config.streaming_mode == StreamingMode.VOD:
         args += [
             '--generate_static_live_mpd',

streamer/pipeline_configuration.py

@@ -76,17 +76,6 @@ class EncryptionMode(enum.Enum):
   RAW = 'raw'
   """Raw key mode"""
 
-class UtcTimingPair(configuration.Base):
-  """An object containing the attributes for a DASH MPD UTCTiming 
-  element"""
-
-  # TODO: Use an enum for scheme_id_uri to simplify the config input
-  scheme_id_uri = configuration.Field(str).cast()
-  """SchemeIdUri attribute to be used for the UTCTiming element"""
-
-  value = configuration.Field(str).cast()
-  """Value attribute to be used for the UTCTiming element"""
-
 class RawKeyConfig(configuration.Base):
   """An object representing a list of keys for Raw key encryption"""
 
@@ -320,19 +309,6 @@ class PipelineConfig(configuration.Base):
                                    default=EncryptionConfig({})).cast()
   """Encryption settings."""
 
-  # TODO: Generalize this to low_latency_mode once LL-HLS is supported by Packager
-  low_latency_dash_mode = configuration.Field(bool, default=False).cast()
-  """If true, stream in low latency mode for DASH."""
-
-  utc_timings = configuration.Field(List[UtcTimingPair]).cast()
-  """UTCTiming schemeIdUri and value pairs for the DASH MPD.
-
-  If multiple UTCTiming pairs are provided for redundancy,
-  list the pairs in the order of preference.
-
-  Must be set for LL-DASH streaming.
-  """
-
 
   def __init__(self, *args) -> None:
 

tests/tests.js

@@ -147,8 +147,6 @@ describe('Shaka Streamer', () => {
   muxedTextTests(dashManifestUrl, '(dash)');
 
   multiPeriodTests(dashManifestUrl, '(dash)');
-
-  lowLatencyDashTests(dashManifestUrl, '(dash)');
 });
 
 function errorTests() {
@@ -380,39 +378,6 @@ function errorTests() {
           error_type: 'RuntimeError',
         }));
   });
-
-  it('fails when utc_timing is not set for low_latency_dash_mode', async () => {
-    const inputConfig = getBasicInputConfig();
-    const pipelineConfig = {
-      low_latency_dash_mode: true,
-      streaming_mode: 'live',
-    };
-
-    await expectAsync(startStreamer(inputConfig, pipelineConfig))
-        .toBeRejectedWith(jasmine.objectContaining({
-          error_type: 'RuntimeError',
-        }));
-  });
-
-  it('fails when low_latency_dash_mode is set without a DASH manifest', async () => {
-    const inputConfig = getBasicInputConfig();
-    const pipelineConfig = {
-      low_latency_dash_mode: true,
-      manifest_format: ['hls'],
-      streaming_mode: 'live',
-      utc_timings: [
-        {
-          scheme_id_uri:'urn:mpeg:dash:utc:http-xsdate:2014',
-          value:'https://time.akamai.com/?.iso'
-        },
-      ],
-    };
-
-    await expectAsync(startStreamer(inputConfig, pipelineConfig))
-        .toBeRejectedWith(jasmine.objectContaining({
-          error_type: 'RuntimeError',
-        }));
-  });
 }
 
 function resolutionTests(manifestUrl, format) {
@@ -1431,43 +1396,4 @@ function multiPeriodTests(manifestUrl, format) {
     // Be more tolerant with float comparison, (D > 1.9 * length) instead of (D == 2 * length).
     expect(video.duration).toBeGreaterThan(1.9);
   });
-}
-
-function lowLatencyDashTests(manifestUrl, format) {
-  it('can process LL-DASH streaming ' + format, async() => {
-    const inputConfigDict = {
-      'inputs': [
-        {
-          'name': TEST_DIR + 'BigBuckBunny.1080p.mp4',
-          'media_type': 'video',
-          // Keep this test short by only encoding 4s of content.
-          'end_time': '0:04',
-        }
-      ],
-    };
-    const pipelineConfigDict = {
-      'streaming_mode': 'live',
-      'resolutions': ['144p'],
-      'video_codecs': ['h264'],
-      'manifest_format': ['dash'],
-      'segment_size': 2,
-      'low_latency_dash_mode': true,
-      'utc_timings': [
-        {
-          'scheme_id_uri':'urn:mpeg:dash:utc:http-xsdate:2014',
-          'value':'https://time.akamai.com/?.iso'
-        },
-      ],
-    };
-    await startStreamer(inputConfigDict, pipelineConfigDict);
-    // TODO(CaitlinO'Callaghan): fix so player loads and test passes
-    player.configure({
-      streaming: {
-        lowLatencyMode: true,
-        inaccurateManifestTolerance: 0,
-        rebufferingGoal: 0.01,
-      }
-    });
-    await player.load(manifestUrl);
-  });
 }