Accurate Video Frontend

This document describes available configuration settings for Accurate Video.

Files available for configuration:

• settings.js (application settings)
• languages.json (list of languages/codes)

settings.js

Settings are defined in a javascript file which is deployed with the application.

Remote settings

It is possible to store a subset of the settings in the backend or in a remote file.

• The local settings file (deployed with the application) is always read first and must include backendUrl and authentication to ensure that user can be authenticated prior to fetching any remote settings.
• Next, if settingsUrl is defined, the application will fetch and merge it with the local settings.
• Finally, if backedSettings is enabled, the application will fetch settings from the backend and merge it.

The only constraint is that remote settings may not define backendUrl, settingsUrl nor authentication.method.

Using this setup

• sensitive settings can be protected from unauthorized users
• settings can be updated without redeploying application

backendUrl as query parameter

The required setting backendUrl can optionally be provided through query parameter i.e https://demo.accurate.video/?backendUrl="https://your-backend.com"&signature=AABBCCDDEEFFGG.

You'll also need to sign the backendUrl value so the application can verify that the backendUrl was set by a trusted party.

• The signature need to be included in the signature query parameter.
• The signature MUST be done with ECDSA in P1363 Format.
• The public key used to verify the signature can be configured in the local settings file (deployed with the application) under crypto.publicKey.
• The public key format MUST be ECDSA, P-256 (prime256v1 in openssl) in PEM format (optional header and footer).

Settings described

• backendSettings - Fetch settings from backend endpoint, default true.
• backendUrl - Base URL that will be called when accessing Accurate Video Adapter. Here are some examples:

These examples assume that the frontend application is hosted at https://example.com/:

• settingsUrl - URL to remote settings file. If omitted, only local settings are loaded. See Remote settings
• settingsCredentials - The request credentials you want to use for the remote settings request: omit, same-origin, or include. To automatically send cookies for the current domain, this option must be provided.
• authentication - see Authentication
• eventBus.enabled - Used to enable/disable the eventbus connectivity
• eventBus.url - URL to backend event bus. If omitted, it is set to backendUrl + "/eventbus"
• endFrameInclusive - If true, backend timespans are considered end frame inclusive.
• licenseKey - License key for Accurate Player.
• preferredVideoTags - Array of tags to load when opening a video proxy. First tag has the highest priority.
• showAssetView - Enable/disable asset list view.
• apps.validate - see Validate Settings
• apps.edit - see Edit Settings
• apps.poster - see Poster Settings
• render - see Render Settings
• ingest - see Ingest
• markers - see Markers
• timeline - see Timeline
• storages - see Storages
• drm - see Drm
• jit - see JIT
• enabledApps - Optional list of paths used for limiting enabled apps. E.g. ['validate', 'poster'] will hide other apps from asset list view.
• features - see Common features
• assetStatus - see Asset status
• assetJobsSettings - see Asset jobs
• enrich - see Enrich
• forms - see Forms
• videoTagBlocklist - List of tags, e.g. ['mp4', 'original']. The urls of any video files that have a matching tag will be removed.
• audioTagBlocklist - List of tags, e.g. ['mp3', 'wav'] The urls of any audio files that have a matching tag will be removed.
• metadataFields - see Metadata fields
• metadataViews - see Metadata views
• playbackRates - List of playback rates to use in the players. Affects all applications. Defaults to [ -16, -8, -4, -2, -1.5, -1, -0.5, +0.25, +0.5, +0.75, +1, +1.25, +1.5, +1.75, +2, +2.5, +3, +4, +8, +16, +32, +64, ]
• metadataKeys.fileLanguage - Default: language. The metadata key used for getting the language from files.
• metadataKeys.fileEncoding - Default: encoding. The metadata key used for getting the encoding of the file. Used for SRT subtitle files with a different encoding than utf-8 for example.
• metadataKeys.filePacCodePage - Default: pac_code_page. The metadata key used for getting the PAC code page to use when decoding a PAC subtitle file. Supported code pages are: Latin, Greek, LatinCzech, Arabic, Hebrew, Thai, Cyrillic, ChineseTraditional, ChineseSimplified, Korean, Japanese and LatinTurkish.
• metadataKeys.timespanLanguage - Default: language. The metadata key used for getting the language from timespan metadata.
• languages - List of languages to use in the applications. These languages are used in language pickers for tracks, subtitles etc. See languages.json for format.

Minimal changes

All settings have default values, most of them require no changes. The settings you alter will be merged which means that complex objects (not arrays) are changed easily. For example, changing timeline.waveforms.vidispine.tag

timeline: {
    waveforms: {
      active: "vidispine",
      vidispine: {
        tag: "original",
        shape: null,
        sampleMin: -43,
        sampleMax: 0
      },
      ...
    }
}

only requires

timeline: {
  waveforms: {
    vidispine: {
      tag: "house-original";
    }
  }
}

Render Settings

Render presets allow the user to configure transcoders and formats to use when exporting clips.

render: {
  enabledFormats: ["file-per-layer"],
  options: {
    storageSelection: true,
    renderAssetSelection: true,
  },
  presets: [
    {
      label: "Web (h.264, ffmpeg)",
      metadata: [
        {
          key: "preset_id",
          value: "standard_h264_follow"
        },
        {
          key: "transcoder",
          value: "ffmpeg",
        },
      ],
    }
  ]
}

• enabledFormats - Default: ["file-per-layer"]. Defines which export formats to show in export modal.
• file-per-layer - Each file will contain the entire sequence, i.e. one file including the video and muxed audio layer and one file per audio layer.
• options.storageSelection - Default: true. Enables selection of target storage.
• options.renderAssetSelection - Default: true. Enables option to render result into an asset, when applicable.
• preset.label - Label describing the preset.
• preset.metadata - List of metadata entries that are passed to the render job.

You can read more about the metadata fields by following the template chain starting with render/select template

• preset_id - The preset id used for main output by the selected transcoder.
• transcoder - The transcoder to use.

Vidispine recommendations

When running against vidispine, we recommend the following configuration:

render: {
  enabledFormats: ["file-per-layer"],
  options: {
    storageSelection: false,
    renderAssetSelection: false,
  },
  presets: [
    {
      label: "Web (h.264, mp4)",
      metadata: [
        {
          key: "target_tag",
          value: "mp4",
        },
        {
          key: "transcoder",
          value: "Vidispine",
        },
      ],
    },
    {
      label: "Audio only (wav)",
      metadata: [
        {
          key: "target_tag",
          value: "wav",
        },
        {
          key: "transcoder",
          value: "Vidispine",
        },
      ],
    },
  ],
}

Options for storage selection and asset rendering are disabled since they are not applicable for Vidispine.

The presets should be updated to match the Vidispine setup for each customer. The transcoder key is used for grouping the presets in the UI and the target_tag is the target shape tag to render.

Validate Settings

Settings for the Validate application:

apps: {
    validate: {
      features: {
        markers: "write",
        keepMarkerFormOpenOnSave: false,
        setLanguageOnFiles: true,
        virtualTracks: false,
        startEndMode: "required",
        safeAreas: true,
        trackExtraction: {
          extractAudio: "never",
          extractSubtitles: "never",
          trackExtractorOptions: {
              verbose: false,
              ...
          }
        },
      },
      fallbackDuration: 3600,
      videoFileDisplay: "%filename (%tag, %id)",
      audioFileDisplay: "%filename (%tag, %id, %channels channels)",
      subtitleFileDisplay: "%filename (%tag, %id, %language)",
      videoFileOrder: ["tag", "filename", "language"],
      audioFileOrder: ["tag", "filename", "channels"],
      subtitleFileOrder: ["tag", "filename", "language"],
      subtitleStartTimeFallback: ["scc", "stl", "timespan", "pac"],
      filesTabAllowedFileTypes: ["VIDEO", "AUDIO"],
      channelNamesMetadataKey: "channelNames",
      timelineFilterQueryParams: ["mainAssetId", "assetId"],
      excludeTabs: ["files"],
      profileMetadataKey: "av:profile",
      virtualTracksMetadataKey: "av:virtual_tracks",
      virtualTracksFileOrderMetadataKey: "av:order",
      disableMuxedAudio: false,
      disableFirstTrackAutoEnable: false,
      maxOutputChannelCount: 2,
      enabledWorkspaces: ["General", "Audio", "Adbreak"],
      disableZeroDurationMarkers: false,
      seekStrategy: "regular",
      audioTracks: [
        {
          id: "mono",
          name: "Mono",
          channelCount: 1,
        },
        {
          id: "stereo",
          name: "Stereo",
          channelCount: 2,
          channelNames: ["L", "R"],
        },
      ],
      audioProfiles: [
        {
          id: "1",
          name: "Profile 1",
          tracks: ["mono"],
        },
        {
          id: "2",
          name: "Profile 2",
          tracks: ["stereo"],
        },
        {
          id: "3",
          name: "Profile 3",
          tracks: ["mono", "stereo"],
        },
      ]
    },
    safeAreas: [
      {
        enabled: true,
        name: "16:9 Test",
        url: "https://example.com/16-9.png",
        aspectRatio: "16:9",
      }
    ]
}

