Man command to quantizer_replace

Author: master-of-zen

av1an-core/src/broker.rs

@@ -1,7 +1,7 @@
 use std::fmt::{Debug, Display};
 use std::fs::File;
 use std::io::Write;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::ExitStatus;
 use std::sync::mpsc::Sender;
 use std::thread::available_parallelism;
@@ -18,6 +18,11 @@ use crate::{finish_progress_bar, get_done, Chunk, DoneChunk, Instant};
 pub struct Broker<'a> {
   pub chunk_queue: Vec<Chunk>,
   pub project: &'a Av1anContext,
+
+  // Future
+  pub broker_port: Option<u32>,
+  pub http_port: Option<u32>,
+  pub cache_root: Option<PathBuf>,
 }
 
 #[derive(Clone)]
@@ -97,7 +102,7 @@ impl Display for EncoderCrash {
 impl<'a> Broker<'a> {
   /// Main encoding loop. set_thread_affinity may be ignored if the value is invalid.
   pub fn encoding_loop(self, tx: Sender<()>, mut set_thread_affinity: Option<usize>) {
-    assert!(!self.chunk_queue.is_empty());
+    //if self.chunk_queue.is_empty() ?? {};
 
     if !self.chunk_queue.is_empty() {
       let (sender, receiver) = crossbeam_channel::bounded(self.chunk_queue.len());

av1an-core/src/context.rs

@@ -303,6 +303,9 @@ impl Av1anContext {
       let broker = Broker {
         chunk_queue,
         project: self,
+        broker_port: None,
+        http_port: None,
+        cache_root: None,
       };
 
       let (tx, rx) = mpsc::channel();
@@ -442,7 +445,7 @@ impl Av1anContext {
     if let Some(per_shot_target_quality_cq) = chunk.tq_cq {
       enc_cmd = chunk
         .encoder
-        .man_command(enc_cmd, per_shot_target_quality_cq as usize);
+        .quantizer_replace(enc_cmd, per_shot_target_quality_cq as usize);
     }
 
     let rt = tokio::runtime::Builder::new_current_thread()
@@ -828,270 +831,6 @@ impl Av1anContext {
     Ok(scenes)
   }
 
-  fn create_select_chunk(
-    &self,
-    index: usize,
-    src_path: &Path,
-    start_frame: usize,
-    end_frame: usize,
-    frame_rate: f64,
-    overrides: Option<ZoneOptions>,
-  ) -> anyhow::Result<Chunk> {
-    assert!(
-      start_frame < end_frame,
-      "Can't make a chunk with <= 0 frames!"
-    );
-
-    let ffmpeg_gen_cmd: Vec<OsString> = into_vec![
-      "ffmpeg",
-      "-y",
-      "-hide_banner",
-      "-loglevel",
-      "error",
-      "-i",
-      src_path,
-      "-vf",
-      format!(
-        "select=between(n\\,{}\\,{}),setpts=PTS-STARTPTS",
-        start_frame,
-        end_frame - 1
-      ),
-      "-pix_fmt",
-      self
-        .args
-        .output_pix_format
-        .format
-        .descriptor()
-        .unwrap()
-        .name(),
-      "-strict",
-      "-1",
-      "-f",
-      "yuv4mpegpipe",
-      "-",
-    ];
-
-    let output_ext = self.args.encoder.output_extension();
-
-    let mut chunk = Chunk {
-      cache: self.args.cache.clone(),
-      index,
-      input: Input::Video(src_path.to_path_buf()),
-      source_cmd: ffmpeg_gen_cmd,
-      output_ext: output_ext.to_owned(),
-      start_frame,
-      end_frame,
-      frame_rate,
-      video_params: overrides.as_ref().map_or_else(
-        || self.args.video_params.clone(),
-        |ovr| ovr.video_params.clone(),
-      ),
-      passes: self.args.passes,
-      encoder: self.args.encoder,
-      noise_size: self.args.photon_noise_size,
-      tq_cq: None,
-      ignore_frame_mismatch: self.args.ignore_frame_mismatch,
-    };
-    chunk.apply_photon_noise_args(
-      overrides.map_or(self.args.photon_noise, |ovr| ovr.photon_noise),
-      self.args.chroma_noise,
-    )?;
-    if let Some(ref tq) = self.args.target_quality {
-      tq.per_shot_target_quality_routine(&mut chunk)?;
-    }
-    Ok(chunk)
-  }
-
-  fn create_vs_chunk(
-    &self,
-    index: usize,
-    vs_script: &Path,
-    scene: &Scene,
-    frame_rate: f64,
-  ) -> anyhow::Result<Chunk> {
-    // the frame end boundary is actually a frame that should be included in the next chunk
-    let frame_end = scene.end_frame - 1;
-
-    let vspipe_cmd_gen: Vec<OsString> = into_vec![
-      "vspipe",
-      vs_script,
-      "-c",
-      "y4m",
-      "-",
-      "-s",
-      scene.start_frame.to_string(),
-      "-e",
-      frame_end.to_string(),
-    ];
-
-    let output_ext = self.args.encoder.output_extension();
-
-    let mut chunk = Chunk {
-      cache: self.args.cache.clone(),
-      index,
-      input: Input::VapourSynth(vs_script.to_path_buf()),
-      source_cmd: vspipe_cmd_gen,
-      output_ext: output_ext.to_owned(),
-      start_frame: scene.start_frame,
-      end_frame: scene.end_frame,
-      frame_rate,
-      video_params: scene.zone_overrides.as_ref().map_or_else(
-        || self.args.video_params.clone(),
-        |ovr| ovr.video_params.clone(),
-      ),
-      passes: self.args.passes,
-      encoder: self.args.encoder,
-      noise_size: self.args.photon_noise_size,
-      tq_cq: None,
-      ignore_frame_mismatch: self.args.ignore_frame_mismatch,
-    };
-    chunk.apply_photon_noise_args(
-      scene
-        .zone_overrides
-        .as_ref()
-        .map_or(self.args.photon_noise, |ovr| ovr.photon_noise),
-      self.args.chroma_noise,
-    )?;
-    Ok(chunk)
-  }
-
-  fn create_video_queue_vs(&self, scenes: &[Scene], vs_script: &Path) -> Vec<Chunk> {
-    let frame_rate = self.args.input.frame_rate().unwrap();
-    let chunk_queue: Vec<Chunk> = scenes
-      .iter()
-      .enumerate()
-      .map(|(index, scene)| {
-        self
-          .create_vs_chunk(index, vs_script, scene, frame_rate)
-          .unwrap()
-      })
-      .collect();
-
-    chunk_queue
-  }
-
-  fn create_video_queue_select(&self, scenes: &[Scene]) -> Vec<Chunk> {
-    let input = self.args.input.as_video_path();
-    let frame_rate = self.args.input.frame_rate().unwrap();
-
-    let chunk_queue: Vec<Chunk> = scenes
-      .iter()
-      .enumerate()
-      .map(|(index, scene)| {
-        self
-          .create_select_chunk(
-            index,
-            input,
-            scene.start_frame,
-            scene.end_frame,
-            frame_rate,
-            scene.zone_overrides.clone(),
-          )
-          .unwrap()
-      })
-      .collect();
-
-    chunk_queue
-  }
-
-  fn create_video_queue_segment(&self, scenes: &[Scene]) -> anyhow::Result<Vec<Chunk>> {
-    let input = self.args.input.as_video_path();
-    let frame_rate = self.args.input.frame_rate().unwrap();
-
-    debug!("Splitting video");
-    segment(
-      input,
-      &self.args.cache,
-      &scenes
-        .iter()
-        .skip(1)
-        .map(|scene| scene.start_frame)
-        .collect::<Vec<usize>>(),
-    );
-    debug!("Splitting done");
-
-    let source_path = Path::new(&self.args.cache).join("split");
-    let queue_files = Self::read_queue_files(&source_path)?;
-
-    assert!(
-      !queue_files.is_empty(),
-      "Error: No files found in cache/split, probably splitting not working"
-    );
-
-    let chunk_queue: Vec<Chunk> = queue_files
-      .iter()
-      .enumerate()
-      .map(|(index, file)| {
-        self
-          .create_chunk_from_segment(
-            index,
-            file.as_path().to_str().unwrap(),
-            frame_rate,
-            scenes[index].zone_overrides.clone(),
-          )
-          .unwrap()
-      })
-      .collect();
-
-    Ok(chunk_queue)
-  }
-
-  fn create_video_queue_hybrid(&self, scenes: &[Scene]) -> anyhow::Result<Vec<Chunk>> {
-    let input = self.args.input.as_video_path();
-    let frame_rate = self.args.input.frame_rate().unwrap();
-
-    let keyframes = crate::ffmpeg::get_keyframes(input).unwrap();
-
-    let to_split: Vec<usize> = keyframes
-      .iter()
-      .filter(|kf| scenes.iter().any(|scene| scene.start_frame == **kf))
-      .copied()
-      .collect();
-
-    debug!("Segmenting video");
-    segment(input, &self.args.cache, &to_split[1..]);
-    debug!("Segment done");
-
-    let source_path = Path::new(&self.args.cache).join("split");
-    let queue_files = Self::read_queue_files(&source_path)?;
-
-    let kf_list = to_split
-      .iter()
-      .copied()
-      .chain(iter::once(self.frames))
-      .tuple_windows();
-
-    let mut segments = Vec::with_capacity(scenes.len());
-    for (file, (x, y)) in queue_files.iter().zip(kf_list) {
-      for s in scenes {
-        let s0 = s.start_frame;
-        let s1 = s.end_frame;
-        if s0 >= x && s1 <= y && s0 < s1 {
-          segments.push((file.as_path(), (s0 - x, s1 - x, s)));
-        }
-      }
-    }
-
-    let chunk_queue: Vec<Chunk> = segments
-      .iter()
-      .enumerate()
-      .map(|(index, &(file, (start, end, scene)))| {
-        self
-          .create_select_chunk(
-            index,
-            file,
-            start,
-            end,
-            frame_rate,
-            scene.zone_overrides.clone(),
-          )
-          .unwrap()
-      })
-      .collect();
-
-    Ok(chunk_queue)
-  }
-
   fn create_chunk_from_segment(
     &self,
     index: usize,

av1an-core/src/encoder.rs

@@ -546,7 +546,7 @@ impl Encoder {
   }
 
   /// Returns changed q/crf in command line arguments
-  pub fn man_command(self, mut params: Vec<String>, q: usize) -> Vec<String> {
+  pub fn quantizer_replace(self, mut params: Vec<String>, q: usize) -> Vec<String> {
     let index = list_index(&params, self.q_match_fn());
     if let Some(index) = index {
       let (replace_index, replace_q) = self.replace_q(index, q);