@eluvio/elv-client-js 4.0.46 → 4.0.48

package/package.json

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

package/src/ElvClient.js

@@ -20,6 +20,7 @@ const Pako = require("pako");
 const {
   ValidatePresence
 } = require("./Validation");
+const CBOR = require("cbor");
 
 const networks = {
   "main": "https://main.net955305.contentfabric.io",
@@ -565,6 +566,85 @@ class ElvClient {
     }
   }
 
+  /**
+   * Return a list of nodes in the content space, optionally filtered by node ID or endpoint.
+   *
+   * @methodGroup Nodes
+   * @namedParams
+   * @param {string} - matchEndpoint
+   * @param {string} - matchNodeId
+   *
+   * @return {Array<Object>} - A list of nodes in the space
+   */
+  async SpaceNodes({matchEndpoint, matchNodeId}) {
+    let bign = await this.CallContractMethod({
+      contractAddress: this.contentSpaceAddress,
+      methodName: "numActiveNodes",
+    });
+    let n = bign.toNumber();
+    let nodes = [];
+
+    for (let i = 0; i < n; i ++) {
+
+      let bigi = Ethers.BigNumber.from(i);
+      let addr = await this.CallContractMethod({
+        contractAddress: this.contentSpaceAddress,
+        methodName: "activeNodeAddresses",
+        methodArgs: [bigi],
+        formatArguments: true
+      });
+
+      let locatorsHex = await this.CallContractMethod({
+        contractAddress: this.contentSpaceAddress,
+        methodName: "activeNodeLocators",
+        methodArgs: [bigi]
+      });
+
+      let nodeId = this.utils.AddressToNodeId(addr);
+
+      if (matchNodeId != undefined && nodeId != matchNodeId) {
+        continue; // Not a match
+      }
+
+      let node = {id: nodeId, endpoints: []};
+
+      // Parse locators CBOR
+      let buffer = locatorsHex.slice(2, locatorsHex.length); // Skip "0x"
+      let hex = buffer.toString("hex");
+      let locators = CBOR.decodeAllSync(hex);
+
+      let match = false;
+
+      if(locators.length >= 5) {
+        let fabArray = locators[4].fab;
+        if(fabArray != undefined) {
+          for(let i = 0; i < fabArray.length; i ++) {
+            let host = fabArray[i].host;
+
+            if(matchEndpoint != undefined && !host.includes(matchEndpoint)) {
+              continue; // Not a match
+            }
+
+            match = true;
+            let endpoint = fabArray[i].scheme + "://" + host;
+
+            if(fabArray[i].port != "") {
+              endpoint = endpoint + ":" + fabArray[i].port;
+            }
+
+            endpoint = endpoint + "/" + fabArray[i].path;
+            node.endpoints.push(endpoint);
+          }
+        }
+      }
+      if(match) {
+        nodes.push(node);
+      }
+    }
+
+    return nodes;
+  }
+
   /**
    * Return information about how the client was connected to the network
    *
@@ -1201,6 +1281,7 @@ Object.assign(ElvClient.prototype, require("./client/ContentAccess"));
 Object.assign(ElvClient.prototype, require("./client/Contracts"));
 Object.assign(ElvClient.prototype, require("./client/Files"));
 Object.assign(ElvClient.prototype, require("./client/ABRPublishing"));
+Object.assign(ElvClient.prototype, require("./client/LiveStream"));
 Object.assign(ElvClient.prototype, require("./client/ContentManagement"));
 Object.assign(ElvClient.prototype, require("./client/NTP"));
 Object.assign(ElvClient.prototype, require("./client/NFT"));

package/src/FrameClient.js

@@ -470,7 +470,12 @@ class FrameClient {
       "SetStaticToken",
       "SetVisibility",
       "SetPermission",
+      "SpaceNodes",
       "StartABRMezzanineJobs",
+      "StreamConfig",
+      "StreamCreate",
+      "StreamStatus",
+      "StreamStartOrStopOrReset",
       "SuspendNTPInstance",
       "UnlinkAccessGroupFromOauth",
       "UpdateContentObjectGraph",
@@ -496,6 +501,7 @@ class FrameClient {
       "MergeUserMetadata",
       "PublicUserMetadata",
       "ReplaceUserMetadata",
+      "TenantContractId",
       "TenantId",
       "UserMetadata",
       "UserProfileImage",

package/src/HttpClient.js

@@ -171,8 +171,19 @@ class HttpClient {
   }
 
   URL({path, queryParams={}}) {
+    let baseURI = this.BaseURI();
+
+    // If URL contains a write token, it must go to the correct server and can not fail over
+    const writeTokenMatch = path.replace(/^\//, "").match(/(qlibs\/ilib[a-zA-Z0-9]+|q|qid)\/(tqw__[a-zA-Z0-9]+)/);
+    const writeToken = writeTokenMatch ? writeTokenMatch[2] : undefined;
+
+    if(writeToken && this.draftURIs[writeToken]) {
+      // Use saved write token URI
+      baseURI = this.draftURIs[writeToken];
+    }
+
     return (
-      this.BaseURI()
+      baseURI
         .path(path)
         .query(queryParams)
         .hash("")

package/src/UserProfileClient.js

@@ -469,6 +469,19 @@ await client.userProfileClient.UserMetadata()
     this.tenantId = id;
   }
 
+  /**
+   * Return the ID of the tenant contract this user belongs to, if set.
+   *
+   * @return {Promise<string>} - Tenant Contract ID
+   */
+  async TenantContractId() {
+    if(!this.tenantContractId) {
+      this.tenantContractId = await this.UserMetadata({metadataSubtree: "tenantContractId"});
+    }
+
+    return this.tenantContractId;
+  }
+
   /**
    * Get the URL of the current user's profile image
    *

package/src/Utils.js

@@ -315,6 +315,17 @@ const Utils = {
     return "ispc" + Utils.AddressToHash(address);
   },
 
+  /**
+   * Convert contract address to node ID
+   *
+   * @param {string} address - Address of contract
+   *
+   * @returns {string} - Node ID from contract address
+   */
+  AddressToNodeId: (address) => {
+    return "inod" + Utils.AddressToHash(address);
+  },
+
   /**
    * Convert contract address to content library ID
    *

package/src/Validation.js

@@ -41,7 +41,13 @@ exports.ValidateWriteToken = (writeToken) => {
 exports.ValidatePartHash = (partHash) => {
   if(!partHash) {
     throw Error("Part hash not specified");
-  } else if(!partHash.toString().startsWith("hqp_") && !partHash.toString().startsWith("hqpe")) {
+  }
+  else if(!partHash.toString().startsWith("hqp_") &&
+          !partHash.toString().startsWith("hqpe") &&
+          !partHash.toString().startsWith("hqt_") &&
+          !partHash.toString().startsWith("hqte") &&
+          !partHash.toString().startsWith("hql_") &&
+          !partHash.toString().startsWith("hqle")) {
     throw Error(`Invalid part hash: ${partHash}`);
   }
 };

package/src/client/ContentAccess.js

@@ -2144,7 +2144,7 @@ exports.ContentObjectImageUrl = async function({libraryId, objectId, versionHash
  * capLevelToPlayerSize - Caps video quality to player size
  * clipEnd - End time for the video
  * clipStart - Start time for the video
- * controls - Sets the player control visibility. Values: browserDefaul t | autoHide | show. Defaults to autoHide
+ * controls - Sets the player control visibility. Values: browserDefault | autoHide | show | hide | hideWithVolume. Defaults to autoHide
  * description - Sets the page description
  * directLink - If enabled, sets direct link
  * linkPath - Video link path
@@ -2175,6 +2175,13 @@ exports.EmbedUrl = async function({
   // Default options
   options.controls = options.controls === undefined ? "autoHide" : options.controls;
 
+  const controlsMap = {
+    autoHide: "h",
+    browserDefault: "d",
+    show: "s",
+    hideWithVolume: "hv"
+  };
+
   let embedUrl = new URL("https://embed.v3.contentfabric.io");
   const networkInfo = await this.NetworkInfo();
   const networkName = networkInfo.name === "demov3" ? "demo" : (networkInfo.name === "test" && networkInfo.id === 955205) ? "testv4" : networkInfo.name;
@@ -2207,7 +2214,9 @@ exports.EmbedUrl = async function({
         embedUrl.searchParams.set("start", options.clipStart);
         break;
       case "controls":
-        embedUrl.searchParams.set("ct", options.controls);
+        if(options.controls !== "hide") {
+          embedUrl.searchParams.set("ct", controlsMap[options.controls]);
+        }
         break;
       case "description":
         data["og:description"] = options.description;

package/src/client/LiveConf.js

@@ -0,0 +1,351 @@
+const LadderTemplate = {
+  "2160": {
+    bit_rate: 14000000,
+    codecs: "avc1.640028,mp4a.40.2",
+    height: 2160,
+    media_type: 1,
+    representation: "videovideo_3840x2160_h264@14000000",
+    stream_name: "video",
+    width: 3840
+  },
+  "1080": {
+    bit_rate: 9500000,
+    codecs: "avc1.640028,mp4a.40.2",
+    height: 1080,
+    media_type: 1,
+    representation: "videovideo_1920x1080_h264@9500000",
+    stream_name: "video",
+    width: 1920
+  },
+  "720": {
+    bit_rate: 4500000,
+    codecs: "avc1.640028,mp4a.40.2",
+    height: 720,
+    media_type: 1,
+    representation: "videovideo_1280x720_h264@4500000",
+    stream_name: "video",
+    width: 1280
+  },
+  "540": {
+    bit_rate: 2000000,
+    codecs: "avc1.640028,mp4a.40.2",
+    height: 540,
+    media_type: 1,
+    representation: "videovideo_960x540_h264@2000000",
+    stream_name: "video",
+    width: 960
+  },
+  "360": {
+    bit_rate: 520000,
+    codecs: "avc1.640028,mp4a.40.2",
+    height: 360,
+    media_type: 1,
+    representation: "videovideo_640x360_h264@520000",
+    stream_name: "video",
+    width: 640
+  }
+};
+
+const LiveconfTemplate = {
+  live_recording: {
+    fabric_config: {
+      ingress_node_api: "",
+      ingress_node_id: ""
+    },
+    playout_config: {
+      rebroadcast_start_time_sec_epoch: 0,
+      vod_enabled: false
+    },
+    recording_config: {
+      recording_params: {
+        description: "",
+        ladder_specs: [
+          {
+            bit_rate: 384000,
+            channels: 2,
+            codecs: "mp4a.40.2",
+            media_type: 2,
+            representation: "audioaudio_aac@384000",
+            stream_name: "audio"
+          }
+        ],
+        listen: true,
+        live_delay_nano: 2000000000,
+        max_duration_sec: -1,
+        name: "",
+        origin_url: "",
+        part_ttl: 3600,
+        playout_type: "live",
+        source_timescale: null,
+        xc_params: {
+          audio_bitrate: 384000,
+          audio_index: [
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0
+          ],
+          audio_seg_duration_ts: null,
+          ecodec2: "aac",
+          enc_height: null,
+          enc_width: null,
+          filter_descriptor: "",
+          force_keyint: null,
+          format: "fmp4-segment",
+          listen: true,
+          n_audio: 1,
+          preset: "faster",
+          sample_rate: 48000,
+          seg_duration: null,
+          skip_decoding: false,
+          start_segment_str: "1",
+          stream_id: -1,
+          sync_audio_to_stream_id: -1,
+          video_bitrate: null,
+          video_seg_duration_ts: null,
+          xc_type: 3
+        }
+      }
+    }
+  }
+};
+
+class LiveConf {
+  constructor(probeData, nodeId, nodeUrl, includeAVSegDurations, overwriteOriginUrl, syncAudioToVideo) {
+    this.probeData = probeData;
+    this.nodeId = nodeId;
+    this.nodeUrl = nodeUrl;
+    this.includeAVSegDurations = includeAVSegDurations;
+    this.overwriteOriginUrl = overwriteOriginUrl;
+    this.syncAudioToVideo = syncAudioToVideo;
+  }
+
+  probeKind() {
+    let fileNameSplit = this.probeData.format.filename.split(":");
+    return fileNameSplit[0];
+  }
+
+  getStreamDataForCodecType(codecType) {
+    let stream = null;
+    for (let index = 0; index < this.probeData.streams.length; index++) {
+      if(this.probeData.streams[index].codec_type == codecType) {
+        stream = this.probeData.streams[index];
+      }
+    }
+    return stream;
+  }
+
+  getFrameRate() {
+    let videoStream = this.getStreamDataForCodecType("video");
+    let frameRate = videoStream.r_frame_rate || videoStream.frame_rate;
+    return frameRate.split("/");
+  }
+
+  isFrameRateWhole() {
+    let frameRate = this.getFrameRate();
+    return frameRate[1] == "1";
+  }
+
+  getForceKeyint() {
+    let frameRate = this.getFrameRate();
+    let roundedFrameRate = Math.round(frameRate[0] / frameRate[1]);
+    if(roundedFrameRate > 30) {
+      return roundedFrameRate;
+    } else {
+      return roundedFrameRate * 2;
+    }
+  }
+
+  calcSegDuration({sourceTimescale}) {
+
+    let videoStream = this.getStreamDataForCodecType("video");
+    let frameRate = videoStream.frame_rate;
+
+    let seg ={};
+    switch (frameRate) {
+      case "24":
+        seg.video = 30 * sourceTimescale;
+        seg.audio = 30 * 48000;
+        seg.keyint = 48;
+        seg.duration = "30";
+        break;
+      case "25":
+        seg.video = 30 * sourceTimescale;
+        seg.audio = 30 * 48000;
+        seg.keyint = 50;
+        seg.duration = "30";
+        break;
+      case "30":
+        seg.video = 30 * sourceTimescale;
+        seg.audio = 30 * 48000;
+        seg.keyint = 60;
+        seg.duration = "30";
+        break;
+      case "30000/1001":
+        seg.video = 30.03 * sourceTimescale;
+        seg.audio = 29.76 * 48000;
+        seg.keyint = 60;
+        seg.duration = "30.03";
+        break;
+      case "48":
+        seg.video = 30 * sourceTimescale;
+        seg.audio = 30 * 48000;
+        seg.keyint = 96;
+        seg.duration = "30";
+        break;
+      case "50":
+        seg.video = 30 * sourceTimescale;
+        seg.audio = 30 * 48000;
+        seg.keyint = 100;
+        seg.duration = "30";
+        break;
+      case "60":
+        seg.video = 30 * sourceTimescale;
+        seg.audio = 30 * 48000;
+        seg.keyint = 120;
+        seg.duration = "30";
+        break;
+      case "60000/1001":
+        seg.video = 30.03 * sourceTimescale;
+        seg.audio = 29.76 * 48000;
+        seg.keyint = 120;
+        seg.duration = "30.03";
+        break;
+      default:
+        console.log("Unsupported frame rate", frameRate);
+        break;
+    }
+    return seg;
+  }
+
+  syncAudioToStreamIdValue() {
+    let sync_id = -1;
+    let videoStream = this.getStreamDataForCodecType("video");
+    switch (this.probeKind()) {
+      case "udp":
+        sync_id = videoStream.stream_id;
+        break;
+      case "rtmp":
+        sync_id = -1; // Pending fabric API: videoStream.stream_index
+        break;
+    }
+    return sync_id;
+  }
+
+  generateLiveConf() {
+    // gather required data
+    const conf = LiveconfTemplate;
+    const fileName = this.overwriteOriginUrl || this.probeData.format.filename;
+    const audioStream = this.getStreamDataForCodecType("audio");
+    const sampleRate = parseInt(audioStream.sample_rate);
+    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.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;
+    conf.live_recording.recording_config.recording_params.origin_url = fileName;
+    conf.live_recording.recording_config.recording_params.description = `Ingest stream ${fileName}`;
+    conf.live_recording.recording_config.recording_params.name = `Ingest stream ${fileName}`;
+    conf.live_recording.recording_config.recording_params.xc_params.audio_index[0] = audioStream.stream_index;
+    conf.live_recording.recording_config.recording_params.xc_params.sample_rate = sampleRate;
+    conf.live_recording.recording_config.recording_params.xc_params.enc_height = videoStream.height;
+    conf.live_recording.recording_config.recording_params.xc_params.enc_width = videoStream.width;
+
+    if(this.syncAudioToVideo) {
+      conf.live_recording.recording_config.recording_params.xc_params.sync_audio_to_stream_id = this.syncAudioToStreamIdValue();
+    }
+
+    // Fill in specifics for protocol
+    switch(this.probeKind()) {
+      case "udp":
+        sourceTimescale = 90000;
+        conf.live_recording.recording_config.recording_params.source_timescale = sourceTimescale;
+        break;
+      case "rtmp":
+        sourceTimescale = 16000;
+        conf.live_recording.recording_config.recording_params.source_timescale = sourceTimescale;
+        break;
+      case "hls":
+        console.log("HLS detected. Not yet implemented");
+        break;
+      default:
+        console.log("Unsuppoted media", this.probeKind());
+        break;
+    }
+
+    const segDurations = this.calcSegDuration({sourceTimescale});
+
+    // Segment conditioning parameters
+    conf.live_recording.recording_config.recording_params.xc_params.seg_duration = segDurations.duration;
+    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;
+
+    switch(videoStream.height) {
+      case 2160:
+        conf.live_recording.recording_config.recording_params.ladder_specs.unshift(
+          LadderTemplate[2160],
+          LadderTemplate[1080],
+          LadderTemplate[720],
+          LadderTemplate[540],
+          LadderTemplate[360]
+        );
+        conf.live_recording.recording_config.recording_params.xc_params.video_bitrate = LadderTemplate[2160].bit_rate;
+        conf.live_recording.recording_config.recording_params.xc_params.enc_height = 2160;
+        conf.live_recording.recording_config.recording_params.xc_params.enc_width = 3840;
+
+        break;
+      case 1080:
+        conf.live_recording.recording_config.recording_params.ladder_specs.unshift(
+          LadderTemplate[1080],
+          LadderTemplate[720],
+          LadderTemplate[540],
+          LadderTemplate[360]
+        );
+        conf.live_recording.recording_config.recording_params.xc_params.video_bitrate = LadderTemplate[1080].bit_rate;
+        conf.live_recording.recording_config.recording_params.xc_params.enc_height = 1080;
+        conf.live_recording.recording_config.recording_params.xc_params.enc_width = 1920;
+        break;
+      case 720:
+        conf.live_recording.recording_config.recording_params.ladder_specs.unshift(
+          LadderTemplate[720],
+          LadderTemplate[540],
+          LadderTemplate[360]
+        );
+        conf.live_recording.recording_config.recording_params.xc_params.video_bitrate = LadderTemplate[720].bit_rate;
+        conf.live_recording.recording_config.recording_params.xc_params.enc_height = 720;
+        conf.live_recording.recording_config.recording_params.xc_params.enc_width = 1280;
+        break;
+      case 540:
+        conf.live_recording.recording_config.recording_params.ladder_specs.unshift(
+          LadderTemplate[540],
+          LadderTemplate[360]
+        );
+        conf.live_recording.recording_config.recording_params.xc_params.video_bitrate = LadderTemplate[540].bit_rate;
+        conf.live_recording.recording_config.recording_params.xc_params.enc_height = 540;
+        conf.live_recording.recording_config.recording_params.xc_params.enc_width = 960;
+        break;
+      case 360:
+        conf.live_recording.recording_config.recording_params.ladder_specs.unshift(LadderTemplate[360]);
+        conf.live_recording.recording_config.recording_params.ladder_specs.unshift(LadderTemplate[360]);
+        conf.live_recording.recording_config.recording_params.xc_params.video_bitrate = LadderTemplate[360].bit_rate;
+        conf.live_recording.recording_config.recording_params.xc_params.enc_height = 360;
+        conf.live_recording.recording_config.recording_params.xc_params.enc_width = 640;
+        break;
+      default:
+        throw new Error("ERROR: Probed stream does not conform to one of the following built in resolution ladders [4096, 2160], [1920, 1080] [1280, 720], [960, 540], [640, 360]");
+    }
+
+    return JSON.stringify(conf, null, 2);
+  }
+}
+exports.LiveConf = LiveConf;