• features.markers - Default: "write". "write" or true allows creating and editing markers, "read" or false allows seeing markers but not editing them, and "hide" will not show any markers. It is also possible to specify a function that calculates the feature setting, with an asset and user roles as input. Possible template values are: ["write", "read", "hide"], (asset: AssetDto, userRoles: string[]) => "write" | "read" | "hide" and legacy values true and false.
• features.keepMarkerFormOpenOnSave - Default: false. Controls if the marker form should stay open after editing and saving marker data.
• features.setLanguageOnFiles - Default: false. Allow changing language on video, audio and subtitle files. Note that the user also needs to have the role file_metadata_write to be able to use this feature.
• features.virtualTracks - Default: false. Enables the virtual tracks feature. Read more about Virtual Tracks here.
• features.startEndMode - Default: "required". Setting to control if start and end markers are required in Ad break workspace or if they are disabled. Possible values are "required" and "disabled".
• features.safeAreas - Default: true. Enable selection of safe areas in the toolbar. Safe areas are configured with apps.validate.safeAreas.
• features.extractMuxedAudio - DEPRECATED: Use features.trackExtraction instead. Default: "never". Setting to control if muxed audio in the video file should be extracted or not. Possible values are "never", "always" and "if_necessary". The "if_necessary" option means that muxed audio is extracted if there are more than one muxed audio track in the video file.
• features.trackExtraction - Controls if audio and/or subtitles in the video file should be extracted.
• features.trackExtraction.extractAudio - Default: "never". Setting to control if muxed audio in the video file should be extracted or not. Possible values are "never", "always" and "if_necessary". The "if_necessary" option means that muxed audio is extracted if there are more than one muxed audio track in the video file.
• features.trackExtraction.extractSubtitles - Default: "never". Setting to control if muxed subtitles in the video file should be extracted or not. Possible values are "never", "always" and "if_necessary". The "if_necessary" option means that muxed subtitles is extracted if there are any supported muxed subtitle track in the video file.
• features.trackExtraction.trackExtractorOptions - Settings that controls how the track extractor works. Note that only the properties are configurable, not the methods. Read more about TrackExtractorOptions here
• videoFileDisplay - Default: "%filename (%tag, %id)". Template string to customize how to display video files in the media tab and metadata tab. The template values will be replaced by actual properties of the file. Possible template values: %filename, %id, %tag, %asset and %language. It is also possible to specify any metadata values of the file by prepending the metadata key by %metadata:, i.e. %metadata:date.
• audioFileDisplay - Default: "%filename (%tag, %id, %channels channels)". Template string to customize how to display audio files in the metadata tab, media tab and timeline. The template values will be replaced by actual properties of the file. Possible template values: %filename, %id, %tag, %language, %asset and %channels. It is also possible to specify any metadata values of the file by prepending the metadata key by %metadata:, i.e. %metadata:date.
• subtitleFileDisplay - Default: "%filename (%tag, %id, %language)". Template string to customize how to display subtitle files in the metadata tab, media tab and timeline. The template values will be replaced by actual properties of the file. Possible template values: : %filename, %id, %tag, %asset and %language. It is also possible to specify any metadata values of the file by prepending the metadata key by %metadata:, i.e. %metadata:date.
• videoFileOrder - Default: []. This controls the ordering of video files in the media tab. The files are first ordered by the first value in the list, then by the second and so on. With no ordering specified the files will be displayed in the order that they are found in the asset. Alternatives are tag, filename, language and id. It is also possible to order the files based on metadata values by pre-pending metadata: to a metadata key, e.g. metadata:date.
• audioFileOrder - Default: []. This controls the ordering of audio files in the media tab, metadata tab, and timeline. The files are first ordered by the first value in the list, then by the second and so on. With no ordering specified the files will be displayed in the order that they are found in the asset. Alternatives are tag, filename, language, id and channels. It is also possible to order the files based on metadata values by pre-pending metadata: to a metadata key, e.g. metadata:date.
• subtitleFileOrder - Default: ["id"]. This controls the ordering of subtitle files in the media tab and timeline. The files are first ordered by the first value in the list, then by the second and so on. Alternatives are tag, filename, language and id. It is also possible to order the files based on metadata values by pre-pending metadata: to a metadata key, e.g. metadata:date.
• subtitleStartTimeFallback - Default: ["scc", "stl", "timespan", "pac"]. Controls the subtitle types that automatically use the same start time as the video, unless the subtitle file itself has a defined start time (file.container.startTime). Possible values are "vtt", "scc", "srt", "stl", "imsc", "itt", "cap", "pac" and "timespan",
• channelNamesMetadataKey - See Channel names metadata
• filesTabAllowedFileTypes - List of file types, e.g. ['AUDIO', 'VIDEO', 'SUBTITLE']. Files matching any of these types will be shown in the files tab.
• timelineFilterQueryParams - Default: ["assetId", "mainAssetId"]. This controls the unique identifier used to store the timeline filter. Search query parameters added to this array will be used when storing the timeline filter. If the array is left empty, all search query parameters will be used.
• excludeTabs - List of tabs to exclude from Validate. Possible values are: "metadata", "media", "audio", "markers", "files". Default value is ["files"].
• profileMetadataKey - The metadata key used for the audio profile when using virtual tracks.
• virtualTracksMetadataKey - The metadata key used for the virtual tracks JSON data.
• virtualTracksFileOrderMetadataKey - The metadata key to use to order files when using virtual tracks. Defaults to "order". The files are ordered by id if no order is set on the included files. The video file is always ordered first if it contains audio.
• disableMuxedAudio - When set to true, disables muxed audio when loading validate.
• disableFirstTrackAutoEnable - When set to true, no discrete audio is automatically enabled if no muxed audio is available or disableMuxedAudio is set to true.
• maxOutputChannelCount - Default 2. Limits the output channels by downmuxing to the given value. Use a higher value (e.g. 8) to enable 5.1 or 7.1 output. Output is also limited by the maximum channel count your hardware reports to the browser.
• enabledWorkspaces - A list of workspace ids, controls which workspaces should be enabled. Optional, all workspaces will enabled by default. Possible values are: "General", "Audio", "Adbreak".
• disableZeroDurationMarkers - Default false. Prevents the creation of zero-duration markers when set to true. Should only be used together with endFrameInclusive: false.
• seekStrategy - Default regular. Possible values are "regular" and "queued". When issuing a new seek; "regular" seek will abort the current seek operation and issue a new seek operation while "queued" seek will wait for the current seek operation to finish before issuing a new seek operation. "regular" seek is recommended when using track extractor while "queued" seek will improve performance when using timeline slider.
• audioTracks - List of audio tracks available in audio profiles, see Audio track. This is used when the virtual tracks feature is enabled.
• audioProfiles - List of audio profiles available, see Audio profile. This is used when the virtual tracks feature is enabled.
• markerTableDefinitions - List of marker table definitions, see Marker table definitions. This is used to set the default column layout of the marker table.
• safeAreas - List of safe area options accessible from the player toolbar.
• enabled - Determines the safe area is enabled or not. Disabled safe areas do not appear in the toolbar.
• url - Publicly accessible url to the overlay image, that should cover the complete image.
• id - Optional. Unique id, defaults to same as url
• name - Display label for the safe area.
• aspectRatio - Aspect ratio given in the string form width:height, that this safe area supports.
  • Note that the safe area will only be available for videos with the same aspect ratio as defined here.

Channel names metadata

Validate supports displaying custom channel names in the timeline. This data should be of type json string array, for example

"["Channel 1", "Channel 2"]"

and should be located in the audio stream metadata. The first entry in the array will be the name for channel[0] and so on.

The setting channelNamesMetadataKeyshould point out the key for the metadata entry.

Audio track

The audio track

{
  id: "stereo",
  name: "Stereo",
  channelCount: 2,
  channelNames: ["L", "R"],
}

