@eluvio/elv-client-js 4.2.16 → 4.2.17

package/dist/src/live_recording_config_profiles/live_recording_config_default.js

@@ -0,0 +1,45 @@
+var LiveRecordingConfigDefault = {
+  drm_type: "clear",
+  recording_config: {
+    part_ttl: 86400,
+    reconnect_timeout: 3600,
+    connection_timeout: 3600,
+    copy_mpegts: false
+  },
+  profile: {
+    ladder_specs: {
+      audio: [{
+        bit_rate: 192000,
+        channels: 2,
+        codecs: "mp4a.40.2"
+      }, {
+        bit_rate: 384000,
+        channels: 6,
+        codecs: "mp4a.40.2"
+      }],
+      video: [{
+        bit_rate: 9500000,
+        codecs: "avc1.640028,mp4a.40.2",
+        height: 1080,
+        width: 1920
+      }, {
+        bit_rate: 4500000,
+        codecs: "avc1.640028,mp4a.40.2",
+        height: 720,
+        width: 1280
+      }, {
+        bit_rate: 2000000,
+        codecs: "avc1.640028,mp4a.40.2",
+        height: 540,
+        width: 960
+      }, {
+        bit_rate: 900000,
+        codecs: "avc1.640028,mp4a.40.2",
+        height: 540,
+        width: 960
+      }]
+    },
+    name: "Default"
+  }
+};
+module.exports = LiveRecordingConfigDefault;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eluvio/elv-client-js",
-  "version": "4.2.16",
+  "version": "4.2.17",
   "description": "Javascript client for the Eluvio Content Fabric",
   "main": "src/index.js",
   "author": "Kevin Talmadge",
@@ -79,6 +79,7 @@
     "lodash": "^4.17.19",
     "lodash.isequal": "^4.5.0",
     "mime-types": "^2.1.24",
+    "moment": "^2.27.0",
     "multihashes": "^0.4.14",
     "node-fetch": "^2.6.7",
     "object-path": "^0.11.8",
@@ -112,7 +113,7 @@
     "eslint": "^9.32.0",
     "jsdoc": "^4.0.0",
     "jsdom": "^26.1.0",
-    "moment": "^2.27.0",
+    "mocha": "^11.7.5",
     "raw-loader": "^0.5.1",
     "shell-quote": "^1.7.2",
     "showdown": "^1.9.1",

package/src/FrameClient.js

