add configuration options for chdman

Author: alucryd

CHANGELOG.md

@@ -4,6 +4,7 @@
 - Enhance the rom matching algorithm in `import-roms` to reduce prompts when multiple matches are found
 - Use `createcd/createdvd` and `extractcd/extractdvd` appropriately for CDs and DVDs
 - Add a `-r` flag to convert-roms to recompress files that already match the target format
+- Add configuration options for chdman
 
 # 0.18.0
 

README.md

@@ -97,6 +97,10 @@ Available settings:
 - `REGIONS_ONE_SUBFOLDERS`: Sort 1G1R ROMs in subfolders, defaults to `none`, valid choices: `none`, `alpha`
 - `REGIONS_ONE_STRICT`: `true` will elect ROMs regardless of them being available, `false` will only elect available ROMs, defaults to `false`
 - `GROUP_SUBSYSTEMS`: Group all system variants in a single directory, defaults to `true`
+- `CHD_CD_HUNK_SIZE`: The CHD hunk size in bytes for CDs, defaults to auto, valid range: `16-1048576`
+- `CHD_CD_COMPRESSION_ALGORITHMS`: The CHD compression algorithms for CDs, up to 4 can be specified, defaults to auto, valid choices: `none`, `cdfl`, `cdlz`, `cdzl`, `cdzs`
+- `CHD_DVD_HUNK_SIZE`: The CHD hunk size in bytes for DVDs, defaults to auto, valid range: `16-1048576`
+- `CHD_DVD_COMPRESSION_ALGORITHMS`: The CHD compression algorithms for DVDs, up to 4 can be specified, defaults to auto, valid choices: `none`, `flac`, `huff`, `lzma`, `zlib`, `zstd`
 - `RVZ_BLOCK_SIZE`: The RVZ block size in KiB, defaults to `128`, valid range: `32-2048`
 - `RVZ_COMPRESSION_ALGORITHM`: The RVZ compression algorithm, defaults to `zstd`, valid choices: `none`, `zstd`, `bzip`, `lzma`, `lzma2`
 - `RVZ_COMPRESSION_LEVEL`: The RVZ compression level, defaults to `5`, valid ranges: `1-22` for zstd, `1-9` for the other algorithms

migrations/20240331210619_add_chd_settings.sql

@@ -0,0 +1,11 @@
+INSERT OR REPLACE INTO settings ("key", value)
+VALUES ('CHD_CD_HUNK_SIZE', NULL);
+
+INSERT OR REPLACE INTO settings ("key", value)
+VALUES ('CHD_CD_COMPRESSION_ALGORITHMS', NULL);
+
+INSERT OR REPLACE INTO settings ("key", value)
+VALUES ('CHD_DVD_HUNK_SIZE', NULL);
+
+INSERT OR REPLACE INTO settings ("key", value)
+VALUES ('CHD_DVD_COMPRESSION_ALGORITHMS', NULL);

src/chdman.rs

@@ -1,24 +1,45 @@
-use std::path::{Path, PathBuf};
-use std::time::Duration;
-
-use indicatif::ProgressBar;
-use regex::Regex;
-use sqlx::SqliteConnection;
-use tokio::io;
-use tokio::io::AsyncReadExt;
-use tokio::process::Command;
-
 use super::common::*;
 use super::config::*;
 use super::model::*;
 use super::progress::*;
 use super::util::*;
 use super::SimpleResult;
+use indicatif::ProgressBar;
+use regex::Regex;
+use sqlx::SqliteConnection;
+use std::path::{Path, PathBuf};
+use std::time::Duration;
+use strum::{Display, EnumString, VariantNames};
+use tokio::io;
+use tokio::io::AsyncReadExt;
+use tokio::process::Command;
 
 const CHDMAN: &str = "chdman";
 
+pub const CHD_HUNK_SIZE_RANGE: [usize; 2] = [16, 1048576];
 pub const MIN_DREAMCAST_VERSION: &str = "0.264";
 
+#[derive(Display, PartialEq, EnumString, VariantNames)]
+#[strum(serialize_all = "lowercase")]
+pub enum ChdCdCompressionAlgorithm {
+    None,
+    Cdfl,
+    Cdlz,
+    Cdzl,
+    Cdzs,
+}
+
+#[derive(Display, PartialEq, EnumString, VariantNames)]
+#[strum(serialize_all = "lowercase")]
+pub enum ChdDvdCompressionAlgorithm {
+    None,
+    Flac,
+    Huff,
+    Lzma,
+    Zlib,
+    Zstd,
+}
+
 lazy_static! {
     static ref VERSION_REGEX: Regex = Regex::new(r"\d+\.\d+").unwrap();
 }