• audioTracks - id - Id of the audio track, unique amongst audio tracks. Used when specifying a audio profile.
• audioTracks - name - Name of the audio track, used for display in validate.
• audioTracks - channelCount - Number of channels included in the audio track.
• audioTracks - channelNames - Names of the channels, ordered by index. Used for display in validate.

Audio profile

{
  id: "3",
  name: "Profile 3",
  tracks: ["mono", "stereo"],
},

• audioProfiles - id - Unique id of the audio profile.
• audioProfiles - name - Name of the audio profile. Used for display in validate.
• audioProfiles - tracks - Array of audio track ids included in the audio profile. Ordered by index.

Marker table definitions

Example:

[{
  id: "name",
  label: "Name",
  enabled: true,
  scope: "#/metadata/name",
  format: "STRING",
},
{
  id: "start",
  label: "Start",
  enabled: true,
  scope: "#/start",
  format: "TIMECODE",
},
{
  id: "advanced",
  label: "Advanced",
  enabled: true,
  scope: [
    "#/metadata/name",
    "#/metadata/ad_break_type",
  ],
  valueMapper: value => "prefix " + value,
  format: "STRING",
}],

• markerTableDefinition - id - Id for this column
• markerTableDefinition - label - Display label for the column in the marker table.
• markerTableDefinition - enabled - Controls if the column is visible or not.
• markerTableDefinition - scope - A path that points to some data in the marker to display. Also accepts an array of paths or a lambda
• when passed an array the first path that yields a value will be used for the table cell
• the lambda takes a marker and returns a field value, useful for more complex lookups
• markerTableDefinition - valueMapper - optional Takes a map or a lambda for remapping one value to another
• when passed a map any value that matches a key in the map will cause the corresponding value in the map to be used instead
• the lambda takes a value and returns another (or the same), make sure to check value types as values can be strings, string arrays or numbers
• markerTableDefinition - format - How the data in the column should be formatted. Possible values are STRING, DATE,TIME, DATETIME, ARRAY, STRING, INTEGER, DECIMAL, BOOLEAN, TIMECODE and DURATION

Edit Settings

Settings for the Edit application:

apps: {
    edit: {
      features: {
        autoSaveEnabled: true,
        autoSaveDebounceTime: 3000,
        saveSequence: false,
      },
      original: {
        tag: "original",
      },
    }
}

• features.autoSaveEnabled - Default: true. Enable/disable auto save. We recommend disabling auto save when running on a Vidispine backend to reduce amount of changesets created.
• features.autoSaveDebounceTime - (Optional, default: 3000). When autoSaveEnabled is set to true, this controls how long the program will wait (in milliseconds) before saving changes.
• features.saveSequence - (Optional, default: false). Only applicable when using Vidispine. If set to true, timeline changes will also be reflected in a sequence document on the project asset.
• features.browseAssets - (Optional, default: true). Controls if the user is allowed to browse for additional source assets.
• features.browseProjects - (Optional, default: true). Controls if the user is allowed to browse for other projects.
• original.tag - Default: original. The tag that marks the original file.
• metadataKeys - Allows configuration of metadata keys stored by edit on asset level. Changing these will break any projects previously created with other settings!
• metadataKeys.assetType - Default: asset_type.
• metadataKeys.sourceAssetId - Default: source_asset_id.
• metadataKeys.editLockId - Default: edit_edl_lock_id.

Poster Settings

Settings for the Poster application:

apps: {
  poster: {
    supportedFormats: [
      {
        value: "jpeg"
        label: "JPEG",
      }
    ],
    supportedAspectRatios: [
      {
        name: "Standard widescreen",
        scale: "16:9",
        ratio: 0.562,
        standard: true
      },
    ],
    defaultAspectRatio: "16:9",
    supportedResolutions: [
      {
        resolution: "1920x1080",
        name: "FHD",
        width: 1920,
        height: 1080,
        ratio: 0.562,
      },
    ],
    guidelineLayouts: [
      {
        name: "None"
      },
      {
        name: "Thirds",
        horizontalPattern: 2,
        verticalPattern: 2
      },
      {
        name: "Golden Ratio",
        horizontalPattern: [0.382, 0.618],
        verticalPattern: [0.382, 0.618],
      },
      {
        name: "Diagonal",
        predefinedLayout:
        "diagonal"
      },
    ],
    presets: [
      {
        name: "Preset 1 (16:9, 1920x1080, JPEG)",
        aspectRatio: "16:9",
        resolution: "1920x1080",
        format: "jpeg",
      },
    ],
    overlays: [
      {
        id: "logo-overlay-id",
        name: "Logo overlay",
        url: "http://example.com/logo-overlay",
        aspectRatio: "16:9",
      },
    ],
    includedMarkerGroups: [
      "Manual",
      "Rekognition",
    ]
  }
}

• supportedFormats
• label - Display label for the format in the poster edit form.
• value - Value that will be passed to the backend when creating a poster with this format.
• supportedAspectRatios
• scale - The ratio given as width:height in text.
• ratio - Ratio of the scale, i.e. height divided by width. Limit to maximum of 3 decimals without rounding.
• name - optional` - Display label for the aspect ratio in the poster edit form.
• defaultAspectRatio - optional` - The entry from supportedAspectRatios in string form width:height to be preselected when editing a snapshot.
• supportedResolutions
• resolution - Actual resolution given as a <width>x<height> text string.
• width - Width of the resolution.
• height - Height of the resolution.
• ratio - Ratio of the resolution i.e height divided by width. Limit to maximum of 3 decimals without rounding.
• name - optional` - Display label of the of resolution in the the poster edit form.
• guidelineLayouts
• name - optional` - Display label of the of the guideline layout in the poster room toolbar.
• horizontalPattern - Pattern for horizontal guidelines.
  • Given an integer, that many horizontal lines will be evenly spaced on top of the image as an overlay.
  • Given an array with values within the range 0-1 it will place horizontal guidelines on the corresponding height*value height.
• verticalPattern - Pattern for vertical guidelines.
  • Given an integer, that many vertical lines will be evenly spaced on top of the image as an overlay.
  • Given an array with values within the range 0-1 it will place vertical guidelines on the corresponding width*value width.
• predefinedLayout - Will exclusively use a predefined pattern instead of using the the horizontalPattern/verticalPattern.
  • triangle - Will show a layout that divides the overlay in four triangles, with two of them covering the whole width.
  • diagonal - Will show a layout with diagonals going from the corners to a point on the opposite horizontal line, an image height away from the vertical of the image.
• presets - Presets choices in the poster edit form that has a defined resolution, format and aspectRatio.
• format - Format the preset uses, must be defined in supportedFormats.
• resolution - Resolution the preset uses, must be defined in supportedResolutions.
• aspectRatio - Aspect ratio the preset uses, must be defined in supportedAspectRatios.
• name - Display label for the presets, shown in the poster edit form.
• overlays - Overlay options accessible from the poster room toolbar.
• id - ID that must be unique.
  • If you specify the same id twice the one defined last in the array will be the only used.
  • If you have an overlay defined via the settings API with the same id as in the settings.js then the settings API overlay will be used.
• name - Display label for the overlay, displayed in the poster room toolbar.
• url - Publicly accessible url to the overlay image, that should cover the complete image.
• aspectRatio - AspectRatio given in the string form width:height, that this overlay supports.
  • Note that the overlay will only work if you're trying to make a poster with the aspectRatio the overlay is configured and made for.
• includedMarkerGroups - The marker group ids that should be shown in the timeline in the Poster app. An array of strings.

Ingest

Settings for the ingest route.

{
  ingest: {
    preferredVideoTags: ["mp4", "mp4-lowres", "original"],
    preferredAudioTags: ["aac", "6track"],
    preferredSubtitleTags: ["original"]
  }
}

• ingest.preferredVideoTags - Array of tags available to select when ingesting a video file.
• ingest.preferredAudioTags - Array of tags available to select when ingesting an audio file.
• ingest.preferredSubtitleTags - Array of tags available to select when ingesting a subtitle file.

Markers

Settings for QC markers are used for

• separating markers into different groups and rows
• defining how those groups and rows should be represented
• mapping customer specific metadata to our internal representation
• configuring manual or dynamic tracks to hold markers in backend
• controlling which rows should allow creation of markers

