Frontend configurations


Whether you want to configure the timeline, markers, tracks, groups, subtitles or something else, Accurate Video got you covered. With Accurate Video you can configure just about everything. Settings are defined in a javascript file which is deployed with the application.

By configuring the settings file you can customize the frontend and edit particular areas to suit your workflow. This guide will go through all configurations available and also include examples to help you get started.


Accurate Video Frontend

This document describes available configuration settings for Accurate Video.

Files available for configuration:

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.
  • 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.poster - see Poster Settings
  • ingest - see Ingest
  • markers - see Markers
  • timeline - see Timeline
  • storages - see Storages
  • drm - see Drm
  • 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
  • videoTagBlackList - List of tags, e.g. ['mp4', 'original']. The urls of any video files that have a matching tag will be removed.
  • audioTagBlackList - List of tags, e.g. ['mp3', 'wav'] The urls of any audio files that have a matching tag will be removed.

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";
    }
  }
}

Validate Settings

Settings for the Validate application:

apps: {
    validate: {
      features: {
        markers: true;
      },
      subtitleTypes: ["imsc", "vtt"],
      fallbackDuration: 3600,
      videoFileDisplay: "%filename (%tag, %id)",
      audioFileDisplay: "%filename (%tag, %id, %channels channels)",
      videoFileOrder: ["tag", "filename", "language"],
      audioFileOrder: ["tag", "filename", "channels"],
      channelNamesMetadataKey: "channelNames",
    }
}
  • features.markers - Default: true. Allow creating and editing markers.
  • subtitleTypes - Default: ["imsc", "vtt", "timespan"]. Which types of subtitles to use, ordered by priority. Alternatives are "imsc", "vtt" and "timespan".
  • fallbackDuration - Default: 3600. The duration to use for assets that are opened that do not have a video or audio file to read the duration from.
  • videoFileDisplay - Default: "%filename (%tag, %id)". Template string to customize how to display video files in the media tab. The template values will be replaced by actual properties of the file. Possible template values: %filename, %id, %tag and %language.
  • audioFileDisplay - Default: "%filename (%tag, %id, %channels channels)". Template string to customize how to display audio files in the media tab. The template values will be replaced by actual properties of the file. Possible template values: %filename, %id, %tag, %language and %channels.
  • 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.
  • audioFileOrder - Default: []. This controls the ordering of audio 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, id and channels.
  • channelNamesMetadataKey - See Channel names metadata

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.

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
exportFormats: string[],
groups: [{
  id: MarkerSettingsDynamicValue<string>,
  trackType: string,
  alwaysHide: MarkerSettingsDynamicValue<boolean>,
  alwaysShow: 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>,
    track: MarkerSettingsDynamicValue<string>,
    alwaysHide: MarkerSettingsDynamicValue<boolean>,
    alwaysShow: 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>,
    names: MarkerSettingsDynamicValue<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
  }]
}]
  • exportFormats - Export formats to enable in the marker exports menu. Defaults to ["CSV", "XML", "JSON"]
  • 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.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.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 event if it contains no markers. Overrides group.alwaysShow
  • 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.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 configured on the row, a label tag is displayed on the row in timeline.
  • row.names - 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.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.
  • 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.

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).

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"),

// 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"]
  }
}

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"),
        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: {
    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,
      }
    }
  }
}
  • waveforms - Describes how waveforms should be retrieved.
  • waveforms.active - String determining which profile to use ("vidispine" or "analyze").
  • waveforms.vidispine - Profile for fetching waveforms from Vidispine adapter.
  • 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.

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",
  method: "keycloak",
  query: {
    tokenParameter: "u",
    tokenPrefix: "AV"
  },
  keycloak: {
    confUrl: "./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.
  • tokenStorageLocation - (Optional, default: av_jwt_token) local storage key to store token.
  • keycloak.confUrl - (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 UserManager Configuration.
  • 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
}
  • 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

Asset status

Settings for asset status feature. Note that feature settings.features.assetStatus is disabled by default.

assetStatus: {
  statusMetadataFieldName: "asset_status",
  commentMetadataFieldName: "asset_status_comment",
  statusSetByMetadataFieldName: "asset_status_set_by_comment",
  statuses: [
    {
      key: "in_progress",
      labels: {
        status: "In progress"
      },
      color: "#9493a0"
    },
    {
      key: "approved",
      labels: {
        status: "Approved",
        assign: "Approve"
      },
      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 - 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 - Optional. Allows the user to comment the status. E.g. explain why the status was rejected.

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.

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.

languages.json

Defines the languages used.

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

  {
    "code": "cz",
    "label": "Czech"
  },
  ...
]
Accurate.Video Docker setup Authentication - Roles and permissions configurations