Workflow Examples

All the command line examples use a dollar sign followed by an ITEM_NAME in bold italic caps to indicate information that you need to substitute in (e.g. $MASTER_TYPE, $FILENAME).

Four of these ($MASTER_TYPE, $MEZ_TYPE, $MASTER_LIB, $MEZ_LIB) are so frequently used that for convenience, you may wish to set these up as environment variables with the values you obtained in Look up your Content Type IDs and LibraryIDs, e.g.: (replace with your own IDs)

export MASTER_TYPE=iq__2tfLjovW8zMN9Yh6eLmwynX1Cbip
export MEZ_TYPE=iq__8SLzhEyJWiJ41BPezhswG56MUwL
export MASTER_LIB=ilib3fm7YhNrmYBNsgNwFuUso1CRVFw3
export MEZ_LIB=ilib29dvmbN91uyXRwcMX88CAs8q2zeT

The command lines also assume that your current working directory is set to elv-utils-js/utilities/

Ingest

Small Local File (no DRM)

The following is suitable for ingesting short videos (several minutes or less) with a single audio stream, where both audio and video are included in a single file. The example ABR Profile used sets a top resolution of 1080p and specifies no DRM.

Because --wait is specified, the MezCreate.js command will wait for transcoding to finish and automatically finalize changes. It will however tie up your command line while transcoding is taking place.

  1. Create the Master:

    2. node MasterCreate.js \
      --libraryId $MASTER_LIB \
      --type $MASTER_TYPE \
      --title "$YOUR_TITLE" \
      --files $PATH_TO_YOUR_FILE

  2. Copy the version hash output by the MasterCreate.js script. This will need to be substituted in for $MASTER_VERSION_HASH in the next command.

  3. Create the Mezzanine (and wait for transcoding to finish)
    4. node MezCreate.js \
      --libraryId $MEZ_LIB \
      --type $MEZ_TYPE \
      --title "$YOUR_TITLE" \
      --masterHash $MASTER_VERSION_HASH \
      --abrProfile ../example-files/abr_profile_no_drm_store_encrypted.json \
      --wait

Longer File / S3 / DRM / shared with Admin Group

The following is a typical ingest workflow with the following parameters:

  • File(s) are longer duration
  • Offering will provide HD resolution (1080p)
  • Master file(s) are hosted on AWS S3, and not copied to Content Fabric
  • Playout uses 'strict' DRM (Fairplay or Widevine only)
  • Master and Mezzanine Objects are managed by your 'Content Admins' group

For longer duration files, tying up the command line until an ingest finishes transcoding is impractical. Usually you will run the MezCreate.js command without the --wait option, then use additional commands to check progress and finalize the finished transcodes.

  1. Specify S3 Credentials:

    2. export AWS_REGION=    (your AWS region)
    export AWS_BUCKET=    (your AWS bucket name)
    export AWS_KEY=       (your AWS S3 key - should start with "AK")
    export AWS_SECRET=    (your AWS S3 secret)

  2. Create the Master:

    3. node MasterCreate.js \
      --libraryId $MASTER_LIB \
      --type $MASTER_TYPE \
      --title "$YOUR_TITLE" \
      --s3Reference \
      --files $S3_PATH_TO_YOUR_FILE

  3. Copy the Object ID output by the MasterCreate.js script. This will need to be substituted in for $MASTER_OBJECT_ID in the next command

  4. Grant manage permission for the Master to your Content Admins Access Group:

    5. node ObjectAddGroupPerm.js \
      --objectId $MASTER_OBJECT_ID \
      --groupAddress $ACCESS_GROUP_ADDRESS \
      --permission manage

  5. Copy the Version Hash output by the MasterCreate.js script from step 2. This will need to be substituted in for $MASTER_VERSION_HASH in the next command.

  6. Create the Mezzanine:

    7. node MezCreate.js \
      --libraryId $MEZ_LIB \
      --type $MEZ_TYPE \
      --title "$YOUR_TITLE" \
      --masterHash $MASTER_VERSION_HASH \
      --abrProfile ../example-files/abr_profile_drm_strict.json

  7. Copy the Object ID output by the MezCreate.js script. This will need to be substituted in for $MEZ_OBJECT_ID in the commands to check transcoding progress and finalize the finished result.

At this point switch to the Check Transcode Progress / Finalize Mezzanine workflow steps.

Check transcode progress / Finalize mezzanine