exportType: string,
exportFormats: string[],
timelineDataSources: TimelineDataSource[],
metadataCopyBlocklist: string[],  
groups: [{
  id: MarkerSettingsDynamicValue<string>,
  trackType: string,
  alwaysHide: MarkerSettingsDynamicValue<boolean>,
  alwaysShow: MarkerSettingsDynamicValue<boolean>,
  forceShowInMarkerForm: MarkerSettingsDynamicValue<boolean>,
  markerStyle: MarkerSettingsDynamicValue<MarkerStyle>,
  match: (marker: AvMarker) => boolean,
  order: MarkerSettingsDynamicValue<number>,
  readOnly: MarkerSettingsDynamicValue<boolean>,
  title: MarkerSettingsDynamicValue<string>,
  maxRowsBeforeCollapsed: MarkerOrTrackSettingsDynamicValue<boolean>,
  startTime: MarkerOrTrackSettingsDynamicValue<TimeCodeDto>

  rows: [{
    markerType: string,
    tooltip: MarkerSettingsDynamicValue<string>,
    tooltipFallback: MarkerSettingsDynamicValue<string>,
    track: MarkerSettingsDynamicValue<string>,
    alwaysHide: MarkerSettingsDynamicValue<boolean>,
    alwaysShow: MarkerSettingsDynamicValue<boolean>,
    forceShowInMarkerForm: MarkerSettingsDynamicValue<boolean>,
    markerStyle: MarkerSettingsDynamicValue<MarkerStyle>,
    match: (marker: AvMarker) => boolean,
    order: MarkerSettingsDynamicValue<number>,
    readOnly: MarkerSettingsDynamicValue<boolean>,
    title: MarkerSettingsDynamicValue<string>,
    maxCollisionsBeforeCollapse: MarkerSettingsDynamicValue<number>,
    startTime: MarkerOrTrackSettingsDynamicValue<TimeCodeDto>,
    tag: MarkerSettingsDynamicValue<string | TrackTagSettings>,
    names: MarkerSettingsDynamicValue<string[]>,
    form: string,
  }]
}],
markersMetadataSettings: [{
  match: (string) => boolean,
  mappings: [{
    name: string,
    description: string,
    trackId: string,
    [key: string]: string
  }]
}],
tracksMetadataSettings: [{
  match: (string) => boolean,
  mappings: [{
      name: string,
      description: string,
      [key: string]: string
  }]
}]

• exportType - Determines the export method to use for exporting markers. Can be set to core or frontend. Defaults to core. core exports markers using the AV Core backend, the exported file is stored on a storage with the marker_export tag and the user is prompted to download the file from the storage when the export is complete. If you set this to frontend the user is prompted to download a temporary file generated on the frontend.
• exportFormats - Export formats to enable in the marker exports menu. Defaults to ["CSV", "XML", "JSON"]
• timelineDataSources - Specify the sources of which to create groups and tracks, possible values are track, settings and markers. Defaults to ["tracks", "settings", "markers"]
• metadataCopyBlocklist - A list of metadata keys to exclude when copying a marker.
• group.id - Identifier for the group. Note, when using a callback here, each unique id generates a new group.
• group.alwaysHide - Hide the group from UI.
• group.alwaysShow - Show the group and its rows even if it contains no markers.
• group.forceShowInMarkerForm - If set to true, even if group.alwaysShow is false and no markers are available on the track, the group is still selectable when creating a marker.
• group.markerStyle - Style for all markers within this group.
• group.match - Matcher function determining if a marker matches this group.
• group.order - Number determining the sort order between groups.
• group.readOnly - Prevent user from creating markers for this group.
• group.startTime - Set to indicate start time of marker time codes within the group. Markers created in this group will also be saved with the given start time offset.
• group.title - Title to show in timeline.
• group.maxRowsBeforeCollapsed - If the group has more than this number of rows it will initially be collapsed in the timeline. The user can then click on the group to expand it.
• group.metadata - Custom metadata added to tracks created for this group.
• row.markerType - Mapped to TimeSpanDto when creating marker. If this is not defined, row.readOnly will always be true.
• row.tooltip - Tooltip to show when hovering over marker.
• row.tooltipFallback - Text to display if tooltip configured in row.tooltip is undefined. Defaults to empty string "".
• row.track - Used for identifying the row. Note, when using a callback here, each unique id generates a new row.
• row.alwaysHide - Hide the row from UI. Overrides group.alwaysHide
• row.alwaysShow - Show the row even if it contains no markers. Overrides group.alwaysShow
• row.forceShowInMarkerForm - If set to true, even if row.alwaysShow is false and no markers are available on the track, the group is still available when creating a marker.
• row.markerStyle - Style for all markers within this row. Overrides group.markerStyle
• row.match - Matcher function determining if a marker matches this row.
• row.order - Number determining the sort order of between rows in this group.
• row.readOnly - Prevent the user from creating markers for this row.
• row.title - Title to show in timeline.
• row.allowEditTrack - Determines if edit track functionality is enabled. Default true.
• row.allowDeleteTrack - Determines if delete track functionality is enabled. Default true.
• row.isDefaultTrackForMarkerCreation - When set to true, this track is the default track selected when creating markers. Can only be set to true on one marker track. If not set on any track, the first writeable track is selected.
• row.maxCollisionsBeforeCollapsed - If the row has more than this number of collisions it will initially be collapsed in the timeline (each marker overlap is a collision that generates a new row).
• row.tag - If tag is configured on the row, a label tag is displayed on the row in timeline.
• row.names - DEPRECATED: Use Custom Forms instead. If there are names on a marker row, the marker form displays the name field as searchable list with names from the selected track. If there are no names on the selected track, the form fall backs to a regular text field. Could for example be used with Multi-value track metadata
• row.markerMetadata - Custom metadata added to markers created on this row.
• row.startTime - Set to indicate start time of marker time codes within the row. Markers created on this track will also be saved with the given start time offset.
• row.form - Set to identify what form to be used for a specific row, see Forms. If no form is specified the form with key "defaultMarker" will be used. If row.form is set to null, no form will be used.
• markersMetadataSettings - Array of settings used for mapping marker metadata keys between backend adapter and frontend scheme.
• markersMetadataSettings.match - Matcher function using marker type to determine if metadata mapping should be used for a marker.
• tracksMetadataSettings - Array of settings used for mapping track metadata keys between backend adapter and frontend scheme.
• tracksMetadataSettings.match - Matcher function using track type to determine if metadata mapping should be used for a track.
• discreteFiles - Settings for discrete marker files Discrete files

metadata format

The return type of metadata setting has to be an object:

metadata: (marker, track) => {
  return {
    number: 1,
    boolean: true,
    string: "string",
  };
};

The values in the object have to be one of the types string, boolean, or number. Values not conforming to this will not be used. If tracksMetadataSetting is defined the keys in metadata object have to be specified in tracksMetadataSetting.

This setting will override metadata names used in frontend (e.g. name).

tag property

The tag property is used to display extra information on a timeline row. The tag can either be defined as a string or an object containing tag: string and type: TrackTagType.

The track tag type can be either badge or description

tag: (marker, track) => {
  return {
    tag: "This is the tag",
    type: TrackTagType.Description,
  };
};

tag: (marker, track) => {
  return "This is the tag";
};

When only specifying a string the type will default to badge.

match property

The match property is used to match a marker or a track to a settings-block. The unique id (for groups) or track (for rows) is what separates the markers into different groups and rows.

It takes a callback (marker?: AvMarker, track?: AvTrack) => boolean. Note that both marker and track may be undefined. This allows the user to separate markers and tracks in numerous ways:

// Separate on marker type
match: marker => marker && marker.type === "Baton",

// Separate on metadata fields
match: marker => marker && marker.metadata.get("trackId") !== null,

// Match all
match: () => true

markerMetadataSettings and tracksMetadataSetting

For markerMetadataSettings and tracksMetadataSetting the match property instead takes a callback (type: string) => boolean where type is the marker (or track) type.

(type) => type === "Baton";

MarkerSettingsDynamicValue\ type

Most of the properties use this type which is either T or a callback (marker?: AvMarker, track?: AvTrack | null) => T.

// Get tooltip from marker metadata field "name".
tooltip: marker => marker && marker.metadata.get("name"),

// Display this text if tooltip is not set
tooltipFallback: "No name",

// Get title from marker.type
title: marker => marker && marker.type,

// Set specific title
title: "Info",

// Set row title based on track (with fallbacks)
title: (marker, track) =>
  (track && track.metadata.get("name")) ||
  (marker && marker.metadata.get("trackId")) ||
  "No track found",

Multi-value track metadata

The track object contains an extra field named metadataArrayValues which contains the same data as metadata, but with string[] values instead of strings.

metadata: Map<string, string>;
metadataArrayValues?: Map<string, string[]>;

In addition to the metadata available in the metadata field, if there are multiple values for the same key the metadataArrayValues field will hold all values to the string[].

For example, with this data available in the backend:

{
  "metadata": [
    {
      "key": "av_track_names",
      "value": "This is multivalue 1"
    },
    {
      "key": "av_track_names",
      "value": "This is multivalue 2"
    },
    {
      "key": "name",
      "value": "Multi value track"
    }
  ]
}

The results of the track object would be

{
  "metadata": {
    "av_track_names": "This is multivalue 2",
    "name": "Multi value track"
  },
  "metadataArrayValues": {
    "av_track_names": ["This is multivalue 1", "This is multivalue 2"],
    "name": ["Multi value track"]
  }
}

discreteFiles property

Settings for discrete files.

discreteFiles: {
  VIDCHECKER: {
    tag: "qc";
  }
}

• VIDCHECKER Settings for handling of Vidchecker files
• tag This setting controls which files are to be handled as Vidchecker files (and be parsed). If a file has a metadata field tag set, that matches the value of this setting, it will be considered a Vidchecker file. Note that when using the vidispine adapter, the tag metadata field is set from the shape-tag.

Examples

Below are some examples of different marker setups.

Read-only markers

groups: [
  {
    match: (marker) => marker && marker.type === "Baton",
    title: "Baton",
    id: "Baton",
    readOnly: true,
    rows: [
      {
        match: () => true, // Default
        track: ({ metadata }) => metadata.get("trackId"),
        title: ({ metadata }) => metadata.get("trackId"),
        tooltip: ({ metadata }) => metadata.get("name"),
        order: ({ metadata }) => {
          switch (metadata.get("trackId")) {
            case "Info":
              return 0;
            case "Warning":
              return 1;
            case "Serious":
              return 2;
          }
          return -Infinity;
        },
        markerStyle: ({ metadata }) => {
          switch (metadata.get("trackId")) {
            case "Warning":
              return { backgroundColor: "#dd5858" };
            case "Serious":
              return { backgroundColor: "#c73535" };
          }
          return undefined;
        },
      },
    ],
  },
];

We match the group on marker type. trackId is used to separate the different rows applying order and style.

Manual markers, static track

groups: [
  {
    match: (marker, track) => (marker && marker.type === "Manual") || (track && track.type === "Manual"),
    title: "Manual",
    id: "Manual",
    alwaysShow: true,
    allowCreateTrack: true,
    rows: [
      {
        match: (marker) => marker && marker.metadata.get("trackId") === "av:track:warning",
        track: "av:track:warning",
        title: "Warning",
        tooltip: ({ metadata }) => metadata.get("name"),
        tooltipFallback: ({ metadata }) => metadata.get("fallback_tooltip"),
        order: 1,
        markerType: "Manual",
        markerStyle: { backgroundColor: "#c73535" },
      },
      {
        match: (marker) => marker && marker.metadata.get("trackId") === "av:track:serious",
        track: "av:track:serious",
        title: "Serious",
        tooltip: ({ metadata }) => metadata.get("name"),
        order: 2,
        markerType: "Manual",
        markerStyle: { backgroundColor: "#c73535" },
      },
      {
        match: (marker) => marker && marker.metadata.get("trackId") === "av:track:info",
        track: "av:track:info",
        title: "Info",
        tooltip: ({ metadata }) => metadata.get("name"),
        order: 0,
        markerType: "Manual",
      },
      {
        // Markers from user tracks generated in UI.
        match: (marker, track) => !!(marker && marker.metadata.get("trackId")) || !!track,
        track: (marker, track) => track.id,
        title: (marker, track) => track && track.metadata.get("name"),
        tooltip: (marker) => marker && marker.metadata.get("name"),
        order: (marker, track) => parseInt(track && track.id, 10) ?? 4,
        markerType: "Manual",
        alwaysShow: false,
        names: (marker, track) => track?.metadataArrayValues?.get("names") || ["Name 1", "Name 2"],
      },
      {
        match: () => true, // Default
        id: (marker) => marker.type,
        title: (marker) => marker.type,
        alwaysHide: true,
        rows: [],
      },
    ],
  },
];

We define the marker type "Manual". This is used in the match property on the group (to find the correct group setting for the marker) and when mapping marker metadata using markerMetadataSettings. markerType is also set to "Manual" on each row to ensure that new markers are created with the correct type. We define different rows using track property and match them using the trackId metadata field.

On group level allowCreateTrack is used to allow users to manually create tracks in th UI for this group.

On row level we set alwaysShow to ensure that the rows are shown even when there are no markers.

Hide by default

groups: [
  {
    match: () => true, // Default
    id: (marker) => marker.type,
    title: (marker) => marker.type,
    alwaysHide: true,
    rows: [],
  },
];

The last group, the default case, matches everything and sets alwaysHide to ensure that those markers are hidden.

Row title from track

row.title: (marker, track) =>
  (track && track.metadata.get("name")) ||
  marker.metadata.get("trackId") ||
  "No track found",

Track is also passed as an argument to MarkerSettingsDynamicValue function which allows us to connect track to a row.

Mapping marker and track metadata

markersMetadataSettings: [
  {
    match: (type) => type === "AvMarker",
    mappings: {
      name: "av_marker_name",
      description: "av_marker_description",
      trackId: "av_marker_track_id",
    },
  },
];

We map the metadata names used in backend (e.g. av_marker_name) to the names we use in frontend (e.g. name). This mapping is done before markers are parsed, which means the frontend name can be used in MarkerSettingsDynamicValue functions. It is also done the other way around when we post markers to backend.

tracksMetadataSettings: [
  {
    match: (type) => type === "VpubTrack",
    mappings: {
      name: "av_track_name",
      description: "av_track_description",
      names: "av_track_names",
    },
  },
];

Mapping is done in the same way for tracks.

Start time

groups: [
  {
    ...
    // Start time of markers in this group
    startTime: {
      frame: 3600, // 01:00:00:00
      numerator: 1,
      denominator: 1
    },
    rows: [
      {
        ...
        // Start time can also be set per row
        // this will override any start time set on the group
        startTime: {
          frame: 45000, // 00:30:00:00
          numerator: 25,
          denominator: 1
        },
        ...
      }
    ],
    ...
  }
];

Start time is set to accommodate for time code offsets in the marker data. For example if markers have been imported from an external source where all time codes starts at 01:00:00:00. In this case, setting startTime to 01:00:00:00 means the application will compensate for that and display the markers starting from 00:00:00:00 instead.

Timeline

Settings for the timeline.

timeline: {
  waveforms: {
    visibility: "show",
    active: "vidispine",
    vidispine: {
      tag: "original",
      shape: null,
      sampleMin: -43,
      sampleMax: 0
    },
    analyze: {
      url: "https://localhost:8080/",
      urlReplaceFrom: "",
      urlReplaceTo: "",
      sampleMin: -43,
      sampleMax: 0,
      authentication: {
        basic: {
          username: "",
          password: "",
        },
        method: "basic",
        enabled: true,
      }
    },
    file: {
      sampleMin: -43,
      sampleMax: 0,
    },
    metadataKeys: {
      track: "waveform:track",
      sourceFileId: "waveform:source_file_id",
      sampleRate: "waveform:ar",
      channels: "waveform:channels",
    },
    requestDebounceTimeMs: 250,
    drawType: "stroke_fill"
  }
}

