@eluvio/elv-client-js 4.0.104 → 4.0.107

package/src/client/LiveConf.js

@@ -1,53 +1,48 @@
-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",
-    stream_index: 0,
-    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",
-    stream_index: 0,
-    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",
-    stream_index: 0,
-    width: 960
-  },
-  "540_low": {
-    bit_rate: 900000,
-    codecs: "avc1.640028,mp4a.40.2",
-    height: 540,
-    media_type: 1,
-    representation: "videovideo_960x540_h264@900000",
-    stream_name: "video",
-    stream_index: 0,
-    width: 960
-  }
+const DefaultABRLadder = {
+  "video" : [
+    {
+      bit_rate: 14000000,
+      codecs: "avc1.640028,mp4a.40.2",
+      height: 2160,
+      width: 3840
+    },
+    {
+      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
+    }
+  ],
+  "audio" : [
+    {
+      bit_rate: 192000,
+      channels: 2,
+      codecs: "mp4a.40.2",
+    },
+    {
+      bit_rate: 384000,
+      channels: 6,
+      codecs: "mp4a.40.2",
+    }
+  ]
 };
 
 const LiveconfTemplate = {
@@ -115,16 +110,6 @@ const LiveconfTemplate = {
   }
 };
 
-const LadderSpecAudio = {
-  bit_rate: 384000,
-  channels: 2,
-  codecs: "mp4a.40.2",
-  media_type: 2,
-  representation: "audioaudio_aac@384000",
-  stream_name: "audio",
-  stream_index: 0
-};
-
 class LiveConf {
   constructor(probeData, nodeId, nodeUrl, includeAVSegDurations, overwriteOriginUrl, syncAudioToVideo) {
     this.probeData = probeData;
@@ -390,7 +375,7 @@ class LiveConf {
   generateAudioStreamsConfig({customSettings}) {
 
     let audioStreams = {};
-    if(customSettings && customSettings.audio) {
+    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];
@@ -405,7 +390,7 @@ class LiveConf {
     }
 
     // If no audio streams specified in custom config, set up all the suitable audio streams in the probe
-    if(!customSettings.audio) {
+    if(!customSettings.audio || Object.keys(customSettings.audio).length == 0) {
       audioStreams = this.getAudioStreamsFromProbe();
     }
 
@@ -506,68 +491,57 @@ class LiveConf {
       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"]
-        );
-        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;
+    const ladderProfile = customSettings.ladder_profile || DefaultABRLadder;
 
-        break;
-      case 1080:
-        conf.live_recording.recording_config.recording_params.ladder_specs.unshift(
-          LadderTemplate[1080],
-          LadderTemplate[720],
-          LadderTemplate[540],
-          LadderTemplate["540_low"]
-        );
-        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["540_low"]
-        );
-        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["540_low"]
-        );
-        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;
-      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]");
-    }
+    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;
 
+    // Determine video recording bitrate and ABR ladder
+    let topLadderRate = 0
+    for (let i = 0; i < ladderProfile.video.length; i ++) {
+      let elem = ladderProfile.video[i];
+      if (elem.height > videoStream.height)
+        continue;
+      if (elem.bit_rate > topLadderRate) {
+        topLadderRate = elem.bit_rate
+      }
+      elem.media_type = 1;
+      elem.stream_name = "video";
+      elem.stream_index = 0;
+      elem.representation = "videovideo_" + elem.width + "x" + elem.height + "_h264@" + elem.bit_rate;
+      conf.live_recording.recording_config.recording_params.ladder_specs.push(elem);
+    }
+    // Currently the recording bitrate is the top bitrate of the ladder (it will be configurable separately in the future)
+    conf.live_recording.recording_config.recording_params.xc_params.video_bitrate = topLadderRate;
 
+    // Determine audio recording bitrate and ABR ladder
     let globalAudioBitrate = 0;
     let nAudio = 0;
 
     for(let i = 0; i < Object.keys(audioStreams).length; i ++ ) {
-      let audioLadderSpec = {...LadderSpecAudio};
+      let audioLadderSpec = {};
       const audioIndex = Object.keys(audioStreams)[i];
       const audio = audioStreams[audioIndex];
-      audioLadderSpec.bit_rate = audio.recordingBitrate;
-      audioLadderSpec.representation = `audioaudio_aac@${audio.recordingBitrate}`;
+
+      // Find ladder rung for the specific channel layout (2 or 6 channels)
+      for (let j = 0; j < ladderProfile.audio.length; j ++) {
+        let elem = ladderProfile.audio[j];
+        if (elem.channels == audio.recordingChannels) {
+          audioLadderSpec = {...elem};
+          break;
+        }
+      }
+      if (Object.keys(audioLadderSpec).length === 0) {
+        // If no channels layout match, just use the first element in the ladder
+        audioLadderSpec = {...ladderProfile.audio[0]};
+      }
+
+      audioLadderSpec.representation = `audioaudio_aac@${audioLadderSpec.bit_rate}`;
       audioLadderSpec.channels = audio.recordingChannels;
       audioLadderSpec.stream_index = parseInt(audioIndex);
       audioLadderSpec.stream_name = `audio_${audioIndex}`;
       audioLadderSpec.stream_label = audio.playoutLabel ? audio.playoutLabel : null;
+      audioLadderSpec.media_type = 2;
 
       conf.live_recording.recording_config.recording_params.ladder_specs.push(audioLadderSpec);
       if(audio.recordingBitrate > globalAudioBitrate) {
@@ -583,4 +557,5 @@ class LiveConf {
     return conf;
   }
 }
+
 exports.LiveConf = LiveConf;

package/src/client/LiveStream.js

@@ -415,16 +415,23 @@ exports.StreamStatus = async function({name, stopLro=false, showParams=false}) {
 
     status.edge_write_token = edgeWriteToken;
     status.stream_id = edgeWriteToken; // By convention the stream ID is its write token
-    let edgeMeta = await this.ContentObjectMetadata({
-      libraryId: libraryId,
-      objectId: objectId,
-      writeToken: edgeWriteToken,
-      select: [
-        "live_recording"
-      ]
-    });
+    let edgeMeta;
+    try {
+      edgeMeta = await this.ContentObjectMetadata({
+        libraryId: libraryId,
+        objectId: objectId,
+        writeToken: edgeWriteToken,
+        select: [
+          "live_recording"
+        ]
+      });
+    } catch(error) {
+      console.error("Unable to read edge write token metadata. Has token been deleted?", error);
+      status.state = "inactive";
+      return status;
+    }
 
-    status.edge_meta_size = JSON.stringify(edgeMeta).length;
+    status.edge_meta_size = JSON.stringify(edgeMeta || "").length;
 
     // If a stream has never been started return state 'inactive'
     if(edgeMeta.live_recording === undefined ||
@@ -1030,6 +1037,18 @@ exports.StreamSetOfferingAndDRM = async function({name, typeAbrMaster, typeLiveS
         };
         continue;
       }
+      if(formats[i] === "dash-clear") {
+        abrProfile.drm_optional = true;
+        playoutFormats["dash-clear"] = {
+          "drm": null,
+          "protocol": {
+            "min_buffer_length": 2,
+            "type": "ProtoDash"
+          }
+        }
+        continue;
+      }
+
       playoutFormats[formats[i]] = abrProfile.playout_formats[formats[i]];
     }
   } else if(!drm) {
@@ -1040,6 +1059,13 @@ exports.StreamSetOfferingAndDRM = async function({name, typeAbrMaster, typeLiveS
         "protocol": {
           "type": "ProtoHls"
         }
+      },
+      "dash-clear": {
+        "drm": null,
+        "protocol": {
+          "min_buffer_length": 2,
+          "type": "ProtoDash"
+        }
       }
     };
   } else {
@@ -1766,26 +1792,36 @@ exports.StreamCopyToVod = async function({
  *
  * @methodGroup Live Stream
  * @namedParams
+ * @param {string=} libraryId - Library ID of the live stream
  * @param {string} objectId - Object ID of the live stream
+ * @param {string=} writeToken - Write token of the draft
  * @param {Array<string>} types - Specify which type of watermark to remove. Possible values:
  * - "image"
  * - "text"
+ * - "forensic"
  * @param {boolean=} finalize - If enabled, target object will be finalized after removing watermark
  *
  * @return {Promise<Object>} - The finalize response
  */
 exports.StreamRemoveWatermark = async function({
+  libraryId,
   objectId,
+  writeToken,
   types,
   finalize=true
 }) {
   ValidateObject(objectId);
 
-  const libraryId = await this.ContentObjectLibraryId({objectId});
-  const {writeToken} = await this.EditContentObject({
-    objectId,
-    libraryId
-  });
+  if(!libraryId) {
+    libraryId = await this.ContentObjectLibraryId({objectId});
+  }
+
+  if(!writeToken) {
+    ({writeToken} = await this.EditContentObject({
+      objectId,
+      libraryId
+    }));
+  }
 
   this.Log(`Removing watermark types: ${types.join(", ")} ${libraryId} ${objectId}`);
 
@@ -1795,25 +1831,27 @@ exports.StreamRemoveWatermark = async function({
     metadataSubtree: "/live_recording/fabric_config/edge_write_token"
   });
 
-  const recordingParamsPath = "live_recording/recording_config/recording_params";
+  const metadataPath = "live_recording/playout_config";
 
-  const recordingMetadata = await this.ContentObjectMetadata({
+  const objectMetadata = await this.ContentObjectMetadata({
     libraryId,
     objectId,
     writeToken,
-    metadataSubtree: recordingParamsPath,
+    metadataSubtree: metadataPath,
     resolveLinks: false
   });
 
-  if(!recordingMetadata) {
-    throw Error("Stream object must be configured");
+  if(!objectMetadata) {
+    throw Error("Stream object must be configured before removing a watermark");
   }
 
   types.forEach(type => {
     if(type === "text") {
-      delete recordingMetadata.simple_watermark;
+      delete objectMetadata.simple_watermark;
     } else if(type === "image") {
-      delete recordingMetadata.image_watermark;
+      delete objectMetadata.image_watermark;
+    } else if(type === "forensic") {
+      delete objectMetadata.forensic_watermark;
     }
   });
 
@@ -1821,8 +1859,8 @@ exports.StreamRemoveWatermark = async function({
     libraryId,
     objectId,
     writeToken,
-    metadataSubtree: recordingParamsPath,
-    metadata: recordingMetadata
+    metadataSubtree: metadataPath,
+    metadata: objectMetadata
   });
 
   if(edgeWriteToken) {
@@ -1830,8 +1868,8 @@ exports.StreamRemoveWatermark = async function({
       libraryId,
       objectId,
       writeToken: edgeWriteToken,
-      metadataSubtree: recordingParamsPath,
-      metadata: recordingMetadata
+      metadataSubtree: metadataPath,
+      metadata: objectMetadata
     });
   }
 
@@ -1852,26 +1890,72 @@ exports.StreamRemoveWatermark = async function({
  *
  * @methodGroup Live Stream
  * @namedParams
+ * @param {string=} libraryId - Library ID of the live stream
  * @param {string} objectId - Object ID of the live stream
+ * @param {string=} writeToken - Write token of the draft
  * @param {Object} simpleWatermark - Text watermark
  * @param {Object} imageWatermark - Image watermark
+ * @param {Object} forensicWatermark - Forensic watermark
  * @param {boolean=} finalize - If enabled, target object will be finalized after adding watermark
+ * Watermark examples:
+ *
+ * Simple Watermark:
+   {
+     "font_color": "",
+     "font_relative_height": 0,
+     "shadow": false,
+     "template": "",
+     "timecode": "",
+     "timecode_rate": 0,
+     "x": "",
+     "y": ""
+   }
+ *
+ * Image watermark:
+   {
+     "image": "",
+     "align_h": "",
+     "align_v": "",
+     "target_video_height": 0,
+     "wm_enabled": false
+   }
+ *
+ * Forensic watermark:
+   {
+     "algo": 6,
+     "forensic_duration": 0,
+     "forensic_start": "",
+     "image_a": <path_to_image>,
+     "image_b": <path_to_image>,
+     "is_stub": true,
+     "payload_bit_nb": 23,
+     "wm_enabled": true
+   }
+ *
  *
  * @return {Promise<Object>} - The finalize response
  */
 exports.StreamAddWatermark = async function({
+  libraryId,
   objectId,
+  writeToken,
   simpleWatermark,
   imageWatermark,
+  forensicWatermark,
   finalize=true
 }) {
   ValidateObject(objectId);
 
-  const libraryId = await this.ContentObjectLibraryId({objectId});
-  const {writeToken} = await this.EditContentObject({
-    objectId,
-    libraryId
-  });
+  if(!libraryId) {
+    libraryId = await this.ContentObjectLibraryId({objectId});
+  }
+
+  if(!writeToken) {
+    ({writeToken} = await this.EditContentObject({
+      objectId,
+      libraryId
+    }));
+  }
 
   const edgeWriteToken = await this.ContentObjectMetadata({
     objectId,
@@ -1879,34 +1963,46 @@ exports.StreamAddWatermark = async function({
     metadataSubtree: "/live_recording/fabric_config/edge_write_token"
   });
 
-  this.Log(`Adding watermarking type: ${imageWatermark ? "image" : "text"} ${libraryId} ${objectId}`);
+  const watermarkType = imageWatermark ? "image" : forensicWatermark ? "forensic" : "text";
+  const metadataPath = "live_recording/playout_config";
 
-  const recordingParamsPath = "live_recording/recording_config/recording_params";
+  this.Log(`Adding watermarking type: ${watermarkType} ${libraryId} ${objectId}`);
 
-  const recordingMetadata = await this.ContentObjectMetadata({
+  const objectMetadata = await this.ContentObjectMetadata({
     libraryId,
     objectId,
     writeToken,
-    metadataSubtree: recordingParamsPath,
+    metadataSubtree: metadataPath,
     resolveLinks: false
   });
 
-  if(!recordingMetadata) {
-    throw Error("Stream object must be configured");
+  if(!objectMetadata) {
+    throw Error("Stream object must be configured before adding a watermark");
+  }
+
+  const watermarkArgCount = [simpleWatermark, imageWatermark, forensicWatermark].filter(i => !!i).length;
+  console.log("watermark arg count", watermarkArgCount)
+
+  if(watermarkArgCount === 0) {
+    throw Error("No watermark was provided");
+  } else if(watermarkArgCount > 1) {
+    throw Error("Only one watermark is allowed")
   }
 
   if(simpleWatermark) {
-    recordingMetadata.simple_watermark = simpleWatermark;
+    objectMetadata.simple_watermark = simpleWatermark;
   } else if(imageWatermark) {
-    recordingMetadata.image_watermark = imageWatermark;
+    objectMetadata.image_watermark = imageWatermark;
+  } else if(forensicWatermark) {
+    objectMetadata.forensic_watermark = forensicWatermark;
   }
 
   await this.ReplaceMetadata({
     libraryId,
     objectId,
     writeToken,
-    metadataSubtree: recordingParamsPath,
-    metadata: recordingMetadata
+    metadataSubtree: metadataPath,
+    metadata: objectMetadata
   });
 
   if(edgeWriteToken) {
@@ -1914,14 +2010,15 @@ exports.StreamAddWatermark = async function({
       libraryId,
       objectId,
       writeToken: edgeWriteToken,
-      metadataSubtree: recordingParamsPath,
-      metadata: recordingMetadata
+      metadataSubtree: metadataPath,
+      metadata: objectMetadata
     });
   }
 
   const response = {
-    "imageWatermark": recordingMetadata.image_watermark,
-    "textWatermark": recordingMetadata.simple_watermark
+    "imageWatermark": objectMetadata.image_watermark,
+    "textWatermark": objectMetadata.simple_watermark,
+    "forensicWatermark": objectMetadata.forensic_watermark
   };
 
   if(finalize) {

package/testScripts/TestAddTenantContractId.js

@@ -7,15 +7,28 @@ const argv = yargs
     description: "Fabric configuration URL (e.g. https://main.net955210.contentfabric.io/config)"
   })
   .option("tenantContractId", {
-    description: "tenant Contract Id to set for the user"
+    description: "tenant Contract Id to set for the objects"
+  })
+  .option("tenantIdToBeReplaced", {
+    description: "tenant Id to be changed for the objects"
   })
   .demandOption(
-    ["configUrl", "tenantContractId"],
-    "\nUsage: PRIVATE_KEY=<private-key> node CreateUserWithTenantId --configUrl <config-url> --tenantContractId <tenant_id>\n"
+    ["configUrl", "tenantContractId", "tenantIdToBeReplaced" ],
+    "\nUsage: PRIVATE_KEY=<private-key> node TestAddTenantContractId --configUrl <config-url> --tenantContractId <tenant_contract_id> --tenantIdToBeReplaced <tenant_id>\n"
   )
   .argv;
 
-const TestAddTenantContractId = async ({configUrl, tenantContractId}) => {
+/**
+ * TestAddTenantContractId adds tenantContractId to wallet,library,group,content-type object
+ * and change tenantId to value provided.
+ *
+ * @param {string} configUrl - Config Url
+ * @param {string} tenantContractId - Id of tenantContract to be set
+ * @param {string} tenantIdToBeReplaced - Id of tenant admin group to be replaced
+ * @returns {Promise<void>}
+ * @constructor
+ */
+const TestAddTenantContractId = async ({configUrl, tenantContractId, tenantIdToBeReplaced}) => {
   try {
     if(!process.env.PRIVATE_KEY) {
       console.log("ERROR: 'PRIVATE_KEY' environment variable must be set");
@@ -79,6 +92,34 @@ const TestAddTenantContractId = async ({configUrl, tenantContractId}) => {
     //   libraryId: client.contentSpaceLibraryId,
     //   objectId: client.utils.AddressToObjectId(groupAddress)}));
 
+
+    // Change tenantID (which in turn changes tenantContractId) to user, group, library and content-type
+    await client.userProfileClient.SetTenantId({id: tenantIdToBeReplaced});
+    const newTenantId = await client.userProfileClient.TenantId();
+    if(newTenantId !== tenantIdToBeReplaced) {
+      throw Error(`tenant mismatch, actual: ${tenantInfo.tenantId}, expected: ${tenantIdToBeReplaced}`);
+    }
+    console.log();
+    console.log(`tenantId for user changed to ${tenantIdToBeReplaced}`);
+
+    tenantInfo = await client.SetTenantId({objectId: libraryId, tenantId: tenantIdToBeReplaced});
+    if(tenantInfo.tenantId !== tenantIdToBeReplaced) {
+      throw Error(`tenant mismatch, actual: ${tenantInfo.tenantId}, expected: ${tenantIdToBeReplaced}`);
+    }
+    console.log(`tenantId for library changed to ${tenantIdToBeReplaced}`);
+
+    tenantInfo = await client.SetTenantId({contractAddress: contentTypeAddress, tenantId: tenantIdToBeReplaced});
+    if(tenantInfo.tenantId !== tenantIdToBeReplaced) {
+      throw Error(`tenant mismatch, actual: ${tenantInfo.tenantId}, expected: ${tenantIdToBeReplaced}`);
+    }
+    console.log(`tenantId for content-type object changed to ${tenantIdToBeReplaced}`)
+
+    tenantInfo = await client.SetTenantId({contractAddress: groupAddress, tenantId: tenantIdToBeReplaced});
+    if(tenantInfo.tenantId !== tenantIdToBeReplaced) {
+      throw Error(`tenant mismatch, actual: ${tenantInfo.tenantId}, expected: ${tenantIdToBeReplaced}`);
+    }
+    console.log(`tenantId for group-address changed to ${tenantIdToBeReplaced}`)
+
   } catch(e){
     console.error(e);
   }