@@ -447,6 +447,15 @@ class FrameClient {
       "Nodes",
       "NTPInstance",
       "ObjectCleanup",
+      "OutputsCreate",
+      "OutputsDelete",
+      "OutputsList",
+      "OutputsListItem",
+      "OutputsModify",
+      "OutputsModifyBatch",
+      "OutputsResolveSrtPullUrls",
+      "OutputsState",
+      "OutputsStop",
       "Permission",
       "PlayoutOptions",
       "PlayoutPathResolution",
@@ -472,6 +481,7 @@ class FrameClient {
       "RevokeShare",
       "SendFunds",
       "SetAccessCharge",
+      "StreamApplyProfile",
       "SetAuth",
       "SetAuthContext",
       "SetAuthPolicy",
@@ -496,17 +506,28 @@ class FrameClient {
       "SpaceNodes",
       "StartABRMezzanineJobs",
       "StreamAddWatermark",
+      "StreamApplyProfile",
+      "StreamAssignProfile",
       "StreamConfig",
+      "StreamConfigProfile",
+      "StreamConfigProfiles",
       "StreamCopyToVod",
       "StreamCreate",
       "StreamInitialize",
       "StreamInsertion",
+      "StreamLinkToSite",
       "StreamListUrls",
+      "StreamRemoveLinkToSite",
       "StreamRemoveWatermark",
+      "StreamSaveConfigProfile",
       "StreamSetOfferingAndDRM",
-      "StreamStatus",
+      "StreamSiteSettings",
+      "StreamStartRecording",
       "StreamStartOrStopOrReset",
-      "StreamStopSession",
+      "StreamStatus",
+      "StreamStopRecording",
+      "StreamUnassignProfile",
+      "StreamUpdateConfig",
       "SuspendNTPInstance",
       "TenantContractId",
       "TenantId",

package/src/abr_profiles/abr_profile_live_drm.js

@@ -1863,16 +1863,6 @@ const AbrProfileLiveDrm = {
     }
   },
   "playout_formats": {
-    "dash-playready-cenc": {
-      "drm": {
-        "enc_scheme_name": "cenc",
-        "type": "DrmPlayReady"
-      },
-      "protocol": {
-        "min_buffer_length": 2,
-        "type": "ProtoDash"
-      }
-    },
     "dash-widevine": {
       "drm": {
         "content_id": "",

package/src/client/ContentAccess.js

@@ -1804,7 +1804,6 @@ exports.GlobalUrl = async function({
     }
   }
 
-  console.log("Updated")
   let urlPath = UrlJoin("s", network);
   if(versionHash) {
     objectId = this.utils.DecodeVersionHash(versionHash).objectId;
@@ -2824,7 +2823,7 @@ exports.EncryptionConk = async function({libraryId, objectId, versionHash, write
   const owner = await this.authClient.Owner({id: objectId});
 
   const ownerCapKey = `eluv.caps.iusr${this.utils.AddressToHash(this.signer.address)}`;
-  const ownerCap = await this.ContentObjectMetadata({libraryId, objectId, versionHash, metadataSubtree: ownerCapKey});
+  const ownerCap = await this.ContentObjectMetadata({libraryId, objectId, versionHash, writeToken, metadataSubtree: ownerCapKey});
 
   if(!this.utils.EqualAddress(owner, this.signer.address) && !ownerCap) {
     if(download) {

package/src/client/LiveConf.js

@@ -1,7 +1,8 @@
 /* eslint no-console: 0 */
+const R = require("ramda");
 
 const DefaultABRLadder = {
-  "video" : [
+  "video": [
     {
       bit_rate: 14000000,
       codecs: "avc1.640028,mp4a.40.2",
@@ -33,7 +34,7 @@ const DefaultABRLadder = {
       width: 960
     }
   ],
-  "audio" : [
+  "audio": [
     {
       bit_rate: 192000,
       channels: 2,
@@ -55,8 +56,9 @@ const LiveconfTemplate = {
     },
     playout_config: {
       dvr_enabled: true,
-      dvr_max_duration: 0,
+      dvr_max_duration: 14400,
       rebroadcast_start_time_sec_epoch: 0,
+      playout_sharding_level: 2,
       vod_enabled: false
     },
     recording_config: {
@@ -64,11 +66,11 @@ const LiveconfTemplate = {
         description: "",
         ladder_specs: [],
         listen: true,
-        live_delay_nano: 2000000000,
+        live_delay_nano: 6000000000,
         max_duration_sec: -1,
         name: "",
         origin_url: "",
-        part_ttl: 3600,
+        part_ttl: 86400,
         playout_type: "live",
         source_timescale: null,
         reconnect_timeout: 600,
@@ -113,18 +115,49 @@ const LiveconfTemplate = {
 };
 
 class LiveConf {
-  constructor(probeData, nodeId, nodeUrl, includeAVSegDurations, overwriteOriginUrl, syncAudioToVideo) {
+  constructor({
+    url,
+    probeData,
+    nodeId,
+    nodeUrl,
+    includeAVSegDurations,
+    overwriteOriginUrl,
+    syncAudioToVideo,
+    liveRecordingMeta
+  }) {
+    this.url = url;
     this.probeData = probeData;
     this.nodeId = nodeId;
     this.nodeUrl = nodeUrl;
     this.includeAVSegDurations = includeAVSegDurations;
     this.overwriteOriginUrl = overwriteOriginUrl;
     this.syncAudioToVideo = syncAudioToVideo;
+    this.currentLiveRecordingMeta = liveRecordingMeta;
   }
 
-  probeKind() {
-    let fileNameSplit = this.probeData.format.filename.split(":");
-    return fileNameSplit[0];
+  getFormat() {
+    if (this.probeData.format.format_name) {
+      return this.probeData.format.format_name;
+    }
+    const fileNameSplit = this.probeData.format?.filename?.split(":");
+    if (fileNameSplit.length > 1) {
+      const protoScheme = fileNameSplit[0];
+      switch(protoScheme) {
+        case "rtmp":
+          return "flv";
+        case "udp":
+        case "rtp":
+        case "srt":
+          return "mpegts";
+        default:
+          return "format_unknown";
+      }
+    }
+  }
+
+  getProtocol() {
+    const protoScheme = this.url.split(":")[0];
+    return protoScheme;
   }
 
   getStreamDataForCodecType(codecType) {
@@ -139,16 +172,18 @@ class LiveConf {
 
   // Return all audio streams found in the probe
   // Used by generateAudioStreamsConfig()
-  getAudioStreamsFromProbe() {
-    let audioStreams = {};
+  getAudioStreamsFromProbe({ladderProfile}) {
+    const audioStreams = {};
     const audioStreamData = this.probeData.streams.filter((value) => value.codec_type === "audio");
 
     for(let index = 0; index < audioStreamData.length; index++) {
       const currentStreamIndex = audioStreamData[index].stream_index;
       const currentStreamData = audioStreamData[index];
 
+      const profileAudioForType = ladderProfile?.audio?.find(a => a.channels === currentStreamData.channels);
+
       audioStreams[currentStreamIndex] = {
-        recordingBitrate: Math.max(currentStreamData.bit_rate, 128000),
+        recordingBitrate: profileAudioForType?.bit_rate ?? Math.max(currentStreamData.bit_rate ?? 0, 12800),
         recordingChannels: currentStreamData.channels,
         playoutLabel: `Audio ${index + 1}`
       };
@@ -205,16 +240,15 @@ class LiveConf {
   calcSegDuration({sourceTimescale, sampleRate, audioCodec}) {
     let seg = {};
 
-    switch(this.probeKind()) {
-      case "rtmp":
+    switch(this.getFormat()) {
+      case "flv":
         seg = this.calcSegDurationRtmp({sourceTimescale, sampleRate, audioCodec});
         break;
-      case "udp":
-      case "srt":
+      case "mpegts":
         seg = this.calcSegDurationMpegts({sourceTimescale, sampleRate, audioCodec});
         break;
       default:
-        throw "protocol not supported - " + this.probeKind();
+        throw "protocol not supported - " + this.getFormat();
     }
 
     if(audioCodec == "aac") {
@@ -362,32 +396,79 @@ class LiveConf {
   syncAudioToStreamIdValue() {
     let sync_id = -1;
     let videoStream = this.getStreamDataForCodecType("video");
-    switch(this.probeKind()) {
-      case "udp":
-      case "srt":
+    switch(this.getFormat()) {
+      case "mpegts":
         sync_id = videoStream.stream_id;
         break;
-      case "rtmp":
+      case "flv":
         sync_id = videoStream.stream_index;
         break;
     }
     return sync_id;
   }
 
+  /**
+   * Map custom live recording profile to the expected config structure
+   * @param {Object} customProfile - User's custom recording profile
+   * @return {Object} - Mapped config in live_recording format
+   */
+  MapCustomProfileToLiveConfig({customProfile}) {
+    if(!customProfile) return {};
+
+    const CompactDeep = (obj) => {
+      if(obj === null || typeof obj !== "object" || Array.isArray(obj)) {
+        return obj;
+      }
+
+      return R.pipe(
+        R.reject(R.isNil),
+        R.map(val => typeof val === "object" ? CompactDeep(val) : val)
+      )(obj);
+    };
+
+    const {recording_config, recording_params, ...rest} = customProfile;
+
+    return CompactDeep({
+      live_recording: {
+        ...rest,
+        recording_config: {
+          recording_params: {
+            ...recording_params,
+            part_ttl: recording_config?.part_ttl,
+            reconnect_timeout: recording_config?.reconnect_timeout,
+            xc_params: {
+              ...(recording_params?.xc_params || {}),
+              connection_timeout: recording_config?.connection_timeout,
+              copy_mpegts: recording_config?.copy_mpegts,
+              input_cfg: recording_config?.input_cfg
+            }
+          }
+        }
+      }
+    });
+  }
+
   /*
   * Generate audio streams recording configuration based on the optional custom settings.
   * If no custom "audio" section is present, record all the acceptable audio streams found in the probe
   */
-  generateAudioStreamsConfig({customSettings}) {
+  generateAudioStreamsConfig({liveRecordingConfigProfile}) {
+    const ladderProfile = liveRecordingConfigProfile?.playout_config?.ladder_specs || DefaultABRLadder;
+    const audioSettings = liveRecordingConfigProfile?.recording_stream_config?.audio;
 
     let audioStreams = {};
-    if(customSettings && customSettings.audio && Object.keys(customSettings.audio).length > 0) {
-      for(let i = 0; i < Object.keys(customSettings.audio).length; i ++) {
-        let audioIdx = Object.keys(customSettings.audio)[i];
-        let audio = customSettings.audio[audioIdx];
+
+    if(audioSettings && Object.keys(audioSettings).length > 0) {
+      for(let i = 0; i < Object.keys(audioSettings).length; i ++) {
+        const audioIdx = Object.keys(audioSettings)[i];
+        const audio = audioSettings[audioIdx];
+        const profileAudioForType = ladderProfile?.audio.find(a => a.channels === (audio.channels ?? 2));
+
         audioStreams[audioIdx] = {
-          recordingBitrate: audio.recording_bitrate || 192000,
+          recordingBitrate: ladderProfile?.audio ? profileAudioForType.bit_rate : audio.recording_bitrate ?? 192000,
           recordingChannels: audio.recording_channels || 2,
+          lang: audio.lang,
+          isDefault: audio.default
         };
         if(audio.playout) {
           audioStreams[audioIdx].playoutLabel = audio.playout_label || `Audio ${i + 1}`;
@@ -396,21 +477,34 @@ class LiveConf {
     }
 
     // If no audio streams specified in custom config, set up all the suitable audio streams in the probe
-    if(!customSettings.audio || Object.keys(customSettings.audio).length == 0) {
-      audioStreams = this.getAudioStreamsFromProbe();
+    if(!audioSettings || Object.keys(audioSettings).length === 0) {
+      audioStreams = this.getAudioStreamsFromProbe({ladderProfile});
     }
 
     return audioStreams;
   }
 
   /*
-  * Generate the live recording config as required by QFAB, based on defaults and optional custom settings.
+  * Generate the live recording config as required by QFAB, based on defaults, existing settings and optional custom settings.
   */
   generateLiveConf({customSettings}) {
-    // gather required data
-    const conf = JSON.parse(JSON.stringify(LiveconfTemplate));
-    const fileName = this.overwriteOriginUrl || this.probeData.format.filename;
-    const audioStreams = this.generateAudioStreamsConfig({customSettings});
+    // Saved config overrides defaults and is preserved on reconfiguration
+    let conf = R.clone(LiveconfTemplate);
+
+    if(this.currentLiveRecordingMeta) {
+      conf = R.mergeDeepRight(conf,
+        {live_recording: this.currentLiveRecordingMeta});
+    }
+
+    if(customSettings.liveRecordingConfigProfile) {
+      conf = R.mergeDeepRight(conf,
+        this.MapCustomProfileToLiveConfig({
+          customProfile: customSettings.liveRecordingConfigProfile
+        }));
+    }
+
+    const fileName = this.url;
+    const audioStreams = this.generateAudioStreamsConfig({liveRecordingConfigProfile: customSettings.liveRecordingConfigProfile});
 
     // Retrieve one audio stream from the probe to read the sample rate and codec name
     const audioStream = this.getStreamDataForCodecType("audio");
@@ -440,15 +534,10 @@ class LiveConf {
     }
 
     // Fill in specifics for protocol
-    switch(this.probeKind()) {
-      case "udp":
-        sourceTimescale = 90000;
-        conf.live_recording.recording_config.recording_params.source_timescale = sourceTimescale;
-        break;
-      case "srt":
+    switch(this.getFormat()) {
+      case "mpegts":
         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;
@@ -458,7 +547,15 @@ class LiveConf {
         console.log("HLS detected. Not yet implemented");
         break;
       default:
-        console.log("Unsupported media", this.probeKind());
+        console.log("Unsupported media", this.getFormat());
+        break;
+    }
+
+    switch(this.getProtocol()) {
+      case "srt":
+        if(!customSettings.liveRecordingConfigProfile?.recording_params?.live_delay_nano) {
+          conf.live_recording.recording_config.recording_params.live_delay_nano = 6000000000;
+        }
         break;
     }
 
@@ -481,11 +578,15 @@ class LiveConf {
       conf.live_recording.recording_config.recording_params.xc_params.video_frame_duration_ts = segDurations.videoFrameDurationTs;
     }
 
-    const ladderProfile = customSettings.ladder_profile || DefaultABRLadder;
+    const ladder_specs = customSettings.liveRecordingConfigProfile?.playout_config?.ladder_specs;
+    const ladderProfile = ladder_specs?.video?.length > 0 ? ladder_specs : DefaultABRLadder;
 
     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;
 
+    // Reset ladder specs (updating existing stream will carry over old specs
+    conf.live_recording.recording_config.recording_params.ladder_specs = [];
+
     // Determine video recording bitrate and ABR ladder
     let topLadderRate = 0;
     for(let i = 0; i < ladderProfile.video.length; i ++) {
@@ -521,6 +622,7 @@ class LiveConf {
           break;
         }
       }
+
       if(Object.keys(audioLadderSpec).length === 0) {
         // If no channels layout match, just use the first element in the ladder
         audioLadderSpec = {...ladderProfile.audio[0]};
@@ -532,8 +634,10 @@ class LiveConf {
       audioLadderSpec.stream_name = `audio_${audioIndex}`;
       audioLadderSpec.stream_label = audio.playoutLabel ? audio.playoutLabel : null;
       audioLadderSpec.media_type = 2;
+      audioLadderSpec.lang = audio.lang ?? "";
 
-      if(Object.keys(audioStreams).length === 1) {
+
+      if(Object.keys(audioStreams).length === 1 || audio.isDefault) {
         audioLadderSpec.default = true;
       }
 
@@ -541,33 +645,13 @@ class LiveConf {
       if(audio.recordingBitrate > globalAudioBitrate) {
         globalAudioBitrate = audio.recordingBitrate;
       }
-      nAudio ++;
+      nAudio++;
     }
 
     // Global recording bitrate for all audio streams
     conf.live_recording.recording_config.recording_params.xc_params.audio_bitrate = globalAudioBitrate;
     conf.live_recording.recording_config.recording_params.xc_params.n_audio = nAudio;
 
-    // Iterate through custom settings (which will override any existing setting)
-    function SetByPath({obj, path, value}) {
-      const keys = path.split(".");
-      let temp = obj;
-      for(let i = 0; i < keys.length - 1; i++) {
-        if(!temp[keys[i]]) {
-          temp[keys[i]] = {};
-        }
-        temp = temp[keys[i]];
-      }
-
-      temp[keys[keys.length - 1]] = value;
-    }
-
-    const {metaPathValues} = customSettings;
-
-    for(let [path, value] of Object.entries(metaPathValues || {})) {
-      SetByPath({obj: conf, path, value});
-    }
-
     return conf;
   }
 }