• waveforms - Describes how waveforms should be retrieved.
• waveforms.visibility - String determining if waveform track should be shown, disabled or hidden ("show", "disable", "hide").
• waveforms.active - String determining which profile to use ("file", "vidispine" or "analyze"). If vidispine or analyze is used, Accurate.Video will always try to fetch waveforms from file before trying either vidispine or analyze. If file is selected Accurate.Video will only try to fetch waveforms from file.
• waveforms.vidispine - Profile for fetching waveforms from Vidispine adapter. If
• waveforms.vidispine.tag - Shape tag to fetch waveform from (see Vidispine API).
• waveforms.vidispine.shape - Shape id to fetch waveform from (see Vidispine API).
• waveforms.vidispine.sampleMin - Adjust scaling of waveform.
• waveforms.vidispine.sampleMax - Adjust scaling of waveform.
• waveforms.analyze - Profile for fetching waveforms from Accurate Analyze.
• waveforms.analyze.url - Url to Accurate Analyze.
• waveforms.analyze.urlReplaceFrom - Regular expression or search string.
• waveforms.analyze.urlReplaceTo - Text to replace with.
• waveforms.analyze.sampleMin - Adjust scaling of waveform.
• waveforms.analyze.sampleMax - Adjust scaling of waveform.
• waveforms.analyze.authentication - Authentication settings.
• waveforms.analyze.authentication.enabled - (Optional, default: false) Enable or disable authentication.
• waveforms.analyze.authentication.method - Sets the authentication method to use. Use one of: basic or query".
• waveforms.analyze.authentication.basic - Settings when using authentication method basic.
• waveforms.analyze.authentication.basic.username - Username to use for basic authentication.
• waveforms.analyze.authentication.basic.password - Password to use for basic authentication.
• waveforms.analyze.authentication.query - Settings when using authentication method query.
• waveforms.analyze.authentication.query.tokenParameter - This is the query parameter to be used for authentication if query authentication method is used.
• waveforms.analyze.authentication.query.tokenPrefix - This is the token sent to backend i.e set header Authorization SETTING_VALUE token when query authentication method is used.
• waveforms.file - Profile for fetching waveforms from file.
• waveforms.file.sampleMin - Adjust scaling of waveform.
• waveforms.file.sampleMax - Adjust scaling of waveform.
• waveforms.metadataKeys.track - The metadata key used to identify the track of a waveform file.
• waveforms.metadataKeys.sourceFileId - The metadata key used to identify the source file id of a waveform file.
• waveforms.metadataKeys.sampleRate - The metadata key used to identify the sample rate of a waveform file.
• waveforms.metadataKeys.channels - The metadata key used to identify channel count of a waveform file.
• waveforms.requestDebounceTimeMs - Default: 250. The debounce time used by the waveform components in the timeline before requesting new data. This can be set to a lower value when using waveform files as those requests are read from memory.

urlReplaceFrom and urlReplaceTo modifies the url that is passed to Accurate Analyze. waveforms.analyze.url is used to as input for this replacement but it is also used as base when calling Accurate Analyze.

Storages

Settings for storages.

storages: {
  tags: ["original", "lowres"],
  awsRegions: [
    {
      label: "us-east-2",
      value: "us-east-2",
      rekognition: false
    },
    autoIngest: {
          manifestFormats: [
            {
              label: "default",
              value: ""
            },
            {
              label: "My special format",
              value: "*.json"
            },
            ...
          ],
          ingestTemplates: [
            {
              label: "default",
              value: ""
            },
            {
              label: "My special template",
              value: "my_ingest"
            },
            ...
          ]
        }
  ]
}

• storages.tags - List of default storage tag suggestions presented when adding or editing a storage.
• storages.awsRegions - List of AWS Regions to support. label is what we present to the user, value is the region code.
• storages.autoIngest.manifestFormats - List of manifest formats used in the add/edit storage dialog.
• storages.autoIngest.ingestTemplates - List of ingest templates used in the add/edit storage dialog.

Authentication

Settings for authentication.

authentication: {
  enabled: true,
  tokenStorageLocation: "av_jwt_token",
  whoamiCookies: ["csrftoken", "sessionid"],
  method: "keycloak",
  query: {
    tokenParameter: "u",
    tokenPrefix: "AV"
  },
  keycloak: {
    configUrl: "./assets/json/keycloak.json"
  },
  cookie: {
    cookieName: "AUTH_TOKEN",
    tokenPrefix: "token",
    deleteCookieOnLogout: true
  },
  oidc: {
    authority: "https://my-open-id-connect-provider.com",
    client_id: "2985y23890trhx913h5807hv35",
    redirect_uri: "http://my-accurate.video/",
    scope: "openid email profile"
  },
  unauthorized: {
    message: {
      title: "Authentication failed",
      content: "You need to login to continue",
      action: "Login"
    }
    redirect: ""
  }
}

• enabled - (Optional, default: true) Enable or disable authentication.
• method - (Optional, default: keycloak) Sets the authentication method to use. Use one of: keycloak query, basic, cookie or oidc. Note: keycloak is deprecated in favor of oidc and will change in future major release
• tokenStorageLocation - (Optional, default: av_jwt_token) local storage key to store token.
• whoamiCookies - (Optional, default: ["csrftoken", "sessionid"]) list of cookie names for which if changes are detected, user info is fetched. The cookie.cookieName settings is always included in this list if defined.
• keycloak.configUrl - (Optional, default: ./assets/json/keycloak.json) Location of keycloak adapter configuration (Keycloak OIDC JSON).
• query.tokenParameter - (Optional, default u) This is the query parameter to be used for authentication if query authentication method is used.
• query.tokenPrefix - (Optional, default AV) This is the token that will be sent to backend i.e set header Authorization SETTING_VALUE token when query authentication method is used.
• cookie.cookieName - (Optional) This is the name of the cookie from which the authentication token should be fetched if cookie authentication method is used.
• cookie.tokenPrefix - (Optional) Backend authentication type to be used when cookie authentication is in effect. Commonly used types are Basic and Bearer.
• cookie.deleteCookieOnLogout - (Optional, default: false) Enable or disable deletion of the cookie specified in cookie.cookieName on current domain and path=/ upon logout.
• oidc - (Optional) OpenID Connect client configuration, see OIDC Client UserManagerSetting Configuration.
• oidc.userStorageType - (Optional, default: window.sessionStorage) Function returning the user store for OpenID Connect (window.localStorage/window.sessionStorage). By default window.sessionStorage is used.
• oidc.tokenType - (Optional, default: ACCESS) If set to ID the Id-token is used instead of the Access-token when calling an external api.
• unauthorized.redirect - (Optional) If set, this will redirect user to another location if unauthorized or logged out. Could be used if AV is launched from a separate system.
• unauthorized.message - (Optional) If set, this will show a message to the user before the user is redirected to unauthorized.redirect.

Common features

Features that may span across several applications.

features: {
  assetStatus: false,
  enrichAsset: false
  usageView: false,
  videoContextMenu: true,
  disableAppNavigation: false,
}

• features.assetStatus - Default: false. Allow user to set status for an asset. See asset status.
• features.enrichAsset - Default: false. Allow user to run enrich services like Amazon Rekognition on assets. See enrich
• features.usageView - Default: false. Will show application usage for a user with the usage_view role, next to the about button on the asset view.
• features.videoContextMenu - Default: true. If set to false, the right-click context menu will be removed from any video elements.
• features.disableAppNavigation - Default: false. If set to true, user cannot switch between apps using button in header.

Asset status

Settings for asset status feature. If a custom form (see Forms) is specified with a corresponding ui schema the form will be added to the asset status modal. Note that feature settings.features.assetStatus is disabled by default.

assetStatus: {
    statusMetadataFieldName: "asset_status",
    commentMetadataFieldName: "asset_status_comment",
    statusSetByMetadataFieldName: "asset_status_set_by",
    statuses: [
      {
        key: "in_progress",
        labels: {
          status: "In progress",
        },

        form: "inProgressAssetStatusForm",
        color: "var(--AP-FOREGROUND-2)",
      },
      {
        key: "pending",
        labels: {
          status: "Pending",
        },
        form: "pendingAssetStatusForm",
        color: "var(--AP-FOREGROUND-2)",
      },
      {
        key: "approved",
        type: "approved",
        labels: {
          status: "Approved",
          assign: "Approve",
        },
        form: "approvedAssetStatusForm",
        color: "var(--AP-SUCCESS)",
      },
      {
        key: "rejected",
        labels: {
          status: "Rejected",
          assign: "Reject",
        },
        color: "var(--AP-ERROR)",
        revokable: false,
        allowComment: true
    }
  ]
}

• statusMetadataFieldName - Name of metadata field to store status. Default "asset_status".
• commentMetadataFieldName - Name of metadata field to store comment. Default "asset_status_comment".
• statusSetByMetadataFieldName - Name of metadata field to store user that set the current status. Default "asset_status_set_by".
• statuses - List of possible statuses.
• statuses - key - Status key as defined by customer. undefined maps to an asset that has no status.
• statuses - labels - Defines how this status should be presented in UI.
• statuses - labels.status - Label to use when this status has been set.
• statuses - labels.assign - Optional. Label to use in confirm button when setting this status.
• statuses - form - Optional. A custom form to add to the asset status modal.
• statuses - color - Optional. Custom color for this status.
• statuses - revokable - Default true. If false, it is not possible to change to a different status after setting this status. E.g. preventing a rejected asset from becoming approved.
• statuses - allowComment - (Deprecated)Optional. Allows the user to comment the status. E.g. explain why the status was rejected.
• statuses - hidden - Optional. Hides the asset status from the drop down list where a user sets the status. Useful for states that should only be settable by an external system.

Asset jobs

These setting are used to configure the metadata fields for jobs running for a specific asset. There will be a spinner next to the asset title indicating active jobs. Notifications will be shown for finished and failed jobs.

