@eluvio/elv-client-js 4.0.77 → 4.0.78

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eluvio/elv-client-js",
-  "version": "4.0.77",
+  "version": "4.0.78",
   "description": "Javascript client for the Eluvio Content Fabric",
   "main": "src/index.js",
   "author": "Kevin Talmadge",

package/src/FrameClient.js

@@ -476,6 +476,7 @@ class FrameClient {
       "StartABRMezzanineJobs",
       "StreamConfig",
       "StreamCreate",
+      "StreamDeactivate",
       "StreamInitialize",
       "StreamInsertion",
       "StreamStatus",

package/src/client/ContentAccess.js

@@ -2176,6 +2176,11 @@ const EmbedMediaTypes = {
   - `showTitle` - Shows the video title, which is set from the title option (if set) or the metadata
   - `title` - Sets the page title
   - `viewRecordKey` - Contains record key
+  - `useTicketCodes` - Use tickets authorization
+  - `tenantId` - Tenant ID, required for tickets authorization
+  - `ntpId` - NTP ID, required for tickets authorization
+  - `ticketCode` - Ticket code, optional with tickets authorization
+  - `ticketSubject` - Ticket subject, optional with tickets authorization
  *
  * @returns {Promise<string>} - Will return an embed URL
  */
@@ -2279,6 +2284,22 @@ exports.EmbedUrl = async function({
       case "viewRecordKey":
         embedUrl.searchParams.set("vrk", options.viewRecordKey);
         break;
+      case "useTicketCodes":
+        embedUrl.searchParams.set("ptk", "");
+        if (options.tenantId) {
+          embedUrl.searchParams.set("ten", options.tenantId);
+        }
+        if (options.ntpId) {
+          embedUrl.searchParams.set("ntp", options.ntpId);
+        }
+        if (options.ticketCode) {
+          embedUrl.searchParams.set("tk", Buffer.from(options.ticketCode).toString("base64"));
+
+        }
+        if (options.ticketSubject) {
+          embedUrl.searchParams.set("sbj", Buffer.from(options.ticketSubject).toString("base64"));
+        }
+        break;
     }
   }
 

package/src/client/LiveConf.js

@@ -107,6 +107,7 @@ const LiveconfTemplate = {
           sync_audio_to_stream_id: -1,
           video_bitrate: null,
           video_seg_duration_ts: null,
+          video_time_base: null,
           xc_type: 3
         }
       }
@@ -160,56 +161,156 @@ class LiveConf {
     }
   }
 
