use crate::{ClipId, DataSetId, MediaFingerprint, NodeId};
use alpha2_media::SourceId;
use alpha2_time::MediaTime;
use serde::{Deserialize, Serialize};
use std::fmt;
pub const MAX_DATA_SETS: usize = 256;
pub const MAX_DATA_CHANNELS: usize = 64;
pub const MAX_DATA_VALUES: usize = 4_000_000;
pub const MAX_DATA_WORDS: usize = 200_000;
pub const MAX_DATA_INTERVALS: usize = 200_000;
pub const MAX_DATA_LABEL_BYTES: usize = 256;
pub const MAX_DATA_ID_BYTES: usize = 64;
pub const MAX_DATA_COORDINATE: f32 = 16.0;
pub const MAX_DATA_SCALAR: f32 = 1e9;
pub const MAX_DATA_ROTATION_DEGREES: f32 = 36_000.0;
pub const MAX_DATA_SCALE: f32 = 1_000.0;
pub const MAX_FOLLOW_DEPTH: usize = 8;
#[derive(Clone, Debug, Eq, PartialEq, Hash, Serialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum DataAnchor {
Source {
source_id: SourceId,
},
Timeline,
}
impl DataAnchor {
#[must_use]
pub const fn source(&self) -> Option<&SourceId> {
match self {
Self::Source { source_id } => Some(source_id),
Self::Timeline => None,
}
}
}
#[derive(Deserialize)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[cfg_attr(feature = "schema", schemars(rename = "DataAnchor"))]
#[serde(tag = "type", rename_all = "snake_case", deny_unknown_fields)]
enum DataAnchorWire {
Source {
source_id: SourceId,
},
Timeline {},
}
impl<'de> Deserialize<'de> for DataAnchor {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
Ok(match DataAnchorWire::deserialize(deserializer)? {
DataAnchorWire::Source { source_id } => Self::Source { source_id },
DataAnchorWire::Timeline {} => Self::Timeline,
})
}
}
#[cfg(feature = "schema")]
impl schemars::JsonSchema for DataAnchor {
fn schema_name() -> std::borrow::Cow<'static, str> {
DataAnchorWire::schema_name()
}
fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
DataAnchorWire::json_schema(generator)
}
}
#[derive(Copy, Clone, Debug, Default, Deserialize, Eq, PartialEq, Hash, Serialize)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[serde(rename_all = "snake_case")]
pub enum DataInterpolation {
#[default]
Hold,
Linear,
}
#[derive(Copy, Clone, Debug, Deserialize, Eq, PartialEq, Hash, Serialize)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[serde(rename_all = "snake_case")]
pub enum DataKind {
Points,
Scalars,
Similarity,
Words,
Intervals,
}
impl DataKind {
#[must_use]
pub const fn arity(self) -> Option<usize> {
match self {
Self::Points => Some(2),
Self::Scalars => Some(1),
Self::Similarity => Some(SIMILARITY_ARITY),
Self::Words | Self::Intervals => None,
}
}
#[must_use]
pub const fn name(self) -> &'static str {
match self {
Self::Points => "points",
Self::Scalars => "scalars",
Self::Similarity => "similarity",
Self::Words => "words",
Self::Intervals => "intervals",
}
}
}
impl fmt::Display for DataKind {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.name())
}
}
pub const SIMILARITY_ARITY: usize = 4;
#[derive(Clone, Debug, Default, PartialEq)]
pub struct DataSamples {
pub interpolation: DataInterpolation,
pub channels: Vec<String>,
pub times: Vec<MediaTime>,
pub values: Vec<Option<f32>>,
}
impl DataSamples {
#[must_use]
pub fn channel(&self, channel: &str) -> Option<usize> {
self.channels.iter().position(|name| name == channel)
}
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[serde(deny_unknown_fields)]
pub struct DataWord {
pub start: MediaTime,
pub end: MediaTime,
pub text: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub speaker: Option<String>,
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[serde(deny_unknown_fields)]
pub struct DataInterval {
pub start: MediaTime,
pub end: MediaTime,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub label: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub score: Option<f32>,
}
#[derive(Clone, Debug, PartialEq)]
pub enum DataValues {
Points(DataSamples),
Scalars(DataSamples),
Similarity(DataSamples),
Words(Vec<DataWord>),
Intervals(Vec<DataInterval>),
}
impl DataValues {
#[must_use]
pub const fn kind(&self) -> DataKind {
match self {
Self::Points(_) => DataKind::Points,
Self::Scalars(_) => DataKind::Scalars,
Self::Similarity(_) => DataKind::Similarity,
Self::Words(_) => DataKind::Words,
Self::Intervals(_) => DataKind::Intervals,
}
}
#[must_use]
pub const fn samples(&self) -> Option<&DataSamples> {
match self {
Self::Points(samples) | Self::Scalars(samples) | Self::Similarity(samples) => {
Some(samples)
}
Self::Words(_) | Self::Intervals(_) => None,
}
}
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[serde(deny_unknown_fields)]
pub struct MadeBy {
pub extractor: String,
pub version: u32,
#[serde(default)]
pub params: serde_json::Map<String, serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub plugin: Option<MadeByPlugin>,
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[serde(deny_unknown_fields)]
pub struct MadeByPlugin {
pub version: String,
pub artifact_sha256: String,
}
#[derive(Clone, Debug, PartialEq)]
pub struct DataSet {
pub id: DataSetId,
pub anchor: DataAnchor,
pub values: DataValues,
pub made_by: Option<MadeBy>,
pub made_from: Option<MediaFingerprint>,
}
impl DataSet {
#[must_use]
pub fn last_time(&self) -> Option<MediaTime> {
match &self.values {
DataValues::Points(samples)
| DataValues::Scalars(samples)
| DataValues::Similarity(samples) => samples.times.last().copied(),
DataValues::Words(words) => words.iter().map(|word| word.end).max(),
DataValues::Intervals(intervals) => intervals.iter().map(|interval| interval.end).max(),
}
}
#[must_use]
pub const fn kind(&self) -> DataKind {
self.values.kind()
}
}
#[cfg(feature = "schema")]
#[allow(dead_code)]
#[derive(schemars::JsonSchema)]
#[schemars(rename = "DataSet")]
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
enum DataSetSchema {
Points {
id: DataSetId,
anchor: DataAnchor,
interpolation: DataInterpolation,
#[cfg_attr(feature = "schema", schemars(length(max = crate::MAX_DATA_CHANNELS)))]
channels: Vec<String>,
#[cfg_attr(feature = "schema", schemars(length(max = crate::MAX_DATA_VALUES)))]
times: Vec<MediaTime>,
#[cfg_attr(feature = "schema", schemars(length(max = crate::MAX_DATA_VALUES)))]
values: Vec<Option<f32>>,
#[serde(default)]
made_by: Option<MadeBy>,
#[serde(default)]
made_from: Option<MediaFingerprint>,
},
Scalars {
id: DataSetId,
anchor: DataAnchor,
interpolation: DataInterpolation,
#[cfg_attr(feature = "schema", schemars(length(max = crate::MAX_DATA_CHANNELS)))]
channels: Vec<String>,
#[cfg_attr(feature = "schema", schemars(length(max = crate::MAX_DATA_VALUES)))]
times: Vec<MediaTime>,
#[cfg_attr(feature = "schema", schemars(length(max = crate::MAX_DATA_VALUES)))]
values: Vec<Option<f32>>,
#[serde(default)]
made_by: Option<MadeBy>,
#[serde(default)]
made_from: Option<MediaFingerprint>,
},
Similarity {
id: DataSetId,
anchor: DataAnchor,
interpolation: DataInterpolation,
#[cfg_attr(feature = "schema", schemars(length(max = crate::MAX_DATA_VALUES)))]
times: Vec<MediaTime>,
#[cfg_attr(feature = "schema", schemars(length(max = crate::MAX_DATA_VALUES)))]
values: Vec<Option<f32>>,
#[serde(default)]
made_by: Option<MadeBy>,
#[serde(default)]
made_from: Option<MediaFingerprint>,
},
Words {
id: DataSetId,
anchor: DataAnchor,
#[cfg_attr(feature = "schema", schemars(length(max = crate::MAX_DATA_WORDS)))]
words: Vec<DataWord>,
#[serde(default)]
made_by: Option<MadeBy>,
#[serde(default)]
made_from: Option<MediaFingerprint>,
},
Intervals {
id: DataSetId,
anchor: DataAnchor,
#[cfg_attr(feature = "schema", schemars(length(max = crate::MAX_DATA_INTERVALS)))]
intervals: Vec<DataInterval>,
#[serde(default)]
made_by: Option<MadeBy>,
#[serde(default)]
made_from: Option<MediaFingerprint>,
},
}
#[cfg(feature = "schema")]
impl schemars::JsonSchema for DataSet {
fn schema_name() -> std::borrow::Cow<'static, str> {
DataSetSchema::schema_name()
}
fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
DataSetSchema::json_schema(generator)
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct DataSetFlat {
id: DataSetId,
anchor: DataAnchor,
kind: DataKind,
#[serde(default)]
interpolation: Option<DataInterpolation>,
#[serde(default)]
#[serde(deserialize_with = "crate::bounded::option_seq::<_, _, { crate::MAX_DATA_CHANNELS }>")]
channels: Option<Vec<String>>,
#[serde(default)]
#[serde(deserialize_with = "crate::bounded::option_seq::<_, _, { crate::MAX_DATA_VALUES }>")]
times: Option<Vec<MediaTime>>,
#[serde(default)]
#[serde(deserialize_with = "crate::bounded::option_seq::<_, _, { crate::MAX_DATA_VALUES }>")]
values: Option<Vec<Option<f32>>>,
#[serde(default)]
#[serde(deserialize_with = "crate::bounded::option_seq::<_, _, { crate::MAX_DATA_WORDS }>")]
words: Option<Vec<DataWord>>,
#[serde(default)]
#[serde(
deserialize_with = "crate::bounded::option_seq::<_, _, { crate::MAX_DATA_INTERVALS }>"
)]
intervals: Option<Vec<DataInterval>>,
#[serde(default)]
made_by: Option<MadeBy>,
#[serde(default)]
made_from: Option<MediaFingerprint>,
}
impl TryFrom<DataSetFlat> for DataSet {
type Error = String;
fn try_from(flat: DataSetFlat) -> Result<Self, Self::Error> {
let kind = flat.kind;
let stray = |field: &str| format!("a {kind} data set has no field `{field}`");
let missing = |field: &str| format!("a {kind} data set needs `{field}`");
let values = match kind {
DataKind::Points | DataKind::Scalars | DataKind::Similarity => {
if flat.words.is_some() {
return Err(stray("words"));
}
if flat.intervals.is_some() {
return Err(stray("intervals"));
}
let channels = if kind == DataKind::Similarity {
if flat.channels.is_some() {
return Err(stray("channels"));
}
Vec::new()
} else {
flat.channels.ok_or_else(|| missing("channels"))?
};
let samples = DataSamples {
interpolation: flat.interpolation.ok_or_else(|| missing("interpolation"))?,
channels,
times: flat.times.ok_or_else(|| missing("times"))?,
values: flat.values.ok_or_else(|| missing("values"))?,
};
match kind {
DataKind::Points => DataValues::Points(samples),
DataKind::Scalars => DataValues::Scalars(samples),
_ => DataValues::Similarity(samples),
}
}
DataKind::Words | DataKind::Intervals => {
for (field, present) in [
("interpolation", flat.interpolation.is_some()),
("channels", flat.channels.is_some()),
("times", flat.times.is_some()),
("values", flat.values.is_some()),
] {
if present {
return Err(stray(field));
}
}
if kind == DataKind::Words {
if flat.intervals.is_some() {
return Err(stray("intervals"));
}
DataValues::Words(flat.words.ok_or_else(|| missing("words"))?)
} else {
if flat.words.is_some() {
return Err(stray("words"));
}
DataValues::Intervals(flat.intervals.ok_or_else(|| missing("intervals"))?)
}
}
};
Ok(Self {
id: flat.id,
anchor: flat.anchor,
values,
made_by: flat.made_by,
made_from: flat.made_from,
})
}
}
impl<'de> Deserialize<'de> for DataSet {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let flat = DataSetFlat::deserialize(deserializer)?;
Self::try_from(flat).map_err(serde::de::Error::custom)
}
}
#[derive(Serialize)]
struct DataSetRef<'a> {
id: &'a DataSetId,
anchor: &'a DataAnchor,
kind: DataKind,
#[serde(skip_serializing_if = "Option::is_none")]
interpolation: Option<DataInterpolation>,
#[serde(skip_serializing_if = "Option::is_none")]
channels: Option<&'a [String]>,
#[serde(skip_serializing_if = "Option::is_none")]
times: Option<&'a [MediaTime]>,
#[serde(skip_serializing_if = "Option::is_none")]
values: Option<&'a [Option<f32>]>,
#[serde(skip_serializing_if = "Option::is_none")]
words: Option<&'a [DataWord]>,
#[serde(skip_serializing_if = "Option::is_none")]
intervals: Option<&'a [DataInterval]>,
#[serde(skip_serializing_if = "Option::is_none")]
made_by: Option<&'a MadeBy>,
#[serde(skip_serializing_if = "Option::is_none")]
made_from: Option<&'a MediaFingerprint>,
}
impl Serialize for DataSet {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut wire = DataSetRef {
id: &self.id,
anchor: &self.anchor,
kind: self.kind(),
interpolation: None,
channels: None,
times: None,
values: None,
words: None,
intervals: None,
made_by: self.made_by.as_ref(),
made_from: self.made_from.as_ref(),
};
match &self.values {
DataValues::Points(samples)
| DataValues::Scalars(samples)
| DataValues::Similarity(samples) => {
wire.interpolation = Some(samples.interpolation);
if self.kind() != DataKind::Similarity {
wire.channels = Some(&samples.channels);
}
wire.times = Some(&samples.times);
wire.values = Some(&samples.values);
}
DataValues::Words(words) => wire.words = Some(words),
DataValues::Intervals(intervals) => wire.intervals = Some(intervals),
}
wire.serialize(serializer)
}
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[serde(deny_unknown_fields)]
pub struct DataBinding {
pub data: DataSetId,
pub channel: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub via: Option<DataVia>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub space: Option<DataSpace>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub offset: Option<[f32; 2]>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub remap: Option<DataRemap>,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Hash, Serialize)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[serde(rename_all = "snake_case", deny_unknown_fields)]
pub enum DataVia {
Clip(ClipId),
Node(NodeId),
}
#[derive(Copy, Clone, Debug, Deserialize, Eq, PartialEq, Hash, Serialize)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[serde(rename_all = "snake_case")]
pub enum DataSpace {
Picture,
Canvas,
}
#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Serialize)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[serde(deny_unknown_fields)]
pub struct DataRemap {
pub input: [f32; 2],
pub output: [f32; 2],
}
impl DataRemap {
#[must_use]
pub fn apply(&self, value: f32) -> f32 {
let [in0, in1] = self.input.map(f64::from);
let [out0, out1] = self.output.map(f64::from);
let mapped = out0 + (f64::from(value) - in0) * (out1 - out0) / (in1 - in0);
let (low, high) = if out0 <= out1 {
(out0, out1)
} else {
(out1, out0)
};
#[allow(clippy::cast_possible_truncation)]
let clamped = mapped.clamp(low, high) as f32;
clamped
}
#[allow(clippy::float_cmp)]
fn is_valid(&self) -> bool {
self.input
.iter()
.chain(&self.output)
.all(|value| value.is_finite())
&& self.input[0] != self.input[1]
}
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[serde(deny_unknown_fields)]
pub struct CorrectionRef {
pub data: DataSetId,
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[serde(deny_unknown_fields)]
pub struct CaptionsFromWords {
pub data: DataSetId,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub track: Option<crate::TrackId>,
pub max_chars: u32,
}
#[derive(Clone, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum DataProblem {
IdTooLong,
UnknownSource(SourceId),
SourceWithoutMedia(SourceId),
ChannelCount,
ChannelName,
TooManyValues,
ValueCount,
TimesNotAscending,
NegativeTime,
InvalidValue {
index: usize,
},
TooManyItems,
InvalidItem {
index: usize,
},
InvalidMadeBy,
InvalidMadeFrom(&'static str),
}
impl fmt::Display for DataProblem {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::IdTooLong => write!(formatter, "has an id over {MAX_DATA_ID_BYTES} bytes"),
Self::UnknownSource(source) => {
write!(formatter, "is anchored to unknown source {source}")
}
Self::SourceWithoutMedia(source) => {
write!(
formatter,
"is anchored to source {source}, which has no media"
)
}
Self::ChannelCount => {
write!(formatter, "needs 1 to {MAX_DATA_CHANNELS} channels")
}
Self::ChannelName => {
formatter.write_str("has an empty, overlong or repeated channel name")
}
Self::TooManyValues => write!(formatter, "has more than {MAX_DATA_VALUES} values"),
Self::ValueCount => {
formatter.write_str("does not have times * channels * arity values")
}
Self::TimesNotAscending => {
formatter.write_str("has times that are not strictly ascending")
}
Self::NegativeTime => formatter.write_str("has a negative time"),
Self::InvalidValue { index } => {
write!(formatter, "has an invalid value at values[{index}]")
}
Self::TooManyItems => write!(
formatter,
"has more than {MAX_DATA_WORDS} words or {MAX_DATA_INTERVALS} intervals"
),
Self::InvalidItem { index } => write!(formatter, "has an invalid item at [{index}]"),
Self::InvalidMadeBy => formatter.write_str("has an invalid made_by"),
Self::InvalidMadeFrom(part) => write!(formatter, "has an invalid made_from.{part}"),
}
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum BindingProblem {
UnknownData,
WrongKind(DataKind),
TypeRefusesData,
ClockRefusesAnchor,
UnknownChannel,
ViaRequired,
ViaForbidden,
ViaWrongReader,
UnknownViaClip,
InvalidViaNode,
ViaShowsOtherSource,
SpaceRequired,
FieldNotApplicable(&'static str),
InvalidRemap,
Cycle,
TooDeep,
NotOwnSource,
InvalidCaptionTrack,
}
impl fmt::Display for BindingProblem {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::UnknownData => formatter.write_str("names an unknown data set"),
Self::WrongKind(kind) => write!(formatter, "cannot follow {kind} data"),
Self::TypeRefusesData => formatter.write_str("is a value whose type takes no data"),
Self::ClockRefusesAnchor => {
formatter.write_str("is keyed on a clock that refuses this anchor")
}
Self::UnknownChannel => formatter.write_str("names an unknown channel"),
Self::ViaRequired => formatter.write_str("needs `via` for a source-anchored data set"),
Self::ViaForbidden => {
formatter.write_str("takes no `via` for a timeline-anchored data set")
}
Self::ViaWrongReader => {
formatter.write_str("names a reader of the wrong kind for its clock")
}
Self::UnknownViaClip => formatter.write_str("reads through an unknown clip"),
Self::InvalidViaNode => formatter
.write_str("reads through a node that is not a media node of its composition"),
Self::ViaShowsOtherSource => {
formatter.write_str("reads through a reader of another source")
}
Self::SpaceRequired => {
formatter.write_str("needs `space` for a point read through `via`")
}
Self::FieldNotApplicable(field) => {
write!(formatter, "has `{field}` where it does not apply")
}
Self::InvalidRemap => formatter
.write_str("has a non-finite offset or remap, or a remap with equal inputs"),
Self::Cycle => formatter.write_str("follows clips in canvas space in a cycle"),
Self::TooDeep => write!(
formatter,
"follows clips in canvas space more than {MAX_FOLLOW_DEPTH} deep"
),
Self::NotOwnSource => {
formatter.write_str("corrects with data anchored to another source")
}
Self::InvalidCaptionTrack => {
formatter.write_str("has an invalid words track or max_chars")
}
}
}
}
pub(crate) fn valid_label(text: &str) -> bool {
text.len() <= MAX_DATA_LABEL_BYTES
}
fn valid_sha256(hash: &str) -> bool {
hash.len() == 64
&& hash
.bytes()
.all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
}
#[must_use]
pub fn value_in_bounds(kind: DataKind, component: usize, value: f32) -> bool {
value.is_finite()
&& match kind {
DataKind::Points => value.abs() <= MAX_DATA_COORDINATE,
DataKind::Similarity => match component {
0 | 1 => value.abs() <= MAX_DATA_COORDINATE,
2 => value.abs() <= MAX_DATA_ROTATION_DEGREES,
_ => value > 0.0 && value <= MAX_DATA_SCALE,
},
DataKind::Scalars | DataKind::Words | DataKind::Intervals => {
value.abs() <= MAX_DATA_SCALAR
}
}
}
#[must_use]
pub fn valid_word(word: &DataWord) -> bool {
word.start.ticks() >= 0
&& word.start < word.end
&& !word.text.is_empty()
&& valid_label(&word.text)
&& word.speaker.as_deref().is_none_or(valid_label)
}
#[must_use]
pub fn valid_interval(interval: &DataInterval) -> bool {
interval.start.ticks() >= 0
&& interval.start <= interval.end
&& interval.label.as_deref().is_none_or(valid_label)
&& interval
.score
.is_none_or(|score| value_in_bounds(DataKind::Scalars, 0, score))
}
impl DataSet {
pub fn validate(&self) -> Result<(), DataProblem> {
if self.id.as_str().len() > MAX_DATA_ID_BYTES {
return Err(DataProblem::IdTooLong);
}
if let Some(made_by) = &self.made_by {
let plugin_ok = made_by.plugin.as_ref().is_none_or(|plugin| {
!plugin.version.is_empty() && valid_sha256(&plugin.artifact_sha256)
});
if made_by.extractor.is_empty() || !plugin_ok {
return Err(DataProblem::InvalidMadeBy);
}
}
if let Some(made_from) = &self.made_from {
if self.anchor == DataAnchor::Timeline {
return Err(DataProblem::InvalidMadeFrom("anchor"));
}
if let Some(part) = made_from.malformed_part() {
return Err(DataProblem::InvalidMadeFrom(part));
}
}
let time_ok = |time: MediaTime| -> Result<(), DataProblem> {
if time.ticks() < 0 {
return Err(DataProblem::NegativeTime);
}
Ok(())
};
let kind = self.kind();
match &self.values {
DataValues::Points(samples)
| DataValues::Scalars(samples)
| DataValues::Similarity(samples) => {
check_samples(kind, samples, &time_ok)?;
}
DataValues::Words(words) => {
if words.len() > MAX_DATA_WORDS {
return Err(DataProblem::TooManyItems);
}
for (index, word) in words.iter().enumerate() {
let ordered = index == 0 || {
let before = &words[index - 1];
(before.start, before.end) <= (word.start, word.end)
};
if !valid_word(word) || !ordered {
return Err(DataProblem::InvalidItem { index });
}
time_ok(word.start)?;
time_ok(word.end)?;
}
}
DataValues::Intervals(intervals) => {
if intervals.len() > MAX_DATA_INTERVALS {
return Err(DataProblem::TooManyItems);
}
for (index, interval) in intervals.iter().enumerate() {
let ordered = index == 0 || {
let before = &intervals[index - 1];
(before.start, before.end) <= (interval.start, interval.end)
};
if !valid_interval(interval) || !ordered {
return Err(DataProblem::InvalidItem { index });
}
time_ok(interval.start)?;
time_ok(interval.end)?;
}
}
}
Ok(())
}
}
fn check_samples(
kind: DataKind,
samples: &DataSamples,
time_ok: &dyn Fn(MediaTime) -> Result<(), DataProblem>,
) -> Result<(), DataProblem> {
let arity = kind.arity().unwrap_or(1);
let channels = if kind == DataKind::Similarity {
1
} else {
if samples.channels.is_empty() || samples.channels.len() > MAX_DATA_CHANNELS {
return Err(DataProblem::ChannelCount);
}
for (index, name) in samples.channels.iter().enumerate() {
if name.is_empty() || !valid_label(name) || samples.channels[..index].contains(name) {
return Err(DataProblem::ChannelName);
}
}
samples.channels.len()
};
if samples.values.len() > MAX_DATA_VALUES {
return Err(DataProblem::TooManyValues);
}
let expected = samples
.times
.len()
.checked_mul(channels * arity)
.ok_or(DataProblem::ValueCount)?;
if samples.values.len() != expected {
return Err(DataProblem::ValueCount);
}
for (index, time) in samples.times.iter().enumerate() {
if index > 0 && samples.times[index - 1] >= *time {
return Err(DataProblem::TimesNotAscending);
}
time_ok(*time)?;
}
for (group, values) in samples.values.chunks_exact(arity).enumerate() {
let lost = values[0].is_none();
for (component, value) in values.iter().enumerate() {
let index = group * arity + component;
let ok = match value {
None => lost,
Some(value) => !lost && value_in_bounds(kind, component, *value),
};
if !ok {
return Err(DataProblem::InvalidValue { index });
}
}
}
Ok(())
}
impl DataBinding {
pub(crate) fn fields_valid(&self) -> bool {
self.offset
.is_none_or(|offset| offset.iter().all(|value| value.is_finite()))
&& self.remap.is_none_or(|remap| remap.is_valid())
}
}