use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HfProtocol {
pub duration: f64,
#[serde(default = "default_fps")]
pub fps: f64,
#[serde(default = "default_width")]
pub width: u32,
#[serde(default = "default_height")]
pub height: u32,
#[serde(default)]
pub media: Vec<HfMediaElement>,
#[serde(default)]
pub transitions: Vec<HfTransitionMeta>,
}
fn default_fps() -> f64 {
30.0
}
fn default_width() -> u32 {
1920
}
fn default_height() -> u32 {
1080
}
impl Default for HfProtocol {
fn default() -> Self {
Self {
duration: 5.0,
fps: 30.0,
width: 1920,
height: 1080,
media: Vec::new(),
transitions: Vec::new(),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct HfMediaElement {
#[serde(rename = "elementId")]
pub element_id: String,
pub src: String,
#[serde(rename = "startTime")]
pub start_time: f64,
#[serde(rename = "endTime")]
pub end_time: f64,
#[serde(rename = "mediaOffset", default)]
pub media_offset: f64,
#[serde(default = "default_volume")]
pub volume: f64,
#[serde(rename = "hasAudio", default = "default_has_audio")]
pub has_audio: bool,
}
fn default_volume() -> f64 {
1.0
}
fn default_has_audio() -> bool {
true
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct HfTransitionMeta {
pub time: f64,
pub duration: f64,
pub shader: Option<String>,
#[serde(default = "default_ease")]
pub ease: String,
#[serde(rename = "fromScene")]
pub from_scene: String,
#[serde(rename = "toScene")]
pub to_scene: String,
}
fn default_ease() -> String {
"power2.inOut".to_string()
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct HfSeekOptions {
#[serde(rename = "suppressEvents", default)]
pub suppress_events: bool,
#[serde(rename = "subFrameDivisions", default)]
pub sub_frame_divisions: Option<u32>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
pub enum VideoFormat {
#[default]
#[serde(rename = "mp4")]
Mp4,
#[serde(rename = "mov")]
Mov,
#[serde(rename = "webm")]
Webm,
#[serde(rename = "gif")]
Gif,
#[serde(rename = "png-sequence")]
PngSequence,
}
impl std::str::FromStr for VideoFormat {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s.to_lowercase().as_str() {
"mp4" => Ok(VideoFormat::Mp4),
"mov" => Ok(VideoFormat::Mov),
"webm" => Ok(VideoFormat::Webm),
"gif" => Ok(VideoFormat::Gif),
"png" | "png-sequence" => Ok(VideoFormat::PngSequence),
other => Err(format!("Unknown video format: {other}")),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
pub enum VideoCodec {
#[default]
#[serde(rename = "h264")]
H264,
#[serde(rename = "h265")]
H265,
#[serde(rename = "prores")]
ProRes,
#[serde(rename = "vp9")]
Vp9,
}
impl std::str::FromStr for VideoCodec {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s.to_lowercase().as_str() {
"h264" | "libx264" => Ok(VideoCodec::H264),
"h265" | "hevc" | "libx265" => Ok(VideoCodec::H265),
"prores" | "prores_ks" => Ok(VideoCodec::ProRes),
"vp9" | "libvpx-vp9" => Ok(VideoCodec::Vp9),
other => Err(format!("Unknown video codec: {other}")),
}
}
}