renamed temp to cache

Author: master-of-zen

av1an-core/src/broker.rs

@@ -215,7 +215,7 @@ impl<'a> Broker<'a> {
     let enc_time = st_time.elapsed();
     let fps = chunk.frames() as f64 / enc_time.as_secs_f64();
 
-    let progress_file = Path::new(&self.project.args.temp).join("done.json");
+    let progress_file = Path::new(&self.project.args.cache).join("done.json");
     get_done().done.insert(
       chunk.name(),
       DoneChunk {

av1an-core/src/chunk.rs

@@ -10,7 +10,7 @@ use crate::Input;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Chunk {
-  pub temp: String,
+  pub cache: String,
   pub index: usize,
   pub input: Input,
   pub source_cmd: Vec<OsString>,
@@ -37,7 +37,7 @@ impl Chunk {
   }
 
   pub fn output(&self) -> String {
-    Path::new(&self.temp)
+    Path::new(&self.cache)
       .join("encode")
       .join(format!("{}.{}", self.name(), self.output_ext))
       .to_str()
@@ -56,7 +56,7 @@ impl Chunk {
   ) -> anyhow::Result<()> {
     if let Some(strength) = photon_noise {
       let iso_setting = u32::from(strength) * 100;
-      let grain_table = Path::new(&self.temp).join(format!("iso{iso_setting}-grain.tbl"));
+      let grain_table = Path::new(&self.cache).join(format!("iso{iso_setting}-grain.tbl"));
       if !grain_table.exists() {
         debug!("Generating grain table at ISO {}", iso_setting);
         let (mut width, mut height) = self.input.resolution()?;
@@ -98,7 +98,7 @@ mod tests {
   #[test]
   fn test_chunk_name_1() {
     let ch = Chunk {
-      temp: "none".to_owned(),
+      cache: "none".to_owned(),
       index: 1,
       input: Input::Video("test.mkv".into()),
       source_cmd: vec!["".into()],
@@ -118,7 +118,7 @@ mod tests {
   #[test]
   fn test_chunk_name_10000() {
     let ch = Chunk {
-      temp: "none".to_owned(),
+      cache: "none".to_owned(),
       index: 10000,
       input: Input::Video("test.mkv".into()),
       source_cmd: vec!["".into()],
@@ -139,7 +139,7 @@ mod tests {
   #[test]
   fn test_chunk_output() {
     let ch = Chunk {
-      temp: "d".to_owned(),
+      cache: "d".to_owned(),
       index: 1,
       input: Input::Video("test.mkv".into()),
       source_cmd: vec!["".into()],

av1an-core/src/concat.rs

@@ -37,7 +37,7 @@ impl Display for ConcatMethod {
 
 pub fn sort_files_by_filename(files: &mut [PathBuf]) {
   files.sort_unstable_by_key(|x| {
-    // If the temp directory follows the expected format of 00000.ivf, 00001.ivf, etc.,
+    // If the cache directory follows the expected format of 00000.ivf, 00001.ivf, etc.,
     // then these unwraps will not fail
     x.file_stem()
       .unwrap()
@@ -242,10 +242,10 @@ pub fn mkvmerge_options_json(
 }
 
 /// Concatenates using ffmpeg (does not work with x265)
-pub fn ffmpeg(temp: &Path, output: &Path) -> anyhow::Result<()> {
-  fn write_concat_file(temp_folder: &Path) -> anyhow::Result<()> {
-    let concat_file = temp_folder.join("concat");
-    let encode_folder = temp_folder.join("encode");
+pub fn ffmpeg(cache: &Path, output: &Path) -> anyhow::Result<()> {
+  fn write_concat_file(cache_folder: &Path) -> anyhow::Result<()> {
+    let concat_file = cache_folder.join("concat");
+    let encode_folder = cache_folder.join("encode");
 
     let mut files = read_encoded_chunks(&encode_folder)?;
 
@@ -270,16 +270,16 @@ pub fn ffmpeg(temp: &Path, output: &Path) -> anyhow::Result<()> {
     Ok(())
   }
 
-  let temp = PathAbs::new(temp)?;
-  let temp = temp.as_path();
+  let cache = PathAbs::new(cache)?;
+  let cache = cache.as_path();
 
-  let concat = temp.join("concat");
+  let concat = cache.join("concat");
   let concat_file = concat.to_str().unwrap();
 
-  write_concat_file(temp)?;
+  write_concat_file(cache)?;
 
   let audio_file = {
-    let file = temp.join("audio.mkv");
+    let file = cache.join("audio.mkv");
     if file.exists() && file.metadata().unwrap().len() > 1000 {
       Some(file)
     } else {

av1an-core/src/context.rs

@@ -58,25 +58,25 @@ impl Av1anContext {
     Ok(this)
   }
 
-  /// Initialize logging routines and create temporary directories
+  /// Initialize logging routines and create cache directories
   fn initialize(&mut self) -> anyhow::Result<()> {
     ffmpeg::init()?;
     ffmpeg::util::log::set_level(ffmpeg::util::log::level::Level::Fatal);
 
-    if !self.args.resume && Path::new(&self.args.temp).is_dir() {
-      fs::remove_dir_all(&self.args.temp)
-        .with_context(|| format!("Failed to remove temporary directory {:?}", &self.args.temp))?;
+    if !self.args.resume && Path::new(&self.args.cache).is_dir() {
+      fs::remove_dir_all(&self.args.cache)
+        .with_context(|| format!("Failed to remove cache directory {:?}", &self.args.cache))?;
     }
 
-    create_dir!(Path::new(&self.args.temp))?;
-    create_dir!(Path::new(&self.args.temp).join("split"))?;
-    create_dir!(Path::new(&self.args.temp).join("encode"))?;
+    create_dir!(Path::new(&self.args.cache))?;
+    create_dir!(Path::new(&self.args.cache).join("split"))?;
+    create_dir!(Path::new(&self.args.cache).join("encode"))?;
 
-    debug!("temporary directory: {}", &self.args.temp);
+    debug!("cache directory: {}", &self.args.cache);
 
-    let done_path = Path::new(&self.args.temp).join("done.json");
+    let done_path = Path::new(&self.args.cache).join("done.json");
     let done_json_exists = done_path.exists();
-    let chunks_json_exists = Path::new(&self.args.temp).join("chunks.json").exists();
+    let chunks_json_exists = Path::new(&self.args.cache).join("chunks.json").exists();
 
     if self.args.resume {
       match (done_json_exists, chunks_json_exists) {
@@ -85,21 +85,21 @@ impl Av1anContext {
         (false, true) => {
           info!(
             "resume was set but done.json does not exist in temporary directory {:?}",
-            &self.args.temp
+            &self.args.cache
           );
           self.args.resume = false;
         }
         (true, false) => {
           info!(
             "resume was set but chunks.json does not exist in temporary directory {:?}",
-            &self.args.temp
+            &self.args.cache
           );
           self.args.resume = false;
         }
         (false, false) => {
           info!(
             "resume was set but neither chunks.json nor done.json exist in temporary directory {:?}",
-            &self.args.temp
+            &self.args.cache
           );
           self.args.resume = false;
         }
@@ -152,7 +152,7 @@ impl Av1anContext {
         {
           self.vs_script = Some(match &self.args.input {
             Input::VapourSynth(path) => path.clone(),
-            Input::Video(path) => create_vs_file(&self.args.temp, path, self.args.chunk_method)?,
+            Input::Video(path) => create_vs_file(&self.args.cache, path, self.args.chunk_method)?,
           });
 
           let vs_script = self.vs_script.clone().unwrap();
@@ -198,8 +198,8 @@ impl Av1anContext {
     if self.args.sc_only {
       debug!("scene detection only");
 
-      if let Err(e) = fs::remove_dir_all(&self.args.temp) {
-        warn!("Failed to delete temp directory: {}", e);
+      if let Err(e) = fs::remove_dir_all(&self.args.cache) {
+        warn!("Failed to delete cache directory: {}", e);
       }
 
       exit(0);
@@ -227,13 +227,13 @@ impl Av1anContext {
         && (!self.args.resume || !get_done().audio_done.load(atomic::Ordering::SeqCst))
       {
         let input = self.args.input.as_video_path();
-        let temp = self.args.temp.as_str();
+        let cache = self.args.cache.as_str();
         let audio_params = self.args.audio_params.as_slice();
         Some(s.spawn(move |_| {
-          let audio_output = crate::ffmpeg::encode_audio(input, temp, audio_params);
+          let audio_output = crate::ffmpeg::encode_audio(input, cache, audio_params);
           get_done().audio_done.store(true, atomic::Ordering::SeqCst);
 
-          let progress_file = Path::new(temp).join("done.json");
+          let progress_file = Path::new(cache).join("done.json");
           let mut progress_file = File::create(progress_file).unwrap();
           progress_file
             .write_all(serde_json::to_string(get_done()).unwrap().as_bytes())
@@ -329,20 +329,20 @@ impl Av1anContext {
       match self.args.concat {
         ConcatMethod::Ivf => {
           concat::ivf(
-            &Path::new(&self.args.temp).join("encode"),
+            &Path::new(&self.args.cache).join("encode"),
             self.args.output_file.as_ref(),
           )?;
         }
         ConcatMethod::MKVMerge => {
           concat::mkvmerge(
-            self.args.temp.as_ref(),
+            self.args.cache.as_ref(),
             self.args.output_file.as_ref(),
             self.args.encoder,
             total_chunks,
           )?;
         }
         ConcatMethod::FFmpeg => {
-          concat::ffmpeg(self.args.temp.as_ref(), self.args.output_file.as_ref())?;
+          concat::ffmpeg(self.args.cache.as_ref(), self.args.output_file.as_ref())?;
         }
       }
 
@@ -376,12 +376,12 @@ impl Av1anContext {
 
       if !Path::new(&self.args.output_file).exists() {
         warn!(
-          "Concatenation failed for unknown reasons! Temp folder will not be deleted: {}",
-          &self.args.temp
+          "Concatenation failed for unknown reasons! cache folder will not be deleted: {}",
+          &self.args.cache
         );
       } else if !self.args.keep {
-        if let Err(e) = fs::remove_dir_all(&self.args.temp) {
-          warn!("Failed to delete temp directory: {}", e);
+        if let Err(e) = fs::remove_dir_all(&self.args.cache) {
+          warn!("Failed to delete cache directory: {}", e);
         }
       }
 
@@ -416,7 +416,7 @@ impl Av1anContext {
   ) -> Result<(), (Box<EncoderCrash>, u64)> {
     update_mp_chunk(worker_id, chunk.index, padding);
 
-    let fpf_file = Path::new(&chunk.temp)
+    let fpf_file = Path::new(&chunk.cache)
       .join("split")
       .join(format!("{}_fpf", chunk.name()));
 
@@ -767,7 +767,7 @@ impl Av1anContext {
   // scenes.json and return that.
   fn split_routine(&mut self) -> anyhow::Result<Vec<Scene>> {
     let scene_file = self.args.scenes.as_ref().map_or_else(
-      || Cow::Owned(Path::new(&self.args.temp).join("scenes.json")),
+      || Cow::Owned(Path::new(&self.args.cache).join("scenes.json")),
       |path| Cow::Borrowed(path.as_path()),
     );
 
@@ -874,7 +874,7 @@ impl Av1anContext {
     let output_ext = self.args.encoder.output_extension();
 
     let mut chunk = Chunk {
-      temp: self.args.temp.clone(),
+      cache: self.args.cache.clone(),
       index,
       input: Input::Video(src_path.to_path_buf()),
       source_cmd: ffmpeg_gen_cmd,
@@ -927,7 +927,7 @@ impl Av1anContext {
     let output_ext = self.args.encoder.output_extension();
 
     let mut chunk = Chunk {
-      temp: self.args.temp.clone(),
+      cache: self.args.cache.clone(),
       index,
       input: Input::VapourSynth(vs_script.to_path_buf()),
       source_cmd: vspipe_cmd_gen,
@@ -1001,7 +1001,7 @@ impl Av1anContext {
     debug!("Splitting video");
     segment(
       input,
-      &self.args.temp,
+      &self.args.cache,
       &scenes
         .iter()
         .skip(1)
@@ -1010,12 +1010,12 @@ impl Av1anContext {
     );
     debug!("Splitting done");
 
-    let source_path = Path::new(&self.args.temp).join("split");
+    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 temp/split, probably splitting not working"
+      "Error: No files found in cache/split, probably splitting not working"
     );
 
     let chunk_queue: Vec<Chunk> = queue_files
@@ -1049,10 +1049,10 @@ impl Av1anContext {
       .collect();
 
     debug!("Segmenting video");
-    segment(input, &self.args.temp, &to_split[1..]);
+    segment(input, &self.args.cache, &to_split[1..]);
     debug!("Segment done");
 
-    let source_path = Path::new(&self.args.temp).join("split");
+    let source_path = Path::new(&self.args.cache).join("split");
     let queue_files = Self::read_queue_files(&source_path)?;
 
     let kf_list = to_split
@@ -1127,7 +1127,7 @@ impl Av1anContext {
     let num_frames = num_frames(Path::new(file))?;
 
     let mut chunk = Chunk {
-      temp: self.args.temp.clone(),
+      cache: self.args.cache.clone(),
       input: Input::Video(PathBuf::from(file)),
       source_cmd: ffmpeg_gen_cmd,
       output_ext: output_ext.to_owned(),
@@ -1155,7 +1155,7 @@ impl Av1anContext {
   /// Returns unfinished chunks and number of total chunks
   fn load_or_gen_chunk_queue(&mut self, splits: &[Scene]) -> anyhow::Result<(Vec<Chunk>, usize)> {
     if self.args.resume {
-      let mut chunks = read_chunk_queue(self.args.temp.as_ref())?;
+      let mut chunks = read_chunk_queue(self.args.cache.as_ref())?;
       let num_chunks = chunks.len();
 
       let done = get_done();
@@ -1167,7 +1167,7 @@ impl Av1anContext {
     } else {
       let chunks = self.create_encoding_queue(splits)?;
       let num_chunks = chunks.len();
-      save_chunk_queue(&self.args.temp, &chunks)?;
+      save_chunk_queue(&self.args.cache, &chunks)?;
       Ok((chunks, num_chunks))
     }
   }

av1an-core/src/encoder.rs

@@ -816,7 +816,7 @@ impl Encoder {
   /// Constructs tuple of commands for target quality probing
   pub fn probe_cmd(
     self,
-    temp: String,
+    cache: String,
     chunk_index: usize,
     q: usize,
     pix_fmt: Pixel,
@@ -836,7 +836,7 @@ impl Encoder {
     );
 
     let probe_name = format!("v_{q}_{chunk_index}.ivf");
-    let mut probe = PathBuf::from(temp);
+    let mut probe = PathBuf::from(cache);
     probe.push("split");
     probe.push(&probe_name);
     let probe_path = probe.to_str().unwrap().to_owned();

av1an-core/src/ffmpeg.rs

@@ -149,14 +149,14 @@ pub fn has_audio(file: &Path) -> bool {
 #[must_use]
 pub fn encode_audio<S: AsRef<OsStr>>(
   input: impl AsRef<Path>,
-  temp: impl AsRef<Path>,
+  cache: impl AsRef<Path>,
   audio_params: &[S],
 ) -> Option<PathBuf> {
   let input = input.as_ref();
-  let temp = temp.as_ref();
+  let cache = cache.as_ref();
 
   if has_audio(input) {
-    let audio_file = Path::new(temp).join("audio.mkv");
+    let audio_file = Path::new(cache).join("audio.mkv");
     let mut encode_audio = Command::new("ffmpeg");
 
     encode_audio.stdout(Stdio::piped());