@@ -77,6 +98,8 @@ pub trait ToChd {
         progress_bar: &ProgressBar,
         destination_directory: &P,
         media_type: &MediaType,
+        compression_algorithms: &[String],
+        hunk_size: &Option<usize>,
     ) -> SimpleResult<ChdRomfile>;
 }
 
@@ -86,12 +109,16 @@ impl ToChd for CueBinRomfile {
         progress_bar: &ProgressBar,
         destination_directory: &P,
         media_type: &MediaType,
+        compression_algorithms: &[String],
+        hunk_size: &Option<usize>,
     ) -> SimpleResult<ChdRomfile> {
         let path = create_chd(
             progress_bar,
             &self.cue_romfile.path,
             destination_directory,
             media_type,
+            hunk_size,
+            compression_algorithms,
         )
         .await?;
         Ok(ChdRomfile {
@@ -107,8 +134,18 @@ impl ToChd for IsoRomfile {
         progress_bar: &ProgressBar,
         destination_directory: &P,
         media_type: &MediaType,
+        compression_algorithms: &[String],
+        hunk_size: &Option<usize>,
     ) -> SimpleResult<ChdRomfile> {
-        let path = create_chd(progress_bar, &self.path, destination_directory, media_type).await?;
+        let path = create_chd(
+            progress_bar,
+            &self.path,
+            destination_directory,
+            media_type,
+            hunk_size,
+            compression_algorithms,
+        )
+        .await?;
         Ok(ChdRomfile {
             path,
             cue_path: None,
@@ -280,6 +317,8 @@ async fn create_chd<P: AsRef<Path>, Q: AsRef<Path>>(
     romfile_path: &P,
     destination_directory: &Q,
     media_type: &MediaType,
+    hunk_size: &Option<usize>,
+    compression_algorithms: &[String],
 ) -> SimpleResult<PathBuf> {
     progress_bar.set_message("Creating chd");
     progress_bar.set_style(get_none_progress_style());
@@ -295,18 +334,25 @@ async fn create_chd<P: AsRef<Path>, Q: AsRef<Path>>(
         chd_path.file_name().unwrap().to_str().unwrap()
     ));
 
-    let output = Command::new(CHDMAN)
+    let mut command = Command::new(CHDMAN);
+    command
         .arg(match media_type {
             MediaType::Cd => "createcd",
             MediaType::Dvd => "createdvd",
         })
         .arg("-i")
         .arg(romfile_path.as_ref())
         .arg("-o")
-        .arg(&chd_path)
-        .output()
-        .await
-        .expect("Failed to create chd");
+        .arg(&chd_path);
+    if let Some(hunk_size) = hunk_size {
+        command.arg("--hunksize").arg(hunk_size.to_string());
+    }
+    if !compression_algorithms.is_empty() {
+        command
+            .arg("--compression")
+            .arg(compression_algorithms.join(","));
+    }
+    let output = command.output().await.expect("Failed to create chd");
 
     if !output.status.success() {
         bail!(String::from_utf8(output.stderr).unwrap().as_str())

src/common.rs

@@ -1,22 +1,20 @@
-use std::fs::File;
-use std::io;
-use std::io::prelude::*;
-use std::path::{Path, PathBuf};
-
-use digest::Digest;
-use indicatif::ProgressBar;
-use md5::Md5;
-use sha1::Sha1;
-use simple_error::SimpleResult;
-use sqlx::SqliteConnection;
-
 use super::config::*;
 use super::crc32::*;
 use super::database::*;
 use super::model::Header;
 use super::model::*;
 use super::progress::*;
 use super::util::*;
+use digest::Digest;
+use indicatif::ProgressBar;
+use md5::Md5;
+use sha1::Sha1;
+use simple_error::SimpleResult;
+use sqlx::SqliteConnection;
+use std::fs::File;
+use std::io;
+use std::io::prelude::*;
+use std::path::{Path, PathBuf};
 
 #[derive(Clone)]
 pub struct CommonRomfile {

src/config.rs

@@ -1,5 +1,6 @@
+use super::chdman::{ChdCdCompressionAlgorithm, ChdDvdCompressionAlgorithm, CHD_HUNK_SIZE_RANGE};
 use super::database::*;
-use super::dolphin::{RVZ_BLOCK_SIZE_RANGE, RVZ_COMPRESSION_LEVEL_RANGE};
+use super::dolphin::{RvzCompressionAlgorithm, RVZ_BLOCK_SIZE_RANGE, RVZ_COMPRESSION_LEVEL_RANGE};
 use super::sevenzip::{SEVENZIP_COMPRESSION_LEVEL_RANGE, ZIP_COMPRESSION_LEVEL_RANGE};
 use super::util::*;
 use super::SimpleResult;
@@ -39,16 +40,6 @@ pub enum HashAlgorithm {
     Sha1,
 }
 
-#[derive(Display, PartialEq, EnumString, VariantNames)]
-#[strum(serialize_all = "lowercase")]
-pub enum RvzCompressionAlgorithm {
-    None,
-    Zstd,
-    Bzip,
-    Lzma,
-    Lzma2,
-}
-
 #[derive(PartialEq, EnumString, VariantNames)]
 #[strum(serialize_all = "lowercase")]
 pub enum SubfolderScheme {
@@ -86,7 +77,13 @@ const CHOICES: phf::Map<&str, &[&str]> = phf_map! {
     "REGIONS_ONE_SUBFOLDERS" => SubfolderScheme::VARIANTS,
     "RVZ_COMPRESSION_ALGORITHM" => RvzCompressionAlgorithm::VARIANTS,
 };
+const CHOICE_LISTS: phf::Map<&str, &[&str]> = phf_map! {
+    "CHD_CD_COMPRESSION_ALGORITHMS" => ChdCdCompressionAlgorithm::VARIANTS,
+    "CHD_DVD_COMPRESSION_ALGORITHMS" => ChdDvdCompressionAlgorithm::VARIANTS,
+};
 const INTEGERS: phf::Map<&str, &[usize; 2]> = phf_map! {
+    "CHD_CD_HUNK_SIZE" => &CHD_HUNK_SIZE_RANGE,
+    "CHD_DVD_HUNK_SIZE" => &CHD_HUNK_SIZE_RANGE,
     "RVZ_BLOCK_SIZE" => &RVZ_BLOCK_SIZE_RANGE,
     "RVZ_COMPRESSION_LEVEL" => &RVZ_COMPRESSION_LEVEL_RANGE,
     "SEVENZIP_COMPRESSION_LEVEL" => &SEVENZIP_COMPRESSION_LEVEL_RANGE,
@@ -287,14 +284,12 @@ pub async fn set_bool(connection: &mut SqliteConnection, key: &str, value: bool)
     };
 }
 
-pub async fn get_integer(connection: &mut SqliteConnection, key: &str) -> usize {
+pub async fn get_integer(connection: &mut SqliteConnection, key: &str) -> Option<usize> {
     find_setting_by_key(connection, key)
         .await
         .unwrap()
         .value
-        .unwrap()
-        .parse()
-        .unwrap()
+        .map(|value| value.parse().unwrap())
 }
 
 async fn set_integer(connection: &mut SqliteConnection, key: &str, value: usize) {
@@ -328,13 +323,26 @@ pub async fn add_to_list(connection: &mut SqliteConnection, key: &str, value: &s
         } else {
             println!("Value already in list");
         }
+    } else if CHOICE_LISTS.keys().any(|&s| s == key) {
+        if CHOICE_LISTS.get(key).unwrap().contains(&value) {
+            let mut list = get_list(connection, key).await;
+            if !list.contains(&String::from(value)) {
+                list.push(value.to_owned());
+                list.sort();
+                set_list(connection, key, &list).await;
+            } else {
+                println!("Value already in list");
+            }
+        } else {
+            println!("Valid choices: {:?}", CHOICE_LISTS.get(key).unwrap());
+        }
     } else {
         println!("Only list settings are supported");
     }
 }
 
 pub async fn remove_from_list(connection: &mut SqliteConnection, key: &str, value: &str) {
-    if LISTS.contains(&key) {
+    if LISTS.contains(&key) || CHOICE_LISTS.keys().any(|&s| s == key) {
         let mut list = get_list(connection, key).await;
         if list.contains(&String::from(value)) {
             list.remove(list.iter().position(|v| v == value).unwrap());
@@ -383,12 +391,8 @@ pub async fn set_directory<P: AsRef<Path>>(
     };
 }
 
-pub async fn get_string(connection: &mut SqliteConnection, key: &str) -> String {
-    find_setting_by_key(connection, key)
-        .await
-        .unwrap()
-        .value
-        .unwrap()
+pub async fn get_string(connection: &mut SqliteConnection, key: &str) -> Option<String> {
+    find_setting_by_key(connection, key).await.unwrap().value
 }
 
 pub async fn set_string(connection: &mut SqliteConnection, key: &str, value: &str) {