For longer-running transcodes, you will use additional command lines to check on progress and finalize when done. It is also common after finalizing to grant your Content Admins Group 'manage' permission for the Mezzanine Object as well as set the overall Object Permission / Visibility to 'viewable':

  1. Check on transcoding progress:

    2. node MezJobStatus.js \
      --objectId $MEZ_OBJECT_ID

  2. Once the job is finished, finalize the Mezzanine:

    3. node MezJobStatus.js \
      --objectId $MEZ_OBJECT_ID \
      --finalize

  3. Grant manage permission for the Mezzanine to your Content Admins Access Group:

    4. node ObjectAddGroupPerm.js \
      --objectId $MEZ_OBJECT_ID \
      --groupAddress $ACCESS_GROUP_ADDRESS \
      --permission manage

  4. Set the Object Permission on the Mezzanine to viewable:

    5. node ObjectSetPermission.js \
      --objectId $MEZ_OBJECT_ID \
      --permission viewable

Use a single object as both Master and Mezzanine

For very short videos (e.g. NFT animations) or for 'single-use' videos (where you don't expect to ever need to generate more than one Offering) you may wish to simplify management by using a single Object as both Master and Mezzanine. This means you only need to use the Mezzanine Library and Mezzanine Content Type.

The example ABR Profile used sets a top resolution of 1080p and specifies no DRM. In addition, it uses unencrypted storage.

Because --wait is specified, the MezCreate.js command will wait for transcoding to finish and automatically finalize changes. It will however tie up your command line while transcoding is taking place.

  1. Create the Master, using your Mezzanine Library and Content Type:

    2. node MasterCreate.js \
      --libraryId $MEZ_LIB \
      --type $MEZ_TYPE \
      --title "$YOUR_TITLE" \
      --files $PATH_TO_YOUR_FILE

  2. Copy both the Object ID and the Version Hash output by the MasterCreate.js script. These will need to be substituted in for $MEZ_OBJECT_ID and $MASTER_VERSION_HASH in the next command.

  3. Create the Mezzanine (and wait for transcoding to finish). Because the Object already exists, use the --existingMezId option. (This also means you can omit --libraryId, --type, and --title.)

    4. node MezCreate.js \
      --existingMezId $MEZ_OBJECT_ID \
      --masterHash $MASTER_VERSION_HASH \
      --abrProfile ../example-files/abr_profile_no_drm_store_unencrypted.json \
      --wait

When working with masters stored in AWS S3, usually you will want to link to the master file(s) instead of copying them to the Content Fabric. This avoids the time needed to copy, reduces storage used by your tenancy, and keeps access to your master assets as limited as possible. Once your transcodes are finalized you can move the source files to S3 Glacier, remove them from S3 altogether, or keep them in your S3 bucket but revoke access for the S3 credentials used during ingest.

Keep in mind that if you need to re-transcode from the master files (for example, to increase the top resolution/bit rate) you will need to restore them to the same path in the same S3 bucket first.

Before running the command, you must set the environment variables to specify your AWS region, bucket, and credentials:

export AWS_REGION=    (your AWS region)
export AWS_BUCKET=    (your AWS bucket name)
export AWS_KEY=       (your AWS S3 key - should start with "AK")
export AWS_SECRET=    (your AWS S3 secret)

NOTE: these variables must also be set whenever you run commands that need to access the contents of linked files: FilesProbe.js, MasterInit.js, MasterUpdateSources.js, and MezCreate.js. The Content Fabric does not store your AWS credentials.

The paths to use for the --files option should take the form:

s3://BUCKET_NAME/FILE_PATH_WITHIN_BUCKET

For example, if my bucket name were "ingest" and my file "master.mp4" was in the top level of the bucket, then it would be s3://ingest/master.mp4 (Note that my AWS_BUCKET environment variable would also be set to ingest)

The command to create the Master is then:

node MasterCreate.js \
  --libraryId $MASTER_LIB \
  --type $MASTER_TYPE \
  --title "$YOUR_TITLE" \
  --s3Reference \
  --files $FILE_1_S3_PATH $FILE_2_S3_PATH...

Create a master from S3 (copy files)

If you wish to copy the file from S3 into the Content Fabric, use the --s3Copy option. This may take a while, depending on file size and proximity of the AWS S3 server to the Content Fabric node.

If you are in a different geographic area than the S3 region that hosts your bucket, you can use the --elvGeo option to choose a Content Fabric node that is closer to the S3 servers.

s3://BUCKET_NAME/bbb_sunflower_1080p_60fps_stereo_abl.mp4

node MasterCreate.js \
  --libraryId $MASTER_LIB \
  --type $MASTER_TYPE \
  --title "$YOUR_TITLE" \
  --s3Copy \
  --files $S3_PATH_TO_YOUR_FILE

Ingest an HDR video

Ingest a local video file that was prepared with High Dynamic Range (HDR).

Please see the HDR Mezzanines section for details on preparation of the JSON file containing HDR information.

  1. Create the Master:

    2. node MasterCreate.js \
      --libraryId $MASTER_LIB \
      --type $MASTER_TYPE \
      --title "$YOUR_TITLE" \
      --files $PATH_TO_YOUR_FILE

  2. Copy the Object ID output by the MasterCreate.js script. This will need to be substituted in for $MASTER_OBJECT_ID in later commands.

  3. Grant manage permission for the Master to your Content Admins Access Group:

    4. node ObjectAddGroupPerm.js \
      --objectId $MASTER_OBJECT_ID \
      --groupAddress $ACCESS_GROUP_ADDRESS \
      --permission manage

  4. Add HDR information to the Master:

    5. node MasterAddHDRInfo.js \
      --objectId $MASTER_OBJECT_ID \
      --file $FILE_NAME \
      --info $PATH_TO_YOUR_HDR_INFO_JSON_FILE

  5. Copy the Version Hash output by the MasterAddHDRInfo.js script. This will need to be substituted in for $MASTER_VERSION_HASH in the next command.

  6. Create the Mezzanine, using an x265 ABR Profile:

    7. node MezCreate.js \
      --libraryId $MEZ_LIB \
      --type $MEZ_TYPE \
      --title "$YOUR_TITLE" \
      --masterHash $MASTER_VERSION_HASH \
      --abrProfile ../example-files/abr_profile_x265_4k_16x9_crf28_medium_clear.json

  7. Copy the Object ID output by the MezCreate.js script. This will need to be substituted in for $MEZ_OBJECT_ID in the commands to check transcoding progress and finalize the finished result.

The rest of the ingest proceeds as usual - at this point, switch to the "Check Transcode Progress / Finalize Mezzanine" workflow steps.

Replace a stream (revised master file provided after initial ingest)

Update stream 'video' in Variant named 'default' to use a new file stored on S3, then redo the stream in the Offering (which is also named 'default')

  1. Add file to Master

    2. node FilesAdd.js \
      --objectId $MASTER_OBJECT_ID \
      --files $FILE_S3_URL \
      --s3Reference

  2. Probe file and update info in Master

    3. node MasterUpdateSources.js \
      --objectId $MASTER_OBJECT_ID \
      --files $FILENAME

  3. Change stream in the Variant to use the new file as source (NOTE: the version hash output by this command will need to be substituted in for $NEW_MASTER_HASH in the next step)

    4. node VariantEditStream.js \
      --objectId $MASTER_OBJECT_ID \
      --streamKey video \
      --file $FILENAME

  4. Ingest to existing Offering 'default' in existing Mezzanine object, transcoding only 1 stream and preserving other previously ingested streams

    5. node MezCreate.js \
      --masterHash $NEW_MASTER_HASH \
      --objectId $MEZ_OBJECT_ID \
      --abrProfile ../example-files/abr_profile_drm.json \
      --streamKeys video \
      --keepOtherStreams

  5. Check status of transcode

    6. node MezJobStatus.js \
      --objectId $MEZ_OBJECT_ID

  6. Finalize as usual once transcoding is finished.

    7. node MezJobStatus.js \
      --objectId $MEZ_OBJECT_ID \
      --finalize

Offerings

Add a subtitle track to an Offering

Subtitle files must be in WebVTT format and need to be available as a local file to be added to an Offering.

When the subtitle track is added it gets incorporated into the Object as binary data (not uploaded as a file).

It is recommended (but not required) to also upload subtitles as regular files to your Master object, so that they are easily available in case they need to be redone or added to other Offerings.

See the documentation for OfferingAddSubtitles.js for more information about the various available options.

See Reference: Language codes and labels section for code to use for the --language option.

  1. (Optional, but recommended) Upload the subtitle file to the Master Object:

    2. node FilesAdd.js \
      --objectId $MASTER_OBJECT_ID \
      --files $PATH_TO_VTT_FILE

  2. Add the subtitle track to the Mezzanine Offering:

    3. node OfferingAddSubtitles.js \
      --objectId $EXISTING_MEZ_OBJECT_ID \
      --streamKey $STREAM_KEY \
      --language $LANGUAGE_CODE \
      --label $DISPLAY_LABEL \
      --file $PATH_TO_VTT_FILE

Add a text watermark to an Offering

Note that you cannot have both an image watermark and a text watermark on the same Offering. Also, x265 Offerings do not currently support watermarks.

You should first create a JSON file specifying the content and appearance of the watermark. The elv-utils-js package has an example file containing a watermark definition, elv-utils-js/example-files/text_watermark.json. This file will put the text "PREPARED FOR $USERNAME - DO NOT DISTRIBUTE" horizontally centered and near the bottom of the screen. ($USERNAME gets replaced by the viewer's Content Fabric address).

Example JSON file contents (text_watermark.json):

{
  "font_color": "white@0.5",
  "font_relative_height": 0.05,
  "shadow": true,
  "shadow_color": "black@0.5",
  "template": "PREPARED FOR $USERNAME - DO NOT DISTRIBUTE",
  "x": "(w-tw)/2",
  "y": "h-(4*lh)"
}

See the documentation for OfferingSetTextWatermark.js for more information about the various available options.

  1. Add the watermark:

    2. node OfferingSetTextWatermark.js \
      --objectId $MEZ_OBJECT_ID \
      --watermark $PATH_TO_WATERMARK_JSON_FILE

Add an image watermark to an Offering

Note that you cannot have both an image watermark and a text watermark on the same Offering. Also, x265 Offerings do not currently support watermarks.

You will need an IMAGE file (PNG recommended, as it has good support for transparency) and should also create a JSON file specifying the sizing and placement of the watermark. The elv-utils-js repo has an example file containing a watermark definition elv-utils-js/example-files/image_watermark.json as well as a sample PNG file elv-utils-js/example-files/image_watermark.png. Using these files will put a small transparent Eluvio icon at the bottom right of the screen.

Example JSON file contents (image_watermark.json):

{
  "align_h": "right",
  "align_v": "bottom",
  "image": "/image_watermark.png",
  "margin_h": "1/20",
  "margin_v": "1/10",
  "target_video_height": 1080
}

See the documentation for OfferingSetImageWatermark.js for more information about the various available options.

  1. Upload the watermark IMAGE file to the Mezzanine Object (if it has not already been uploaded):

    2. node FilesAdd.js \
      --objectId $MEZ_OBJECT_ID \
      --files $PATH_TO_WATERMARK_IMAGE_FILE

  2. Add the watermark (your watermark JSON file needs to contain the filename of your IMAGE file):

    3. node OfferingSetImageWatermark.js \
      --objectId $MEZ_OBJECT_ID \
      --watermark $PATH_TO_WATERMARK_JSON_FILE

Create both a normal and a watermarked Offering during ingest

When you create an Offering, you can specify that additional modified copies of it should be created during finalization. This is done via the --addlOfferingSpecs option of the MezCreate.js command.

You should first create a JSON file specifying the offering key(s) to use for the additional Offering(s), along with the JSON Patch operations to perform on each. The elv-utils-js package has an example file, elv-utils-js/example-files/addl_offering_spec_watermark.json to create an additional Offering labeled 'watermark' that adds a text watermark:

Example JSON file contents (addl_offering_spec_watermark.json):

{
  "watermark": [
    {
      "op": "replace",
      "path": "/simple_watermark",
      "value": {
        "font_color": "white@0.6",
        "font_relative_height": 0.05,
        "shadow": true,
        "shadow_color": "black@0.15",
        "template": "Prepared for $USERNAME",
        "x": "(w-tw)*85/100",
        "y": "(h-th)*95/100"
      }
    }
  ]
}

Command using the example file:

node MezCreate.js \
  --libraryId $MEZ_LIB \
  --type $MEZ_TYPE \
  --title "$YOUR_TITLE" \
  --masterHash $MASTER_VERSION_HASH \
  --abrProfile $PATH_TO_ABR_PROFILE_JSON_FILE \
  --addlOfferingSpecs ../example-files/addl_offering_spec_watermark.json

Duplicate an offering (to the same mezzanine object)

It is often useful to create an extra copy of an existing Offering within the same Mezzanine Object. The copy can then be modified (for example, by changing the DRM options, or adding a watermark). The utility for this is MezCopyOffering.js: 

node MezCopyOffering.js \
  --objectId $MEZ_OBJECT_ID \
  --offeringKey $EXISTING_OFFERING_KEY \
  --newOfferingKey $NEW_OFFERING_KEY

Add DRM to an offering

NOTE: To be able to add DRM, your Offering must have been created using an ABR Profile that had Storage Encryption enabled. Otherwise you will need to recreate the Offering using such a profile.

If you initially created an Offering without any DRM and you wish to add DRM afterwards, the utility for this is OfferingSetFormats.js. The command below adds all DRM formats supported by the Content Fabric.

node OfferingSetFormats.js \
  --objectId $MEZ_OBJECT_ID \
  --formats hls-aes128 hls-sample-aes hls-fairplay dash-widevine

Change offering DRM to ‘strict’

NOTE: To set DRM options, your Offering must have been created using an ABR Profile that had Storage Encryption enabled. Otherwise you will need to recreate the Offering using such a profile.

Out of the DRM Formats that the Content Fabric supports, Sample-AES and AES-128 are considered to be less strict than Fairplay and Widevine. If you wish to limit playout to only use the latter two, the utility for this is OfferingSetFormats.js. The command below changes an Offering to only allow playout with Fairplay or Widevine.

node OfferingSetFormats.js \
  --objectId $MEZ_OBJECT_ID \
  --offeringKey $OFFERING_KEY \
  --formats hls-fairplay dash-widevine

Remove DRM from an offering

In order to remove DRM from an offering the drm_optional field in Offering metadata must be set to true.

If you created the Offering using one of the example ABR Profiles with filename like *_both.json then this will already be the case, otherwise you will first need to use the MetaSet.js command:

node MetaSet.js \
  --objectId $MEZ_OBJECT_ID \
  --path /offerings/$OFFERING_KEY/drm_optional \
  --metadata true \
  --force

Then to set the Offering to only provide clear (DRM-free) playout, use OfferingSetFormats.js:

node OfferingSetFormats.js \
  --objectId $MEZ_OBJECT_ID \
  --offeringKey $OFFERING_KEY \
  --formats hls-clear dash-clear

Change a single metadata field

Changing metadata can be done with the MetaSet.js command (please see the docs for complete information on usage).

When a field already exists, you must use the --force option to overwrite the existing value:

node MetaSet.js \
  --objectId $OBJECT_ID \
  --path $METADATA_PATH \
  --metadata $JSON_FILE_PATH_OR_METADATA \
  --force

Audio

Prepare a stereo audio stream from a surround stream

If your Master source file only has a 5.1 surround audio stream, you will usually need to add a stereo audio stream to the Variant before creating a Mezzanine Offering. The Content Fabric will then mix the audio channels you specify into a stereo audio stream during ingest.

You will need to decide on a Stream Key (e.g. "audio" or "audio-stereo") and a label (e.g. "stereo", or "English - stereo"). The former becomes part of the URLs used to retrieve audio segments during playout, and the latter is shown in the UI by player software.

You will also need a language code (see Reference: Language codes and labels).

If the source file had an English 6-channel surround audio track as the second stream (stream index = 1) then the command would be:

node VariantAddStream.js \
  --objectId $MASTER_OBJECT_ID \
  --streamKey $STREAM_KEY \
  --lang en \
  --file $FILENAME \
  --label $LABEL \
  --streamIndex 1 \
  --channelIndex 0 1 2 4 5 \
  --mapping 5CHANNELS_1STEREO

(Note that audio channel index 3 from master is omitted - this is the subwoofer/LFO channel)

If you wish to mark the audio stream as the default, add --isDefault to the command line.

Prepare a stereo audio stream from 2 mono streams

If your Master source file has left and right audio channels packaged as 2 separate mono streams, you will need to add an audio stream to the Variant that packages them together as a single 2-channel stream (before creating a Mezzanine Offering). The Content Fabric will then package them into a single stereo audio stream during ingest.

You will need to decide on a Stream Key (e.g. "audio" or "audio-stereo") and a label (e.g. "stereo", or "English - stereo"). The former becomes part of the URLs used to retrieve audio segments during playout, and the latter is shown in the UI by player software.

You will also need a language code (see Reference: Language codes and labels).

If the source file audio is in English and the left and right audio channels were set up as the second and third stream (stream index = 1 & 2) then the command would be:

node VariantAddStream.js \
  --objectId $MASTER_OBJECT_ID \
  --streamKey $STREAM_KEY \
  --lang en \
  --file $FILENAME \
  --label $LABEL \
  --streamIndex 1 2 \
  --mapping 2MONO_1STEREO

If you wish to mark the audio stream as the default, add --isDefault to the command line.

Prepare a stereo audio stream from 5 mono streams

If your Master source file has no premixed stereo left and right audio available but has surround audio packaged as 6 separate mono streams, you will need to add an audio stream to the Variant that packages them together as a single 2-channel stream (before creating a Mezzanine Offering). The Content Fabric will then package them into a single stereo audio stream during ingest.

You will need to decide on a Stream Key (e.g. "audio" or "audio-stereo") and a label (e.g. "stereo", or "English - stereo"). The former becomes part of the URLs used to retrieve audio segments during playout, and the latter is shown in the UI by player software.

You will also need a language code (see Reference: Language codes and labels).

If the source file audio is in English, and the surround audio streams were set up as the second through seventh streams (stream index = 1 to 6) then the command would be:

node VariantAddStream.js \
  --objectId $MASTER_OBJECT_ID \
  --streamKey $STREAM_KEY \
  --lang en \
  --file $FILENAME \
  --label $LABEL \
  --streamIndex 1 2 3 5 6 \
  --mapping 5MONO_1STEREO

(Note that audio stream index 4 from master is omitted - this is the subwoofer/LFO channel)

If you wish to mark the audio stream as the default, add --isDefault to the command line.

Prepare a surround audio stream from 6 mono streams

If your Master source file has surround audio packaged as 6 separate mono streams and you want your Mezzanine Offering to provide surround audio, you will need to add an audio stream to the Variant that packages the 6 mono streams together as a single 5.1 stream (before creating a Mezzanine Offering). The Content Fabric will then package them into a single surround audio stream during ingest.

You will need to decide on a Stream Key (e.g. "audio" or "audio-surround") and a label (e.g. "surround", or "English - surround"). The former becomes part of the URLs used to retrieve audio segments during playout, and the latter is shown in the UI by player software.

You will also need a language code (see Reference: Language codes and labels).

If the source file audio is in English, and the surround audio streams were set up as the second through seventh streams (stream index = 1 to 6) then the command would be:

node VariantAddStream.js \
  --objectId $MASTER_OBJECT_ID \
  --streamKey $STREAM_KEY \
  --lang en \
  --file $FILENAME \
  --label $LABEL \
  --streamIndex 1 2 3 4 5 6 \
  --mapping 6MONO_1SURROUND

If you wish to mark the audio stream as the default, add --isDefault to the command line.

Add audio stream for a second language (after initial ingest)

Add a new stream 'audio-fr' to Variant 'default', using a new file on S3, then update the Offering (also named 'default')

  1. Add file to Master

    2. node FilesAdd.js \
      --objectId $MASTER_OBJECT_ID \
      --files $FILE_S3_URL \
      --s3Reference

  2. Probe file and update info in Master

    3. node MasterUpdateSources.js \
      --objectId $MASTER_OBJECT_ID \
      --files $FILENAME

  3. Add new stream to Variant, using the new file as source (NOTE: the version hash output by this command will need to be substituted in for $NEW_MASTER_HASH in the next step)

    4. node VariantAddStream.js \
      --objectId $MASTER_OBJECT_ID \
      --streamKey audio-fr \
      --file $FILENAME \
      --streamIndex 0 \
      --language fr \
      --label Français

  4. Ingest to existing Mezzanine / Offering, transcoding only 1 stream (preserving the other streams)

    5. node MezCreate.js \
      --masterHash $NEW_MASTER_HASH \
      --objectId $MEZ_OBJECT_ID \
      --abrProfile ../example-files/abr_profile_both.json \
      --streamKeys audio-fr \
      --keepOtherStreams

  5. Check transcode status

    6. node MezJobStatus.js \
      --objectId $MEZ_OBJECT_ID

  6. Finalize as usual once transcoding is finished.

    7. node MezJobStatus.js \
      --objectId $MEZ_OBJECT_ID \
      --finalize