-  calcSegDuration({sourceTimescale}) {
+  /*
+   * 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
+   */
+  calcSegDuration({sourceTimescale, sampleRate, audioCodec}) {
+    let seg = {};
+
+    switch(this.probeKind()) {
+      case "rtmp":
+        seg = this.calcSegDurationRtmp({sourceTimescale, sampleRate, audioCodec});
+        break;
+      case "udp":
+      case "srt":
+        seg = this.calcSegDurationMpegts({sourceTimescale, sampleRate, 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;
+  }
+
+  calcSegDurationMpegts({sourceTimescale}) {
     let videoStream = this.getStreamDataForCodecType("video");
     let frameRate = videoStream.frame_rate;
+    let 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;
+        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.videoTimeBase = 60000;
+        seg.video = seg.videoTimeBase * 30.03;
+        seg.keyint = 120;
+        seg.duration = "30.03";
+        break;
+      default:
+        throw "unsupported frame rate for MPEGTS - " + frameRate;
+        break;
+    }
+    return seg;
+  }
 
+  calcSegDurationRtmp({sourceTimescale}) {
+    let videoStream = this.getStreamDataForCodecType("video");
+    let frameRate = videoStream.frame_rate;
     let 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.03;
         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.video = sourceTimescale * 30.03;
         seg.keyint = 120;
         seg.duration = "30.03";
         break;
       default:
-        console.log("Unsupported frame rate", frameRate);
+        throw "unsupported frame rate for RTMP - " + frameRate;
         break;
     }
     return seg;
@@ -220,10 +321,11 @@ class LiveConf {
     let 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;
@@ -234,14 +336,14 @@ class LiveConf {
     const conf = JSON.parse(JSON.stringify(LiveconfTemplate));
     const fileName = this.overwriteOriginUrl || this.probeData.format.filename;
     const audioStream = this.getStreamDataForCodecType("audio");
+
     const sampleRate = parseInt(audioStream.sample_rate);
+    const audioCodec = audioStream.codec_name;
     const videoStream = this.getStreamDataForCodecType("video");
     let 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 +369,11 @@ class LiveConf {
         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;
@@ -279,7 +386,7 @@ class LiveConf {
         break;
     }
 
-    const segDurations = this.calcSegDuration({sourceTimescale});
+    const segDurations = this.calcSegDuration({sourceTimescale, sampleRate, audioCodec});
 
     // Segment conditioning parameters
     conf.live_recording.recording_config.recording_params.xc_params.seg_duration = segDurations.duration;
@@ -287,6 +394,15 @@ class LiveConf {
     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(

package/src/client/LiveStream.js

@@ -136,9 +136,9 @@ const StreamGenerateOffering = async({
   const maxStreamIndex = Math.max(aStreamIndex, vStreamIndex);
 
   for(let i = 0; i <= maxStreamIndex; i++) {
-    if (i === aStreamIndex) {
+    if(i === aStreamIndex) {
       sourceStreams.push(sourceAudioStream);
-    } else if (i === vStreamIndex) {
+    } else if(i === vStreamIndex) {
       sourceStreams.push(sourceVideoStream);
     } else {
       sourceStreams.push(DUMMY_STREAM);
@@ -242,12 +242,12 @@ const StreamGenerateOffering = async({
     abrProfile
   });
 
-  if (createResponse.warnings.length > 0) {
+  if(createResponse.warnings.length > 0) {
     console.log("WARNINGS:");
     console.log(JSON.stringify(createResponse.warnings, null, 2));
   }
 
-  if (createResponse.errors.length > 0) {
+  if(createResponse.errors.length > 0) {
     console.log("ERRORS:");
     console.log(JSON.stringify(createResponse.errors, null, 2));
   }
@@ -339,6 +339,8 @@ exports.StreamStatus = async function({name, stopLro=false, showParams=false}) {
       ]
     });
 
+    status.reference_url = mainMeta.live_recording_config.reference_url;
+
     if(mainMeta.live_recording_config == undefined || mainMeta.live_recording_config.url == undefined) {
       status.state = "unconfigured";
       return status;
@@ -367,7 +369,7 @@ exports.StreamStatus = async function({name, stopLro=false, showParams=false}) {
     status.url = mainMeta.live_recording.recording_config.recording_params.origin_url;
 
     let edgeWriteToken = mainMeta.live_recording.fabric_config.edge_write_token;
-    if(edgeWriteToken == undefined) {
+    if(!edgeWriteToken) {
       status.state = "inactive";
       return status;
     }
@@ -688,8 +690,6 @@ exports.StreamCreate = async function({name, start=false}) {
 */
 exports.StreamStartOrStopOrReset = async function({name, op}) {
   try {
-    console.log("Stream ", op, ": ", name);
-
     let status = await this.StreamStatus({name});
     if(status.state != "stopped") {
       if(op === "start") {
@@ -699,8 +699,6 @@ exports.StreamStartOrStopOrReset = async function({name, op}) {
     }
 
     if(status.state == "running" || status.state == "starting" || status.state == "stalled") {
-      console.log("STOPPING");
-
       try {
         await this.CallBitcodeMethod({
           libraryId: status.library_id,
@@ -834,7 +832,7 @@ exports.StreamStopSession = async function({name}) {
 
       // Wait until LRO is terminated
       let tries = 10;
-      while (status.state != "stopped" && tries-- > 0) {
+      while(status.state != "stopped" && tries-- > 0) {
         console.log("Wait to terminate - ", status.state);
         await Sleep(1000);
         status = await this.StreamStatus({name});
@@ -1202,7 +1200,7 @@ exports.StreamInsertion = async function({name, insertionTime, sinceStart=false,
     playout: "/qfab/" + targetHash + "/rep/playout"  // TO FIX - should be a link
   };
 
-  for (let i = 0; i < insertions.length; i ++) {
+  for(let i = 0; i < insertions.length; i ++) {
     if(insertions[i].insertion_time <= currentTime) {
       // Bad insertion - must be later than current time
       append(errs, "Bad insertion - time:", insertions[i].insertion_time);
@@ -1325,9 +1323,10 @@ exports.StreamConfig = async function({name, customSettings={}}) {
 
   let userConfig = mainMeta.live_recording_config;
   status.user_config = userConfig;
+  console.log("userConfig", userConfig);
 
   // Get node URI from user config
-  const hostName = userConfig.url.replace("udp://", "").replace("rtmp://", "").split(":")[0];
+  const hostName = userConfig.url.replace("udp://", "").replace("rtmp://", "").replace("srt://", "").split(":")[0];
   const streamUrl = new URL(userConfig.url);
 
   console.log("Retrieving nodes...");
@@ -1380,7 +1379,6 @@ exports.StreamConfig = async function({name, customSettings={}}) {
     }
   }
 
-  console.log("PROBE", probe);
   probe.format.filename = streamUrl.href;
 
   // Create live recording config
@@ -1410,14 +1408,6 @@ exports.StreamConfig = async function({name, customSettings={}}) {
     metadata: liveRecordingConfig.live_recording
   });
 
-  await this.ReplaceMetadata({
-    libraryId,
-    objectId: conf.objectId,
-    writeToken,
-    metadataSubtree: "probe",
-    metadata: probe
-  });
-
   status.fin = await this.FinalizeContentObject({
     libraryId,
     objectId: conf.objectId,
@@ -1427,3 +1417,100 @@ exports.StreamConfig = async function({name, customSettings={}}) {
 
   return status;
 };
+
+/**
+ * Deactivate the stream
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string} name - Object ID or name of the live stream object
+ *
+ * @return {Promise<Object>} - The status response for the stream
+ */
+exports.StreamDeactivate = async function({name}) {
+  try {
+    let conf = await this.LoadConf({name});
+
+    let {objectId} = conf;
+    let libraryId = await this.ContentObjectLibraryId({objectId});
+
+    let mainMeta = await this.ContentObjectMetadata({
+      libraryId,
+      objectId
+    });
+    let status = await this.StreamStatus({name});
+
+    if(!mainMeta.live_recording) {
+      return {
+        state: status.state,
+        error: "Stream must be configured before deactivating"
+      };
+    }
+
+    // Return error if the LRO is running
+    if(status.state !== "stopped") {
+      return {
+        state: status.state,
+        error: "Stream must be stopped before deactivating"
+      };
+    }
+
+    let fabURI = mainMeta.live_recording.fabric_config.ingress_node_api;
+    // Support both hostname and URL ingress_node_api
+    if(!fabURI.startsWith("http")) {
+      // Assume https
+      fabURI = "https://" + fabURI;
+    }
+
+    this.SetNodes({fabricURIs: [fabURI]});
+
+    let edgeWriteToken = mainMeta.live_recording.fabric_config.edge_write_token;
+
+    if(edgeWriteToken === undefined || edgeWriteToken === "") {
+      return {
+        state: "inactive",
+        error: "stream is already inactive"
+      };
+    }
+    let edgeMeta = await this.ContentObjectMetadata({
+      libraryId,
+      objectId,
+      writeToken: edgeWriteToken
+    });
+
+    // Set stop time
+    edgeMeta.recording_stop_time = Math.floor(new Date().getTime() / 1000);
+    const newState = "inactive";
+
+    edgeMeta.live_recording.status = {
+      state: newState,
+      recording_stop_time: edgeMeta.recording_stop_time
+    };
+
+    edgeMeta.live_recording.fabric_config.edge_write_token = "";
+
+    await this.ReplaceMetadata({
+      libraryId,
+      objectId,
+      writeToken: edgeWriteToken,
+      metadata: edgeMeta
+    });
+
+    let fin = await this.FinalizeContentObject({
+      libraryId,
+      objectId,
+      writeToken: edgeWriteToken,
+      commitMessage: "Deactivate stream"
+    });
+
+    return {
+      reference_url: status.reference_url,
+      fin,
+      name,
+      edge_write_token: edgeWriteToken,
+      state: newState
+    };
+  } catch(error) {
+    console.error(error);
+  }
+};

package/testScripts/Test.js

@@ -16,6 +16,13 @@ const Test = async () => {
     });
 
     client.SetSigner({signer});
+
+    const versionHash = "";
+
+    const url = await client.FabricUrl({
+      versionHash
+    });
+    console.log("url", url)
   } catch(error) {
     console.error(error);
     console.error(JSON.stringify(error, null, 2));