assetJobsSettings: [
  {
    jobType: AssetJobType.Enrich,
    jobStatusMetadataKey: "aws_rekognition_status",
    jobIdMetadataKey: "rekognition_job_id",
    jobStartedMetadataKey: "rekognition_job_started",
    jobTitle: "Enrich",
  },
];

• jobType - Currently only Enrich is supported.
• jobStatusMetadataKey - Metadata field for the status of the job.
• jobIdMetadataKey - Metadata field for the id of the job. Can be used to get more information about the job.
• jobStartedMetadataKey - Metadata field for the start time of the job.
• jobTitle - Name of the job to show in the UI.

Enrich

The enrich feature allows the user to add content to an asset using e.g. Amazon Rekognition. Note that feature settings.features.enrich is disabled by default.

enrich: {
  configuration: [
    {
      type: "technical_cue",
      key: "technical_cue_confidence",
      label: "Technical cue detection",
      rekognitionType: "rekognition_type",
      description: "Detect black frames, end credits and color bars",
      defaultEnabled: false,
      defaultValue: "70",
      unit: "confidence"
    },
    {
      type: "shot",
      key: "shot_confidence",
      label: "Shot detection",
      rekognitionType: "rekognition_type",
      description: "Detect individual shots",
      defaultEnabled: false,
      defaultValue: "70",
      unit: "confidence"
    },
    {
      type: "content_moderation",
      key: "content_moderation_confidence",
      rekognitionType: "rekognition_type",
      label: "Unsafe content detection",
      description: "Detect unsafe content like nudity, violence and drugs",
      defaultEnabled: false,
      defaultValue: "70",
      unit: "confidence",
    },
    {
      type: "label_detection",
      key: "label_detection_confidence",
      rekognitionType: "rekognition_type",
      label: "Object detection",
      description: "Detect objects in video",
      defaultEnabled: false,
      defaultValue: "70",
      unit: "confidence",
    },
    {
      type: "celebrity_detection",
      key: "celebrity_detection_confidence",
      rekognitionType: "rekognition_type",
      label: "Celebrity detection",
      description: "Finds Celebrities in video",
      defaultEnabled: true,
      defaultValue: "70",
      unit: "confidence",
    },
    {
      type: "face_detection",
      key: "face_detection_confidence",
      rekognitionType: "rekognition_type",
      label: "Face detection",
      description: "Detect faces in video",
      defaultEnabled: false,
      defaultValue: "70",
      unit: "confidence",
    },
    {
      type: "text_detection",
      key: "text_detection_confidence",
      rekognitionType: "rekognition_type",
      label: "Text detection",
      description: "Detect text in video",
      defaultEnabled: false,
      defaultValue: "70",
      unit: "confidence",
    },
  ]
},

• configurations - List of enrich configurations.
• configurations - type - Enrich type mapping a specific job.
• configurations - key - Metadata key for accessing job result.
• configurations - rekognitionType - Type of rekognition: rekognition_label
• configurations - label - Label for the configuration.
• configurations - description - Description fo the configuration.
• configurations - defaultEnabled - If true, the setting is preselected when opening enrich modal.
• configurations - defaultValue - The default confidence level to select.
• configurations - options - Optional. List of {label, value} objects to populate dropdown.
• configurations - unit - Unit for the values.

Forms

The forms setting is used to define custom forms that can be used for marker-, asset- or file metadata:

Here is an example of defining a form with the id myForm:

{
  "forms": {
    "myForm": {
      "schema": {
        "type": "object",
        "properties": {
          "title": {
            "type": "string"
          },
          "description": {
            "type": "string"
          },
          "genre": {
            "type": "string",
            "enum": ["Action", "Drama", "Horror", "Comedy", "Thriller", "Western"]
          }
        },
        "required": ["name"]
      },
      "uischema": {
        "type": "VerticalLayout",
        "elements": [
          {
            "type": "Control",
            "label": "Title",
            "scope": "#/properties/title"
          },
          {
            "type": "Control",
            "label": "Description",
            "scope": "#/properties/description",
            "options": {
              "format": "textarea"
            }
          },
          {
            "type": "Control",
            "label": "Genre",
            "scope": "#/properties/genre"
          }
        ]
      },
      "defaultValues": {
        "title": "Default title"
      }
    }
  }
}

• schema - Schema for the form, see json-schema.
• uischema - UI Schema for the form, see ui-schema.
• defaultValues - Any default values the form should be initialized with.

This document covers the currently supported UI Schema formats and explains how to configure them. Please note that this is a guide for how to create forms using our internal component library but the examples are still valid and correct.

Note: If you are using Vidispine, don't forget to update your metadata schema that you use for your items so they include the form field keys in your form.

Form references

A schema can reference another schema using the $ref keyword. The value of $ref is a URI-reference that is resolved when the form is loaded for the first time. Here are some examples:

• A complete form at a remote location (URL):

json { "forms": { "myForm": { "$ref": "https://example.com/my-remote-form.json" } } }

• A sub-schema at a remote location:

json { "forms": { "myForm": { "schema": { "type": "object", "properties": { "title": { "type": "string" }, "description": { "type": "string" }, "genre": { "$ref": "https://example.com/genre-field.json" } } } } } }

With the contents of genre-field.json being:

json { "type": "string", "enum": ["Action", "Drama", "Horror", "Comedy", "Thriller", "Western"] }

• References within the same schema:

json { "forms": { "myForm": { "schema": { "type": "object", "properties": { "genre": { "type": "string", "enum": ["Action", "Drama", "Horror", "Comedy", "Thriller", "Western"] }, "subGenre": { "$ref": "#/schema/properties/genre" } } } } } }

• AV specific references:

You can reference the available languages (see languages.json) in AV by using a special reference av://languages:

json { "forms": { "myForm": { "schema": { "type": "object", "properties": { "language": { "$ref": "av://languages" } } } } } }

Marker forms

These are the default forms used for markers:

You can override the default forms by defining forms with the same keys.

In order to use a different form than the default, you can specify the form to use by using the form key in the marker row settings, see Markers.

Note: When row.names (see Markers) is defined, enum field in schema.properties will be automatically filled with the names defined for any field with key name, for example:

forms: {
  defaultMarker: {
    schema: {
      type: "object",
      properties: {
        name: {
          type: "string",
          description: "This field will get the enum property from row.names",
        }
      }
    },
    uischema: {
      type: "VerticalLayout",
      elements: [
        {
          type: "Control",
          scope: "#/properties/name",
        }
      ]
    }
  }
}

Asset- and file metadata forms (metadata tab forms)

These are the default forms used by in the metadata tab:

You can override these or specify new forms under different keys and use those by setting the form key in the Metadata View settings

Metadata fields

These settings are used to configure which metadata fields that exist on an asset, file, media container and its video- and audio streams. Metadata fields can be used to configure a metadata view that is shown in the tab Metadata in Validate.

metadataFields: [
  {
    id: "title",
    key: "title",
    label: "Title",
    source: "metadata",
  },
  {
    id: "duration",
    key: "duration",
    label: "Duration",
    source: "property",
    displayType: "smpte",
    storedType: "timebase",
  },
  {
    id: "sampleRate",
    key: "sampleRate",
    label: "Sample Rate",
    source: "property",
  },
  {
    id: "channels",
    key: "channels",
    label: "Channels",
    source: "property",
    expectedMetadata: [
      {
        id: "expectedChannels",
        key: "expected-channels",
        source: "assetMetadata",
        comparison: {
          key: "expected-channels-result",
        },
      },
    ],
  },
  {
    id: "#asset/properties/deliveryDate",
    key: "deliveryDate",
    source: "metadata",
    displayType: "date",
    storedType: "utcDate",
  },
];

• id - Unique id for this metadata field. Required to reference this field from a metadata-view.
• key - Metadata key holding the value.
• label - Label that will be shown for this metadata-field when used in metadata-view.
• description - (Optional) Text describing the metadata field.
• source - (Optional) Source limiting where to look for metadata key. Alternatives are metadata or properties. Technical metadata like codec or bitrate of a media file are usually properties and metadata is used for user defined metadata. Default is metadata.
• displayType - (Optional) Decides in which format the metadata value should be presented in the UI. Alternatives are smpte, date, time, date-time or a callback function that formats the value ((value: string | number | boolean) => string). If not specified the metadata value will be displayed as it is with no conversion of any kind.
• storedType - (Optional) Which data type the value is stored in. Alternatives are timebase and utcDate.
• expectedMetadata - (Optional) see ExpectedMetadata
• expectedMetadata.comparison - (Optional) see ExpectedMetadataComparison

Auto-generated fields

