feat: add strip covers feature (WIP) and clean up code

Author: Curstantine

src/cli.rs

@@ -45,6 +45,10 @@ pub enum Commands {
         /// - aac-lc: 192K
         bitrate: Option<u32>,
 
+        #[arg(long, default_value_t = false)]
+        /// If set, album cover images will be stripped from synced files.
+        strip_covers: bool,
+
         #[arg(long, value_delimiter = ',', default_value = "flac,alac")]
         /// A comma-separated list of codecs to match to include in the transcode process.
         transcode_codecs: Option<Vec<Codec>>,

src/commands/sync.rs

@@ -8,15 +8,17 @@ use crate::{
     format::{Codec, get_track_data},
     utils::{
         adb_file_exists,
-        fs::{FSBackend, get_file_ext, get_file_name},
-        is_adb_running, parse_sync_list, push_to_adb_device, read_dir_recursively, read_selectively, transcode_file,
+        ffmpeg::{strip_covers, transcode_file},
+        fs::{FSBackend, get_file_ext, get_file_name, read_dir_recursively, read_selectively},
+        is_adb_running, parse_sync_list, push_to_adb_device,
     },
 };
 
 pub struct SyncOpts {
     pub fs: FSBackend,
     pub codec: Option<Codec>,
     pub bitrate: Option<u32>,
+    pub strip_covers: bool,
     pub transcode_codecs: Vec<Codec>,
     pub sync_codecs: Vec<Codec>,
     pub sync_list: Option<String>,
@@ -99,12 +101,11 @@ pub fn run<P: AsRef<Path>>(source_dir: P, target_dir: P, opts: SyncOpts) -> Resu
         // But why? Can't we use the check from codec.is_some()? No, not really.
         // We support syncing files that are part of the sync_extensions, so they don't go through the transcoding workflow.
         // So in cases like removing the temp file, it will remove the source file instead.
-        let mut transcoded = false;
+        let mut is_temp = false;
         let mut final_source_path = file.clone();
 
-        let file_data = get_track_data(&file, &source_file_ext)?;
-        let is_transcodable =
-            !opts.sync_codecs.contains(&file_data.codec) && opts.transcode_codecs.contains(&file_data.codec);
+        let meta = get_track_data(&file, &source_file_ext)?;
+        let is_transcodable = !opts.sync_codecs.contains(&meta.codec) && opts.transcode_codecs.contains(&meta.codec);
 
         match &opts.codec {
             Some(codec) if is_transcodable => {
@@ -123,27 +124,41 @@ pub fn run<P: AsRef<Path>>(source_dir: P, target_dir: P, opts: SyncOpts) -> Resu
                 fs::create_dir_all(temp_path.parent().unwrap())?;
                 transcode_file(&file, &temp_path, *codec, bitrate)?;
 
-                transcoded = true;
+                is_temp = true;
                 final_source_path = temp_path;
                 rel_path.set_extension(new_ext);
             }
             None if is_transcodable => {
                 skipping(&rel_path, &indicator, Some("due to no codec"));
                 continue;
             }
-            _ if opts.sync_codecs.contains(&file_data.codec) => {
+            _ if opts.sync_codecs.contains(&meta.codec) => {
                 if fs_wrapper.exists(&target_dir.join(&rel_path))? {
                     path_already_exists(&rel_path, &indicator);
                     continue;
                 }
+
+                if opts.strip_covers {
+                    let temp_path = temp_dir.join(&rel_path);
+                    fs::create_dir_all(temp_path.parent().unwrap())?;
+                    fs::copy(&file, &temp_path)?;
+
+                    let message = format!("Stripping covers from {}", get_file_name(&rel_path));
+                    indicator.set_message(message);
+
+                    strip_covers(&temp_path, &temp_path)?;
+
+                    is_temp = true;
+                    final_source_path = temp_path;
+                }
             }
             _ => unreachable!(),
         }
 
-        indicator.set_message(format!("Moving {:?}", get_file_name(&rel_path)));
+        indicator.set_message(format!("Syncing {:?}", get_file_name(&rel_path)));
         fs_wrapper.copy(&final_source_path, &target_dir.join(rel_path))?;
 
-        if transcoded {
+        if is_temp {
             fs::remove_file(final_source_path)?;
         }
 
@@ -180,6 +195,10 @@ impl FSWrapper {
             FSBackend::Adb => push_to_adb_device(source, target),
             FSBackend::Ftp => todo!(),
             FSBackend::None => {
+                if let Some(p) = target.parent() {
+                    fs::create_dir_all(p)?;
+                }
+
                 fs::copy(source, target)?;
                 Ok(())
             }

src/main.rs

@@ -21,6 +21,7 @@ fn main() {
             fs,
             codec,
             bitrate,
+            strip_covers,
             transcode_codecs,
             sync_codecs,
             sync_list,
@@ -31,6 +32,7 @@ fn main() {
                 fs: fs.unwrap(),
                 codec,
                 bitrate,
+                strip_covers,
                 transcode_codecs: transcode_codecs.unwrap_or(Vec::with_capacity(0)),
                 sync_codecs: sync_codecs.unwrap(),
                 sync_list,

src/utils/ffmpeg.rs

@@ -0,0 +1,61 @@
+use std::{path::Path, process::Command};
+
+use crate::{
+    errors::{Error, Result},
+    format::Codec,
+};
+
+pub fn strip_covers<P: AsRef<Path>>(source: P, parent: P) -> Result<()> {
+    let mut cmd = Command::new("ffmpeg");
+    cmd.arg("-i")
+        .arg(source.as_ref())
+        .arg("-map")
+        .arg("0:v")
+        .arg("-c")
+        .arg("copy")
+        .arg(parent.as_ref().join("cover_%d.jpg"));
+
+    let output = cmd.output()?;
+
+    if !output.status.success() {
+        let message = format!("ffmpeg exited with code {}", output.status.code().unwrap_or(-1));
+        eprintln!("{}", String::from_utf8_lossy(&output.stderr));
+        return Err(Error::descriptive(message));
+    }
+
+    Ok(())
+}
+
+pub fn transcode_file<P: AsRef<Path>>(source: P, target: P, codec: Codec, bitrate: u32) -> Result<()> {
+    let output = match codec {
+        Codec::Opus => {
+            let mut cmd = Command::new("opusenc");
+            cmd.arg("--bitrate")
+                .arg(format!("{}K", bitrate))
+                .arg(source.as_ref())
+                .arg(target.as_ref());
+
+            cmd.output()
+        }
+        _ => {
+            let mut cmd = Command::new("ffmpeg");
+            cmd.arg("-i")
+                .arg(source.as_ref())
+                .arg("-c:a")
+                .arg(codec.get_ffmpeg_lib())
+                .arg("-b:a")
+                .arg(format!("{}K", bitrate))
+                .arg(target.as_ref());
+
+            cmd.output()
+        }
+    }?;
+
+    if !output.status.success() {
+        let message = format!("transcoder exited with code {}", output.status.code().unwrap_or(-1));
+        eprintln!("{}", String::from_utf8_lossy(&output.stderr));
+        return Err(Error::descriptive(message));
+    }
+
+    Ok(())
+}

src/utils/fs.rs

@@ -1,5 +1,9 @@
+use std::path::{Path, PathBuf};
+
 use clap::ValueEnum;
 
+use crate::errors::{Error, Result};
+
 #[derive(Debug, Clone, ValueEnum)]
 pub enum FSBackend {
     /// Useful for android devices connected over tcpip or usb, and is recommended for all android-targeted syncs.
@@ -19,3 +23,52 @@ pub fn get_file_name(p: &std::path::Path) -> String {
 pub fn get_file_ext(p: &std::path::Path) -> String {
     p.extension().unwrap().to_string_lossy().to_string()
 }
+
+pub fn read_dir_recursively<P: AsRef<Path>>(path: P, extensions: &Option<Vec<&'static str>>) -> Result<Vec<PathBuf>> {
+    let mut files = Vec::<PathBuf>::new();
+
+    for entry in std::fs::read_dir(path)? {
+        let entry = entry?;
+        let path = entry.path();
+
+        if path.is_dir() {
+            let mut sub_files = read_dir_recursively(path, extensions)?;
+            files.append(&mut sub_files);
+        } else {
+            let ext = path.extension().and_then(|ext| ext.to_str()).unwrap();
+            match extensions {
+                Some(exts) if exts.contains(&ext) => files.push(path),
+                None => files.push(path),
+                _ => continue,
+            }
+        }
+    }
+
+    Ok(files)
+}
+
+pub fn read_selectively<P: AsRef<Path>>(paths: &[P], extensions: &Option<Vec<&'static str>>) -> Result<Vec<PathBuf>> {
+    let mut files = Vec::<PathBuf>::new();
+
+    for entry in paths {
+        let path = entry.as_ref();
+
+        if !path.exists() {
+            return Err(Error::descriptive("File does not exist").with_context(path.to_string_lossy()));
+        }
+
+        if path.is_dir() {
+            let mut sub_files = read_dir_recursively(path, extensions)?;
+            files.append(&mut sub_files);
+        } else {
+            let ext = path.extension().and_then(|ext| ext.to_str()).unwrap();
+            match extensions {
+                Some(exts) if exts.contains(&ext) => files.push(path.to_path_buf()),
+                None => files.push(path.to_path_buf()),
+                _ => continue,
+            }
+        }
+    }
+
+    Ok(files)
+}

src/utils/mod.rs

@@ -3,11 +3,9 @@ use std::{
     process::Command,
 };
 
-use crate::{
-    errors::{Error, Result},
-    format::Codec,
-};
+use crate::errors::{Error, Result};
 
+pub mod ffmpeg;
 pub mod fs;
 
 pub fn is_adb_running() -> Result<bool> {
@@ -43,89 +41,6 @@ pub fn push_to_adb_device(source: &Path, target: &Path) -> Result<()> {
     Ok(())
 }
 
-pub fn transcode_file<P: AsRef<Path>>(source: P, target: P, codec: Codec, bitrate: u32) -> Result<()> {
-    let output = match codec {
-        Codec::Opus => {
-            let mut cmd = Command::new("opusenc");
-            cmd.arg("--bitrate")
-                .arg(format!("{}K", bitrate))
-                .arg(source.as_ref().to_str().unwrap())
-                .arg(target.as_ref().to_str().unwrap());
-
-            cmd.output()
-        }
-        _ => {
-            let mut cmd = Command::new("ffmpeg");
-            cmd.arg("-i")
-                .arg(source.as_ref().to_str().unwrap())
-                .arg("-c:a")
-                .arg(codec.get_ffmpeg_lib())
-                .arg("-b:a")
-                .arg(format!("{}K", bitrate))
-                .arg(target.as_ref().to_str().unwrap());
-
-            cmd.output()
-        }
-    }?;
-
-    if !output.status.success() {
-        let message = format!("transcoder exited with code {}", output.status.code().unwrap_or(-1));
-        eprintln!("{}", String::from_utf8_lossy(&output.stderr));
-        return Err(Error::descriptive(message));
-    }
-
-    Ok(())
-}
-
-pub fn read_dir_recursively<P: AsRef<Path>>(path: P, extensions: &Option<Vec<&'static str>>) -> Result<Vec<PathBuf>> {
-    let mut files = Vec::<PathBuf>::new();
-
-    for entry in std::fs::read_dir(path)? {
-        let entry = entry?;
-        let path = entry.path();
-
-        if path.is_dir() {
-            let mut sub_files = read_dir_recursively(path, extensions)?;
-            files.append(&mut sub_files);
-        } else {
-            let ext = path.extension().and_then(|ext| ext.to_str()).unwrap();
-            match extensions {
-                Some(exts) if exts.contains(&ext) => files.push(path),
-                None => files.push(path),
-                _ => continue,
-            }
-        }
-    }
-
-    Ok(files)
-}
-
-pub fn read_selectively<P: AsRef<Path>>(paths: &[P], extensions: &Option<Vec<&'static str>>) -> Result<Vec<PathBuf>> {
-    let mut files = Vec::<PathBuf>::new();
-
-    for entry in paths {
-        let path = entry.as_ref();
-
-        if !path.exists() {
-            return Err(Error::descriptive("File does not exist").with_context(path.to_string_lossy()));
-        }
-
-        if path.is_dir() {
-            let mut sub_files = read_dir_recursively(path, extensions)?;
-            files.append(&mut sub_files);
-        } else {
-            let ext = path.extension().and_then(|ext| ext.to_str()).unwrap();
-            match extensions {
-                Some(exts) if exts.contains(&ext) => files.push(path.to_path_buf()),
-                None => files.push(path.to_path_buf()),
-                _ => continue,
-            }
-        }
-    }
-
-    Ok(files)
-}
-
 pub fn parse_sync_list(source_dir: &Path, path: &Path) -> Result<Vec<PathBuf>> {
     let contents = std::fs::read_to_string(path)?;