@eluvio/elv-client-js 4.0.76 → 4.0.78

package/dist/src/client/Files.js

@@ -2,8 +2,8 @@ var _toConsumableArray = require("@babel/runtime/helpers/toConsumableArray");
 var _defineProperty = require("@babel/runtime/helpers/defineProperty");
 var _regeneratorRuntime = require("@babel/runtime/regenerator");
 var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 /**
  * Methods for accessing and managing access groups
  *

package/dist/src/client/LiveConf.js

@@ -97,6 +97,7 @@ var LiveconfTemplate = {
           sync_audio_to_stream_id: -1,
           video_bitrate: null,
           video_seg_duration_ts: null,
+          video_time_base: null,
           xc_type: 3
         }
       }
@@ -156,57 +157,170 @@ var LiveConf = /*#__PURE__*/function () {
         return roundedFrameRate * 2;
       }
     }
+
+    /*
+     * Calculates mez segment durations based on input stream parameters
+     *
+     * Live input formats have fixed timebase:
+     * - MPEG-TS/SRT input stream timebase is 90000
+     * - RTMP input stream timebase is 1000 and gets translated to 16000 if not otherwise specified
+     *
+     * This causes frame duration irregularities for certain frame rates.
+     * For example RTMP 60fps has frames of durations 16 and 17.  MPEG-TS 59.94fps has frames of
+     * durations 1001 and 1002.
+     *
+     * Live mez segmentation requires that the segment be cut at the specific number of frames, and when
+     * the frame durations are irregular we adjust both the video timebase and the video frame duration
+     * to make the math possible.  This adjustment is also required for live-to-vod conversion.
+     *
+     * For example for MPEG-TS 59.94fps, the mez segment timebase needs to be 60000
+     * (and resulting frame duration is 1001) and for RTMP 60fps the timebase needs to be 15360 (resulting frame
+     * duration is 256).
+     *
+     * @sourceTimescale - adjusted source video stream timescale (eg. MPEGTS 90000, RTMP 16000 )
+     * @sampleRate - audio sample rate (commonly 48000 but can be different)
+     * @audioCodec - audio codec as a string (eg. "aac")
+     * @return - segment encoding parameters
+     */
   }, {
     key: "calcSegDuration",
     value: function calcSegDuration(_ref) {
-      var sourceTimescale = _ref.sourceTimescale;
+      var sourceTimescale = _ref.sourceTimescale,
+        sampleRate = _ref.sampleRate,
+        audioCodec = _ref.audioCodec;
+      var seg = {};
+      switch (this.probeKind()) {
+        case "rtmp":
+          seg = this.calcSegDurationRtmp({
+            sourceTimescale: sourceTimescale,
+            sampleRate: sampleRate,
+            audioCodec: audioCodec
+          });
+          break;
+        case "udp":
+        case "srt":
+          seg = this.calcSegDurationMpegts({
+            sourceTimescale: sourceTimescale,
+            sampleRate: sampleRate,
+            audioCodec: audioCodec
+          });
+          break;
+        default:
+          throw "protocol not supported - " + this.probeKind();
+      }
+      if (audioCodec == "aac") {
+        seg.audio = 29.76 * sampleRate;
+      } else {
+        seg.audio = 29.76 * 48000; // Other codecs are resampled @48000
+      }
+
+      return seg;
+    }
+  }, {
+    key: "calcSegDurationMpegts",
+    value: function calcSegDurationMpegts(_ref2) {
+      var sourceTimescale = _ref2.sourceTimescale;
       var videoStream = this.getStreamDataForCodecType("video");
       var frameRate = videoStream.frame_rate;
       var seg = {};
-      seg.audio = 29.76 * 48000;
       switch (frameRate) {
         case "24":
-          seg.video = 30 * sourceTimescale;
+          seg.video = sourceTimescale * 30;
           seg.keyint = 48;
           seg.duration = "30";
           break;
         case "25":
-          seg.video = 30 * sourceTimescale;
+          seg.video = sourceTimescale * 30;
           seg.keyint = 50;
           seg.duration = "30";
           break;
         case "30":
-          seg.video = 30 * sourceTimescale;
+          seg.video = sourceTimescale * 30;
           seg.keyint = 60;
           seg.duration = "30";
           break;
         case "30000/1001":
-          seg.video = 30.03 * sourceTimescale;
+          seg.video = sourceTimescale * 30;
           seg.keyint = 60;
           seg.duration = "30.03";
           break;
         case "48":
-          seg.video = 30 * sourceTimescale;
+          seg.video = sourceTimescale * 30;
           seg.keyint = 96;
           seg.duration = "30";
           break;
         case "50":
-          seg.video = 30 * sourceTimescale;
+          seg.video = sourceTimescale * 30;
           seg.keyint = 100;
           seg.duration = "30";
           break;
         case "60":
-          seg.video = 30 * sourceTimescale;
+          seg.video = sourceTimescale * 30;
           seg.keyint = 120;
           seg.duration = "30";
           break;
         case "60000/1001":
-          seg.video = 30.03 * sourceTimescale;
+          seg.videoTimeBase = 60000;
+          seg.video = seg.videoTimeBase * 30.03;
           seg.keyint = 120;
           seg.duration = "30.03";
           break;
         default:
-          console.log("Unsupported frame rate", frameRate);
+          throw "unsupported frame rate for MPEGTS - " + frameRate;
+          break;
+      }
+      return seg;
+    }
+  }, {
+    key: "calcSegDurationRtmp",
+    value: function calcSegDurationRtmp(_ref3) {
+      var sourceTimescale = _ref3.sourceTimescale;
+      var videoStream = this.getStreamDataForCodecType("video");
+      var frameRate = videoStream.frame_rate;
+      var seg = {};
+      switch (frameRate) {
+        case "24":
+          seg.video = sourceTimescale * 30;
+          seg.keyint = 48;
+          seg.duration = "30";
+          break;
+        case "25":
+          seg.video = sourceTimescale * 30;
+          seg.keyint = 50;
+          seg.duration = "30";
+          break;
+        case "30":
+          seg.video = sourceTimescale * 30;
+          seg.keyint = 60;
+          seg.duration = "30";
+          break;
+        case "30000/1001":
+          seg.video = sourceTimescale * 30.03;
+          seg.keyint = 60;
+          seg.duration = "30.03";
+          break;
+        case "48":
+          seg.video = sourceTimescale * 30;
+          seg.keyint = 96;
+          seg.duration = "30";
+          break;
+        case "50":
+          seg.video = sourceTimescale * 30;
+          seg.keyint = 100;
+          seg.duration = "30";
+          break;
+        case "60":
+          seg.video = sourceTimescale * 30;
+          seg.keyint = 120;
+          seg.duration = "30";
+          break;
+        case "60000/1001":
+          seg.video = sourceTimescale * 30.03;
+          seg.keyint = 120;
+          seg.duration = "30.03";
+          break;
+        default:
+          throw "unsupported frame rate for RTMP - " + frameRate;
           break;
       }
       return seg;
@@ -218,32 +332,33 @@ var LiveConf = /*#__PURE__*/function () {
       var videoStream = this.getStreamDataForCodecType("video");
       switch (this.probeKind()) {
         case "udp":
+        case "srt":
           sync_id = videoStream.stream_id;
           break;
         case "rtmp":
-          sync_id = -1; // Pending fabric API: videoStream.stream_index
+          sync_id = videoStream.stream_index;
           break;
       }
       return sync_id;
     }
   }, {
     key: "generateLiveConf",
-    value: function generateLiveConf(_ref2) {
-      var audioBitrate = _ref2.audioBitrate,
-        audioIndex = _ref2.audioIndex,
-        partTtl = _ref2.partTtl,
-        channelLayout = _ref2.channelLayout;
+    value: function generateLiveConf(_ref4) {
+      var audioBitrate = _ref4.audioBitrate,
+        audioIndex = _ref4.audioIndex,
+        partTtl = _ref4.partTtl,
+        channelLayout = _ref4.channelLayout;
       // gather required data
       var conf = JSON.parse(JSON.stringify(LiveconfTemplate));
       var fileName = this.overwriteOriginUrl || this.probeData.format.filename;
       var audioStream = this.getStreamDataForCodecType("audio");
       var sampleRate = parseInt(audioStream.sample_rate);
+      var audioCodec = audioStream.codec_name;
       var videoStream = this.getStreamDataForCodecType("video");
       var sourceTimescale;
-      console.log("AUDIO", audioStream);
-      console.log("VIDEO", videoStream);
 
       // Fill in liveconf all formats have in common
+      conf.live_recording.probe_info = this.probeData;
       conf.live_recording.fabric_config.ingress_node_api = this.nodeUrl || null;
       conf.live_recording.fabric_config.ingress_node_id = this.nodeId || null;
       conf.live_recording.recording_config.recording_params.description;
@@ -267,6 +382,11 @@ var LiveConf = /*#__PURE__*/function () {
           sourceTimescale = 90000;
           conf.live_recording.recording_config.recording_params.source_timescale = sourceTimescale;
           break;
+        case "srt":
+          sourceTimescale = 90000;
+          conf.live_recording.recording_config.recording_params.source_timescale = sourceTimescale;
+          conf.live_recording.recording_config.recording_params.live_delay_nano = 4000000000;
+          break;
         case "rtmp":
           sourceTimescale = 16000;
           conf.live_recording.recording_config.recording_params.source_timescale = sourceTimescale;
@@ -275,11 +395,13 @@ var LiveConf = /*#__PURE__*/function () {
           console.log("HLS detected. Not yet implemented");
           break;
         default:
-          console.log("Unsuppoted media", this.probeKind());
+          console.log("Unsupported media", this.probeKind());
           break;
       }
       var segDurations = this.calcSegDuration({
-        sourceTimescale: sourceTimescale
+        sourceTimescale: sourceTimescale,
+        sampleRate: sampleRate,
+        audioCodec: audioCodec
       });
 
       // Segment conditioning parameters
@@ -287,6 +409,15 @@ var LiveConf = /*#__PURE__*/function () {
       conf.live_recording.recording_config.recording_params.xc_params.audio_seg_duration_ts = segDurations.audio;
       conf.live_recording.recording_config.recording_params.xc_params.video_seg_duration_ts = segDurations.video;
       conf.live_recording.recording_config.recording_params.xc_params.force_keyint = segDurations.keyint;
+
+      // Optional override output timebase and frame duration (ts)
+      if (segDurations.videoTimeBase) {
+        conf.live_recording.recording_config.recording_params.xc_params.video_time_base = segDurations.videoTimeBase;
+        conf.live_recording.recording_config.recording_params.source_timescale = segDurations.videoTimeBase;
+      }
+      if (segDurations.videoFrameDurationTs) {
+        conf.live_recording.recording_config.recording_params.xc_params.video_frame_duration_ts = segDurations.videoFrameDurationTs;
+      }
       switch (videoStream.height) {
         case 2160:
           conf.live_recording.recording_config.recording_params.ladder_specs.unshift(LadderTemplate[2160], LadderTemplate[1080], LadderTemplate[720], LadderTemplate[540], LadderTemplate["540_low"]);