this repo has no description
🐛 Fix progress bar and timings analysis
authored by
Gwenn Le Bihan
and committed by
Gwenn Le Bihan
d255fbda
cffb9853
+29
-17
+29
-17
src/video/encoding.rs
+29
-17
src/video/encoding.rs
···
1
+
1
2
use super::{context::Context, engine::milliseconds_to_timestamp, Video};
2
3
use crate::rendering::stringify_svg;
3
4
use crate::{Canvas, SVGRenderable};
4
5
use anyhow::Result;
5
6
use indicatif::ProgressIterator;
6
7
use measure_time::debug_time;
7
-
use std::io::Write;
8
-
use std::sync::mpsc::Sender;
8
+
use std::fs::File;
9
+
use std::io::{Read, Write};
10
+
use std::sync::mpsc::{Sender, SyncSender};
9
11
use std::thread;
10
12
use std::time::Duration;
11
13
use std::{fs::create_dir_all, path::PathBuf};
···
41
43
.arg("-shortest")
42
44
.arg(output_path.to_str().unwrap())
43
45
.arg("-loglevel")
44
-
.arg("error")
46
+
.arg(if log::log_enabled!(log::Level::Debug) {
47
+
"debug"
48
+
} else {
49
+
"error"
50
+
})
45
51
.stdin(std::process::Stdio::piped())
52
+
.stdout(File::create("ffmpeg_stdout.log")?)
53
+
.stderr(File::create("ffmpeg_stderr.log")?)
46
54
.spawn()?)
47
55
}
48
56
49
57
pub fn render_frames(
50
58
&self,
51
-
output: Sender<(Duration, String)>,
59
+
output: SyncSender<(Duration, String)>,
52
60
) -> Result<usize> {
53
61
debug_time!("render_frames");
54
62
let mut written_frames_count: usize = 0;
···
71
79
let mut previous_rendered_beat = 0;
72
80
let mut previous_rendered_frame = 0;
73
81
74
-
let render_ms_range = 0..self.duration_ms() + self.start_rendering_at;
82
+
let render_ms_range = self.start_rendering_at + 0..self.duration_ms();
75
83
76
84
self.progress_bar.set_length(render_ms_range.len() as u64);
77
85
78
-
for _ in render_ms_range
79
-
.into_iter()
80
-
.progress_with(self.progress_bar.clone())
81
-
{
86
+
for _ in render_ms_range {
82
87
context.ms += 1_usize;
83
88
context.timestamp = milliseconds_to_timestamp(context.ms).to_string();
84
89
context.beat_fractional =
···
86
91
context.beat = context.beat_fractional as usize;
87
92
context.frame = self.fps * context.ms / 1000;
88
93
89
-
self.progress_bar.set_message(context.timestamp.clone());
90
-
91
94
if context.marker() != "" {
92
95
self.progress_bar.println(format!(
93
96
"{}: marker {}",
···
167
170
}
168
171
}
169
172
173
+
output.send((Duration::from_millis(context.ms as _), "".to_string()))?;
174
+
170
175
Ok(written_frames_count)
171
176
}
172
177
···
191
196
let initial_canvas = self.initial_canvas.clone();
192
197
let resolution = self.resolution;
193
198
194
-
let (tx, rx) = std::sync::mpsc::channel();
199
+
let (tx, rx) = std::sync::mpsc::sync_channel::<(Duration, String)>(1_000);
200
+
201
+
let pb = self.progress_bar.clone();
202
+
203
+
let encoder_thread = thread::spawn(move || {
204
+
for (time, svg) in rx.iter() {
205
+
if svg.is_empty() {
206
+
break;
207
+
}
195
208
196
-
thread::spawn(move || {
197
-
for (time, svg) in rx.into_iter() {
198
209
encode_frame(
199
210
&mut encoder,
200
211
resolution,
···
203
214
&svg,
204
215
)
205
216
.unwrap();
217
+
218
+
pb.set_position(time.as_millis() as _);
219
+
pb.set_message(milliseconds_to_timestamp(time.as_millis() as _));
206
220
}
207
221
208
222
encoder.stdin.take().unwrap().flush().unwrap();
···
210
224
211
225
self.render_frames(tx)?;
212
226
213
-
self.progress_bar.set_position(0);
214
-
self.progress_bar.set_prefix("Adding");
215
-
self.progress_bar.set_message("audio track");
227
+
encoder_thread.join().expect("Encoder thread panicked");
216
228
217
229
Ok(())
218
230
}