@eluvio/elv-client-js 4.2.24 → 4.2.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eluvio/elv-client-js",
-  "version": "4.2.24",
+  "version": "4.2.27",
   "description": "Javascript client for the Eluvio Content Fabric",
   "main": "src/index.js",
   "author": "Kevin Talmadge",
@@ -35,6 +35,10 @@
   "browser": {
     "fs": false
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eluv-io/elv-client-js.git"
+  },
   "files": [
     "/build",
     "/dist",

package/src/client/ABRPublishing.js

@@ -78,6 +78,11 @@ const MezJobMainOfferingKey = function(abrMezOfferings) {
  * -           ...
  * -         ]
  * -
+ * - For a presigned URL, `path` and `storage_endpoint` are not required and `cloud_credentials` should be:
+ * -         {
+ * -           signed_url: "YOUR_PRESIGNED_S3_URL"
+ * -         }
+ * -
  * - The simplest case is a one element array with .path_matchers == [".*"], in which case the same credentials will be used for all items in fileInfo
  *
  * @throws {Object} error - If the initialization of the master fails, error details can be found in error.body
@@ -127,8 +132,11 @@ exports.CreateProductionMaster = async function({
         let matched = false;
         for(let j = 0; !matched && j < access.length; j++) {
           let credentialSet = access[j];
+          const remoteAccess = credentialSet.remote_access;
           // strip trailing slash to get bucket name for credential set
-          const credentialSetBucket = credentialSet.remote_access.path.replace(/\/$/, "");
+          const credentialSetBucket = remoteAccess.path
+            ? remoteAccess.path.replace(/\/$/, "")
+            : undefined;
           const matchers = credentialSet.path_matchers;
           for(let k = 0; !matched && k < matchers.length; k++) {
             const matcher = new RegExp(matchers[k]);
@@ -139,7 +147,7 @@ exports.CreateProductionMaster = async function({
               const s3prefixMatch = (s3prefixRegex.exec(fileSourcePath));
               if(s3prefixMatch) {
                 const bucketName = s3prefixMatch[1];
-                if(bucketName !== credentialSetBucket) {
+                if(credentialSetBucket && bucketName !== credentialSetBucket) {
                   throw Error("Full S3 file path \"" + fileSourcePath + "\" matched to credential set with different bucket name '" + credentialSetBucket + "'");
                 }
               }
@@ -154,7 +162,7 @@ exports.CreateProductionMaster = async function({
           }
         }
         if(!matched) {
-          throw Error("no credential set found for file path: \"" + filePath + "\"");
+          throw Error("no credential set found for file path: \"" + oneFileInfo.source + "\"");
         }
       }
 
@@ -162,10 +170,13 @@ exports.CreateProductionMaster = async function({
       for(let i = 0; i < access.length; i++) {
         const credentialSet = access[i];
         if(credentialSet.hasOwnProperty("matched") && credentialSet.matched.length > 0) {
-          const region = credentialSet.remote_access.storage_endpoint.region;
-          const bucket = credentialSet.remote_access.path.replace(/\/$/, "");
-          const accessKey = credentialSet.remote_access.cloud_credentials.access_key_id;
-          const secret = credentialSet.remote_access.cloud_credentials.secret_access_key;
+          const remoteAccess = credentialSet.remote_access;
+          const cloudCredentials = remoteAccess.cloud_credentials;
+          const region = remoteAccess.storage_endpoint && remoteAccess.storage_endpoint.region;
+          const bucket = remoteAccess.path && remoteAccess.path.replace(/\/$/, "");
+          const accessKey = cloudCredentials.access_key_id;
+          const secret = cloudCredentials.secret_access_key;
+          const signedUrl = cloudCredentials.signed_url;
 
           await this.UploadFilesFromS3({
             libraryId,
@@ -176,6 +187,7 @@ exports.CreateProductionMaster = async function({
             bucket,
             accessKey,
             secret,
+            signedUrl,
             copy,
             callback,
             encryption: encrypt ? "cgck" : "none"
@@ -212,22 +224,24 @@ exports.CreateProductionMaster = async function({
     constant: false
   });
 
+  const mergeMetadata = {
+    ...(metadata || {}),
+    name: name !== undefined ? name : (metadata || {}).name,
+    description: description !== undefined ? description : (metadata || {}).description,
+    reference: access && !copy,
+    public: {
+      ...((metadata || {}).public || {}),
+      name: name !== undefined ? name : ((metadata || {}).public || {}).name,
+      description: description !== undefined ? description : ((metadata || {}).public || {}).description
+    },
+    elv_created_at: new Date().getTime(),
+  };
+
   await this.MergeMetadata({
     libraryId,
     objectId,
     writeToken,
-    metadata: {
-      ...(metadata || {}),
-      name,
-      description,
-      reference: access && !copy,
-      public: {
-        ...((metadata || {}).public || {}),
-        name: name || "",
-        description: description || ""
-      },
-      elv_created_at: new Date().getTime(),
-    }
+    metadata: mergeMetadata
   });
 
   let additionalReturnVals;

package/src/client/Files.js

@@ -74,11 +74,11 @@ exports.ListFiles = async function({libraryId, objectId, path = "", versionHash,
  * @param {string} libraryId - ID of the library
  * @param {string} objectId - ID of the object
  * @param {string} writeToken - Write token of the draft
- * @param {string} region - AWS region to use
- * @param {string} bucket - AWS bucket to use
+ * @param {string=} region - AWS region to use
+ * @param {string=} bucket - AWS bucket to use
  * @param {Array<Object>} fileInfo - List of files to reference/copy
- * @param {string} accessKey - AWS access key
- * @param {string} secret - AWS secret
+ * @param {string=} accessKey - AWS access key
+ * @param {string=} secret - AWS secret
  * @param {string=} signedUrl
  * @param {string} encryption="none" - Encryption for uploaded files (copy only) - cgck | none
  * @param {boolean} copy=false - If true, will copy the data from S3 into the fabric. Otherwise, a reference to the content will be made.
@@ -152,17 +152,18 @@ exports.UploadFilesFromS3 = async function({
     };
   }
 
+  const remoteAccess = {
+    protocol: "s3",
+    platform: "aws",
+    cloud_credentials: cloudCredentials
+  };
+
+  if(bucket) remoteAccess.path = bucket;
+  if(region) remoteAccess.storage_endpoint = {region};
+
   const defaults = {
     encryption_key,
-    access: {
-      protocol: "s3",
-      platform: "aws",
-      path: bucket,
-      storage_endpoint: {
-        region
-      },
-      cloud_credentials: cloudCredentials
-    }
+    access: remoteAccess
   };
 
   const ops = fileInfo.map(info => {

package/src/client/LiveConf.js

@@ -218,7 +218,8 @@ class LiveConf {
    *
    * 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
+   * - RTMP input stream timebase is 1000 and gets translated to match the frame rate
+   *   (eg. 24000 @24fps, 30000 @30fps/29.97fps, 60000 @60fps/59.94fps)
    *
    * 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
@@ -229,10 +230,13 @@ class LiveConf {
    * 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).
+   * (and resulting frame duration is 1001) and for RTMP 60fps the timebase is set to 60000
+   * (resulting frame duration is 1000). For every supported RTMP frame rate, the video timebase is
+   * set equal to the source timescale, with a frame duration of 1000 (1001 for the *000/1001
+   * fractional rates).
    *
-   * @sourceTimescale - adjusted source video stream timescale (eg. MPEGTS 90000, RTMP 16000 )
+   * @sourceTimescale - adjusted source video stream timescale (eg. MPEGTS 90000; ignored for RTMP,
+   *   which derives its own timebase per frame rate in calcSegDurationRtmp)
    * @sampleRate - audio sample rate (commonly 48000 but can be different)
    * @audioCodec - audio codec as a string (eg. "aac")
    * @return - segment encoding parameters
@@ -333,57 +337,65 @@ class LiveConf {
     return seg;
   }
 
-  calcSegDurationRtmp({sourceTimescale}) {
+  calcSegDurationRtmp() {
     let videoStream = this.getStreamDataForCodecType("video");
     let frameRate = videoStream.frame_rate;
     let seg = {};
 
     switch(frameRate) {
       case "24":
-        seg.videoTimeBase = 768; // Note 1536 produces low output bitrate
-        seg.videoFrameDurationTs = 512;
-        seg.video = this.calcOutputTimebase(seg.videoTimeBase) * 30;
+        seg.videoTimeBase = 24000;
+        seg.videoFrameDurationTs = 1000;
+        seg.video = seg.videoTimeBase * 30;
         seg.keyint = 48;
         seg.duration = "30";
         break;
       case "25":
-        seg.video = sourceTimescale * 30;
+        seg.videoTimeBase = 25000;
+        seg.videoFrameDurationTs = 1000;
+        seg.video = seg.videoTimeBase * 30;
         seg.keyint = 50;
         seg.duration = "30";
         break;
       case "30":
-        seg.videoTimeBase = 960; // Output timebase: 15360
-        seg.videoFrameDurationTs = 512;
-        seg.video = this.calcOutputTimebase(seg.videoTimeBase) * 30;
+        seg.videoTimeBase = 30000;
+        seg.videoFrameDurationTs = 1000;
+        seg.video = seg.videoTimeBase * 30;
         seg.keyint = 60;
         seg.duration = "30";
         break;
       case "30000/1001":
-        seg.video = sourceTimescale * 30.03;
+        seg.videoTimeBase = 30000;
+        seg.videoFrameDurationTs = 1001;
+        seg.video = seg.videoTimeBase * 30.03;
         seg.keyint = 60;
         seg.duration = "30.03";
         break;
       case "48":
-        seg.videoTimeBase = 1536; // Output timebase: 12288
-        seg.videoFrameDurationTs = 256;
-        seg.video = this.calcOutputTimebase(seg.videoTimeBase) * 30;
+        seg.videoTimeBase = 48000;
+        seg.videoFrameDurationTs = 1000;
+        seg.video = seg.videoTimeBase * 30;
         seg.keyint = 96;
         seg.duration = "30";
         break;
       case "50":
-        seg.video = sourceTimescale * 30;
+        seg.videoTimeBase = 50000;
+        seg.videoFrameDurationTs = 1000;
+        seg.video = seg.videoTimeBase * 30;
         seg.keyint = 100;
         seg.duration = "30";
         break;
       case "60":
-        seg.videoTimeBase = 960; // Output timebase: 15360
-        seg.videoFrameDurationTs = 256;
-        seg.video = this.calcOutputTimebase(seg.videoTimeBase) * 30;
+        seg.videoTimeBase = 60000;
+        seg.videoFrameDurationTs = 1000;
+        seg.video = seg.videoTimeBase * 30;
         seg.keyint = 120;
         seg.duration = "30";
         break;
       case "60000/1001":
-        seg.video = sourceTimescale * 30.03;
+        seg.videoTimeBase = 60000;
+        seg.videoFrameDurationTs = 1001;
+        seg.video = seg.videoTimeBase * 30.03;
         seg.keyint = 120;
         seg.duration = "30.03";
         break;
@@ -514,6 +526,10 @@ class LiveConf {
     const videoStream = this.getStreamDataForCodecType("video");
     let sourceTimescale;
 
+    // Custom profile values take precedence over computed defaults
+    const customRecordingParams = customSettings.liveRecordingConfigProfile?.recording_params;
+    const customXcParams = customRecordingParams?.xc_params;
+
     // 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;
@@ -536,12 +552,12 @@ class LiveConf {
     // Fill in specifics for protocol
     switch(this.getFormat()) {
       case "mpegts":
-        sourceTimescale = 90000;
+        sourceTimescale = customRecordingParams?.source_timescale ?? 90000;
         conf.live_recording.recording_config.recording_params.source_timescale = sourceTimescale;
         break;
       case "rtmp":
       case "flv":
-        sourceTimescale = 16000;
+        sourceTimescale = customRecordingParams?.source_timescale ?? 16000;
         conf.live_recording.recording_config.recording_params.source_timescale = sourceTimescale;
         break;
       case "hls":
@@ -565,17 +581,20 @@ class LiveConf {
     // 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.video_seg_duration_ts =
+      customXcParams?.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) {
+    if(segDurations.videoTimeBase && R.isNil(customXcParams?.video_time_base)) {
       conf.live_recording.recording_config.recording_params.xc_params.video_time_base = segDurations.videoTimeBase;
 
       // Note 'source_timescale' needs to be set to the output timebase and is used by playout
-      conf.live_recording.recording_config.recording_params.source_timescale = this.calcOutputTimebase(segDurations.videoTimeBase);
+      if(R.isNil(customRecordingParams?.source_timescale)) {
+        conf.live_recording.recording_config.recording_params.source_timescale = this.calcOutputTimebase(segDurations.videoTimeBase);
+      }
     }
-    if(segDurations.videoFrameDurationTs) {
+    if(segDurations.videoFrameDurationTs && R.isNil(customXcParams?.video_frame_duration_ts)) {
       conf.live_recording.recording_config.recording_params.xc_params.video_frame_duration_ts = segDurations.videoFrameDurationTs;
     }
 

package/src/client/LiveStream.js

@@ -322,15 +322,16 @@ exports.StreamCreate = async function({
         video_type: "live",
         slug: slugify(name)
       }
-    },
-    "live_recording_config": liveRecordingConfig
+    }
   };
 
-  const oldProfile = await this.ContentObjectMetadata({
+  const currentLiveRecordingConfig = await this.ContentObjectMetadata({
     libraryId,
     objectId,
-    metadataSubtree: "live_recording_config/name"
-  });
+    metadataSubtree: "live_recording_config"
+  }) || {};
+
+  const oldProfile = currentLiveRecordingConfig.name;
 
   if(liveRecordingConfig?.name && liveRecordingConfig.name !== oldProfile) {
     metadata.public.asset_metadata.profile_last_updated = new Date().toISOString();
@@ -343,6 +344,15 @@ exports.StreamCreate = async function({
     metadata
   });
 
+  // Full overwrite avoids the server-side merge mixing streams from the old and new profile
+  await this.ReplaceMetadata({
+    libraryId,
+    objectId,
+    writeToken,
+    metadataSubtree: "live_recording_config",
+    metadata: R.mergeDeepRight(currentLiveRecordingConfig, liveRecordingConfig)
+  });
+
   try {
     await this.CreateLinks({
       libraryId,