Fields for metadata defined in forms (see for example fieldSet.asset.form in Metadata Views) are automatically generated from the properties defined in the form. The auto-generated definitions can be overridden by defining a field with the same id as the auto-generated one. The id follows the pattern: #{fieldSet}/properties/${propertyName}.

For example, if we have a form id defined in fieldSet.asset.form that points to a form with this schema:

{
  "schema": {
    "type": "object",
    "properties": {
      "deliveryDate": {
        "type": "string",
        "format": "date-time"
      }
    }
  }
}

We would get an auto-generated metadata field definition with the id #asset/properties/deliveryDate. To override the displayType and storedType, for example, we would need to add this field definition:

{
  "id": "#asset/properties/deliveryDate",
  "key": "deliveryDate",
  "source": "metadata",
  "displayType": "date",
  "storedType": "utcDate"
}

Expected metadata

Expected metadata is an additional field describing the actual value that is expected for this metadata field. It also includes a comparison property that contains information about the comparison between the metadata field and the expected metadata.

expectedMetadata: [
  {
    id: "expectedChannels",
    key: "expected-channels",
    source: "assetMetadata",
    comparison: {
      key: "expected-channels-result",
      source: "assetMetadata",
    },
  },
];

• id - Unique id for this metadata field. Required to be able to reference this field from a metadata-view.
• key - Metadata key holding the value.
• source -(Optional, default source of the metadata field). Source limiting where to look for metadata key. Alternatives are metadata, properties, assetMetadata, assetProperties, relativeAssetMetadata or relativeAssetProperties.
• comparison - see ExpectedMetadataComparison

Expected metadata comparison

Comparison property contains information about the comparison between the metadata field and expectedMetadata property. The pre-computed result from the comparison can be found using the key value. The value must be interpretable as a boolean, for example "yes", true, 1, "FALSE", null.

comparison: {
  key: "expected-channels-result",
  source: "assetMetadata"
};

• key - Metadata key holding the value.
• source - (Optional, default expectedMetadata.source or the source of the metadata field). Source limiting where to look for metadata key. Alternatives are metadata, properties, assetMetadata, assetProperties, relativeAssetMetadata or relativeAssetProperties.

Metadata views

This setting is used to configure the metadata views that can be shown in the metadata tab.

metadataViews: [
  {
    id: "defaultMetadataView",
    name: "Default",
    description: "The default metadata view",
    fieldSets: {
      asset: {
        form: "assetMetadataForm",
        formFields: [
          {
            metadataFieldId: "#asset/properties/title",
            expectedMetadataFieldId: "assetMetadataTitleExpected",
            order: 20,
          },
        ],
        readOnlyFields: [
          {
            metadataFieldId: "created",
          },
        ],
      },
      videoFile: {
        form: "videoFileForm",
        readOnlyFields: [
          {
            metadataFieldId: "created",
          },
        ],
      },
      audioFile: {
        form: "audioFileForm",
        readOnlyFields: [
          {
            metadataFieldId: "created",
          },
        ],
      },
      subtitleFile: {
        form: "subtitleFileForm",
        readOnlyFields: [
          {
            metadataFieldId: "language",
          },
        ],
      },
      container: {
        readOnlyFields: [
          {
            metadataFieldId: "format",
          },
        ],
      },
      videoStream: {
        readOnlyFields: [
          {
            metadataFieldId: "codec",
          },
        ],
      },
      audioStream: {
        readOnlyFields: [
          {
            metadataFieldId: "channels",
            expectedMetadataFieldId: "expectedChannels",
          },
        ],
      },
    },
  },
];

• id - Unique id for this metadata view.
• name - Name of the metadata view.
• active - Boolean. Marks the view as active, the first active view found will be used. At least one view needs to be active.
• description - (Optional) Text describing the metadata view.
• fieldSets - Fields and form configurations for the different categories in the metadata tab.
• fieldSets.asset.form - Form to use for asset metadata. Id of a form, see Forms.
• fieldSets.asset.formFields - Configuration for fields generated from the form. List of MetadataViewFields. see MetadataViewField. Id of the field to configure have to be the generated id, see Auto-generated fields
• fieldSets.asset.readOnlyFields - Read only fields for assets. List of MetadataViewFields. see MetadataViewField.
• fieldSets.videoFile.form - Form to use for video file metadata. Id of a form, see Forms.
• fieldSets.videoFile.formFields - Configuration for fields generated from the form. List of MetadataViewFields. see MetadataViewField. Id of the field to configure have to be the generated id, see Auto-generated fields
• fieldSets.videoFile.readOnlyFields - Read only fields for video files List of MetadataViewFields. see MetadataViewField.
• fieldSets.audioFile.form - Form to use for audio file metadata. Id of a form, see Forms.
• fieldSets.audioFile.formFields - Configuration for fields generated from the form. List of MetadataViewFields. see MetadataViewField. Id of the field to configure have to be the generated id, see Auto-generated fields
• fieldSets.audioFile.readOnlyFields - Read only fields for audio files List of MetadataViewFields. see MetadataViewField.
• fieldSets.subtitleFile.form - Form to use for subtitle file metadata. Id of a form, see Forms.
• fieldSets.subtitleFile.formFields - Configuration for fields generated from the form. List of MetadataViewFields. see MetadataViewField. Id of the field to configure have to be the generated id, see Auto-generated fields
• fieldSets.subtitleFile.readOnlyFields - Read only fields for subtitle files List of MetadataViewFields. see MetadataViewField.
• fieldSets.container.readOnlyFields - Read only fields for a file container (video and audio files have containers). These fields are shown in the same location as the file read only fields in the UI. List of MetadataViewFields. see MetadataViewField.
• fieldSets.videoStream.readOnlyFields - Read only fields for a media files video streams. List of MetadataViewFields. see MetadataViewField.

• fieldSets.audioStream.readOnlyFields - Read only fields for a media files video streams. List of MetadataViewFields. see MetadataViewField.

• fields - Deprecated. Fields defined under this key will be converted to the new fieldSets setting instead. List of MetadataViewFields. see MetadataViewField

Metadata view field

Describes which metadata-fields that should be included in the metadataView. It will include a reference to an existing metadataFieldId, an optional expectedMetadataFieldId in that particular metadataField and an option to override label for the metadataField.

• metadataFieldId - Reference to a metadata field to use as base.
• label - (Optional) Can override label in referenced metadata field.
• order - (Optional) Decides the display order of the fields.
• expectedMetadataFieldId - (Optional). Which expectedMetadata id that should be used from the referenced metadata-field.

Drm - DASH/HLS Specific

Settings for configuring DRM. Only available when streaming using HLS & Dash. Streaming dash and HLS content is powered by shaka-player and with it comes capabilities to support DRM.

 drm: {
   servers: {
     "com.widevine.alpha": "https://wv-keyos.licensekeyserver.com/"
   },
   streamingInterceptor: (data) => {
     return (type, request) => {
       if (type === 2) {
         request.headers.customdata = data;
       }
     }
   },
   fileSecretKey: "custom_data_xml"
 }

• drm.servers - list of licensing servers and drm system (for additional information see shaka-players documentation).
• drm.streamingInterceptor - Optional callback. Should return interceptor for shaka-players network engine which allows additional authentication capabilities (consult Accurate Player for definitions of the interceptor)
• drm.fileSecretKey: Optional key for metadata field on VideoFileDto, corresponding value will be used as the optional "data" parameter to the streamingInterceptor callback.

JIT (Just-In-Time)

JIT playback requires a separate JIT backend to be available.

  jit: {
    iceServers: [
      {
        urls: "stun.l.google.com:19302"
      }
    ],
    backendUrl: "https://example.com",
    enabled: "determinedByFile"
  }

• jit.iceServers - An array of objects, each describing one server which may be used by the ICE agent; these are typically STUN and/or TURN servers. See RTCIceServers
• jit.backendUrl - Url to the JIT backend
• jit.enabled - Controls if and when JIT should be used. Available alternatives are always, never and determinedByFile

Enable for specific files

With jit.enabled set to determinedByFile it is possible to let the file determine if it should be loaded through JIT or with a regular player. JIT will be used if the file contains the metadata entry:

{
  "key": "jit",
  "value": "true"
}

languages.json

Defines the languages used. These languages are used in language pickers for audio tracks, subtitles etc.

You can also provide languages in the settings.js file under the languages key. Languages provided in the settings file takes precedence over languages provided in the languages.json file.

[
  {
    "code": "en",
    "label": "English"
  },

  {
    "code": "cz",
    "label": "Czech"
  },
  ...
]