1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

#[derive(Debug, Clone, PartialEq)]
pub enum FfmpegEvent {
  ParsedVersion(FfmpegVersion),
  ParsedConfiguration(FfmpegConfiguration),
  ParsedStreamMapping(String),
  ParsedInput(FfmpegInput),
  ParsedOutput(FfmpegOutput),
  ParsedInputStream(AVStream),
  ParsedOutputStream(AVStream),
  ParsedDuration(FfmpegDuration),
  Log(LogLevel, String),
  LogEOF,
  /// An error that didn't originate from the ffmpeg logs
  Error(String),
  Progress(FfmpegProgress),
  OutputFrame(OutputVideoFrame),
  /// A chunk of data that may not correspond to a complete frame.
  /// For example, it may contain encoded h264.
  /// These chunks will need to be handled manually, or piped directly to
  /// another FFmpeg instance.
  OutputChunk(Vec<u8>),
  Done,
}

#[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:", "pipe:1"].contains(&self.to.as_str())
  }
}

#[derive(Debug, Clone, PartialEq)]
pub struct AVStream {
  /// Typically `video` or `audio`, but might be something else like `data` or `subtitle`.
  pub stream_type: String,
  /// Corresponds to stream `-f` parameter, e.g. `rawvideo`, `h264`, or `mpegts`
  pub format: String,
  /// 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,
  /// The index of the input or output that this stream belongs to
  pub parent_index: usize,
  /// The stderr line that this stream was parsed from
  pub raw_log_message: String,
}

#[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 a 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 from 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()
  }
}

// TODO fix the output for OutputChunk also