async_ffmpeg_sidecar/

event.rs

/// Any event that occurs during the execution of an Ffmpeg command,
/// inluding log messages, parsed metadata, progress updates, and output.
#[derive(Debug, Clone, PartialEq)]
pub enum FfmpegEvent {
  ParsedVersion(FfmpegVersion),
  ParsedConfiguration(FfmpegConfiguration),
  ParsedStreamMapping(String),
  ParsedInput(FfmpegInput),
  ParsedOutput(FfmpegOutput),
  ParsedInputStream(FfmpegStream),
  ParsedOutputStream(FfmpegStream),
  ParsedDuration(FfmpegDuration),
  Log(LogLevel, String),
  LogEOF,
  /// An error that didn't originate from the ffmpeg logs
  Error(String),
  Progress(FfmpegProgress),
  // Not parsing output frames for now
  // OutputFrame(OutputVideoFrame),
  /// A chunk of data that may not correspond to a complete frame.
  /// For examples, it may contain encoded h264.
  /// These chunks will need to be handled manually, or piped directly to
  /// another ffmpeg instance
  OutputChunk(Vec<u8>),
  Done,
}

/// The internal log level designated by FFmpeg on each message.
#[derive(Debug, Clone, PartialEq)]
pub enum LogLevel {
  Info,
  Warning,
  Error,
  Fatal,
  Unknown,
}

#[derive(Debug, Clone, PartialEq)]
pub struct FfmpegInput {
  pub index: u32,
  pub duration: Option<f64>,
  pub raw_log_message: String,
}

#[derive(Debug, Clone, PartialEq)]
pub struct FfmpegDuration {
  pub input_index: u32,
  pub duration: f64,
  pub raw_log_message: String,
}

#[derive(Debug, Clone, PartialEq)]
pub struct FfmpegOutput {
  pub to: String,
  pub index: u32,
  pub raw_log_message: String,
}

impl FfmpegOutput {
  /// Detects one of several identifiers which indicate output to stdout
  pub fn is_stdout(&self) -> bool {
    ["pipe", "pipe:1", "pipe:"].contains(&self.to.as_str())
  }
}

/// Represents metadata about a stream.
#[derive(Debug, Clone, PartialEq)]
pub struct FfmpegStream {
  /// Corresponds to stream `-f` parameter, e.g. `rawvideo`, `h264`, `opus` or `srt`.
  pub format: String,
  // The language of the stream as a three-letter code such as `eng`, `ger` or `jpn`.
  pub language: String,
  /// The index of the input or output that this stream belongs to.
  pub parent_index: u32,
  /// The index of the stream inside the input.
  pub stream_index: u32,
  /// The stderr line that this stream was parsed from.
  pub raw_log_message: String,
  // Data that is specific to a certain stream type.
  pub type_specific_data: StreamTypeSpecificData,
}

impl FfmpegStream {
  pub fn is_audio(&self) -> bool {
    matches!(self.type_specific_data, StreamTypeSpecificData::Audio(_))
  }

  pub fn is_subtitle(&self) -> bool {
    matches!(self.type_specific_data, StreamTypeSpecificData::Subtitle)
  }

  pub fn is_video(&self) -> bool {
    matches!(self.type_specific_data, StreamTypeSpecificData::Video(_))
  }

  pub fn is_other(&self) -> bool {
    matches!(self.type_specific_data, StreamTypeSpecificData::Other)
  }

  pub fn audio_data(&self) -> Option<&AudioStream> {
    match &self.type_specific_data {
      StreamTypeSpecificData::Audio(audio_stream) => Some(audio_stream),
      _ => None,
    }
  }

  pub fn video_data(&self) -> Option<&VideoStream> {
    match &self.type_specific_data {
      StreamTypeSpecificData::Video(video_stream) => Some(video_stream),
      _ => None,
    }
  }
}

/// Represents metadata that is specific to a stream, e.g. fields that are only found in audio
/// streams or that are only found in video streams, etc. Storing this in an enum allows function
/// to accept the generic `Stream` type regardless of its actual type (audio, video, ...).
#[derive(Debug, Clone, PartialEq)]
pub enum StreamTypeSpecificData {
  Audio(AudioStream),
  Video(VideoStream),
  Subtitle,
  Other,
}

/// Represents metadata that is specific to audio stream.
#[derive(Debug, Clone, PartialEq)]
pub struct AudioStream {
  /// The sample rate of the audio stream, e.g. 48000 (Hz)
  pub sample_rate: u32,
  /// The number of channels of the audio stream, e.g. `stereo`, `5.1`, or `7.1`
  pub channels: String,
}

/// Represents metadata that is specific to video streams.
#[derive(Debug, Clone, PartialEq)]
pub struct VideoStream {
  /// Corresponds to stream `-pix_fmt` parameter, e.g. `rgb24`
  pub pix_fmt: String,
  /// Width in pixels
  pub width: u32,
  /// Height in pixels
  pub height: u32,
  /// Framerate in frames per second
  pub fps: f32,
}

#[derive(Debug, Clone, PartialEq)]
pub struct FfmpegVersion {
  pub version: String,
  pub raw_log_message: String,
}

#[derive(Debug, Clone, PartialEq)]
pub struct FfmpegConfiguration {
  pub configuration: Vec<String>,
  pub raw_log_message: String,
}

#[derive(Debug, Clone, PartialEq)]
pub struct FfmpegProgress {
  /// index of the current output frame
  pub frame: u32,
  /// frames per second
  pub fps: f32,
  /// Quality factor (if applicable)
  pub q: f32,
  /// Current total size of the output in kilobytes
  pub size_kb: u32,
  /// The raw time string in format like `00:03:29.04`
  pub time: String,
  /// Bitrate in kilo**bits** per second
  pub bitrate_kbps: f32,
  /// Processing speed as a ratio of the input duration
  ///
  /// - 1x is realtime
  /// - 2x means 2 seconds of input are processed in 1 second of wall clock time
  pub speed: f32,
  /// The line that this progress was parsed from
  pub raw_log_message: String,
}

// #[derive(Clone, PartialEq)]
// pub struct OutputVideoFrame {
//     /// The width of this video frame in pixels
//     pub width: u32,
//     /// The height of this video frame in pixels
//     pub height: u32,
//     /// The pixel format of the video frame, corresponding to the chosen
//     /// `-pix_fmt` FFmpeg parameter.
//     pub pix_fmt: String,
//     /// The index of the FFmpeg output stream that emitted this frame.
//     /// In a typical case, there is only one output stream and this will be 0.
//     pub output_index: u32,
//     /// Raw image frame data. The layout of the pixels in memory depends on
//     /// `width`, `height`, and `pix_fmt`.
//     pub data: Vec<u8>,
//     /// Index of current frame, starting at 0 and monotonically increasing by 1
//     pub frame_num: u32,
//     /// Output frame timestamp in seconds
//     pub timestamp: f32,
// }

// impl std::fmt::Debug for OutputVideoFrame {
//     /// Omit the `data` field form the debug output
//     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
//         f.debug_struct("OutputVideoFrame")
//             .field("width", &self.width)
//             .field("height", &self.height)
//             .field("pix_fmt", &self.pix_fmt)
//             .field("output_index", &self.output_index)
//             .finish()
//     }
// }