feat: add cli support for ncm

um_cli/src/cmd/mod.rs

@@ -1,5 +1,6 @@
 use clap::Subcommand;
 
+pub mod ncm;
 pub mod qmc1;
 pub mod qmc2;
 
@@ -9,4 +10,6 @@ pub enum Commands {
     QMCv1(qmc1::ArgsQMCv1),
     #[command(name = "qmc2")]
     QMCv2(qmc2::ArgsQMCv2),
+    #[command(name = "ncm")]
+    NCM(ncm::ArgsNCM),
 }

um_cli/src/cmd/ncm.rs

@@ -0,0 +1,90 @@
+use crate::Cli;
+use clap::Args;
+use std::fs::File;
+use std::io::{Read, Seek, SeekFrom, Write};
+use std::path::PathBuf;
+use umc_ncm::header::NCMFile;
+
+/// Decrypt a NCM file (NetEase Cloud Music)
+#[derive(Args)]
+pub struct ArgsNCM {
+    /// Path to output file, e.g. /export/Music/song.flac
+    #[arg(short, long)]
+    output: Option<PathBuf>,
+
+    /// Path to input file, e.g. /export/Music/song.ncm
+    #[arg(name = "input")]
+    input: PathBuf,
+
+    /// Path to export cover image. Could be either JPG or PNG.
+    /// File will not be created if not found.
+    #[arg(short)]
+    cover: Option<PathBuf>,
+
+    /// Path to export metadata. JSON string.
+    #[arg(short)]
+    metadata: Option<PathBuf>,
+}
+
+impl ArgsNCM {
+    fn write_metadata(&self, cli: &Cli, ncm: &NCMFile) -> anyhow::Result<()> {
+        if let Some(metadata_path) = &self.metadata {
+            if !ncm.metadata.is_empty() {
+                let metadata = ncm.get_metadata()?;
+                File::create(metadata_path)?.write_all(&metadata)?;
+                if cli.verbose {
+                    let metadata_path = metadata_path.display();
+                    let len = metadata.len();
+                    println!("metadata written to {metadata_path} ({len} bytes)");
+                }
+            } else {
+                println!("metadata is empty, skip.");
+            }
+        }
+        Ok(())
+    }
+
+    fn write_cover(&self, cli: &Cli, ncm: &NCMFile) -> anyhow::Result<()> {
+        if let Some(cover_path) = &self.cover {
+            if let Some(cover) = &ncm.image1 {
+                File::create(cover_path)?.write_all(&cover)?;
+                if cli.verbose {
+                    let cover_path = cover_path.display();
+                    let len = cover.len();
+                    println!("cover written to {cover_path} ({len} bytes)");
+                }
+            } else {
+                println!("cover#1 is empty, skip.");
+            }
+        }
+        Ok(())
+    }
+
+    pub fn run(&self, cli: &Cli) -> anyhow::Result<i32> {
+        let mut file_input = File::open(&self.input)?;
+        let ncm = NCMFile::new_from_readable(&mut file_input)?;
+
+        self.write_metadata(cli, &ncm)?;
+        self.write_cover(cli, &ncm)?;
+
+        if let Some(output_path) = &self.output {
+            file_input.seek(SeekFrom::Start(ncm.audio_data_offset as u64))?;
+            let mut file_output = File::create(output_path)?;
+
+            let mut offset = 0usize;
+            let mut buffer = vec![0u8; cli.buffer_size].into_boxed_slice();
+
+            while let Ok(n) = file_input.read(&mut buffer) {
+                if n == 0 {
+                    break;
+                }
+
+                ncm.decrypt(&mut buffer[..n], offset);
+                file_output.write_all(&buffer[..n])?;
+                offset += n;
+            }
+        }
+
+        Ok(0)
+    }
+}

um_cli/src/cmd/qmc1.rs

@@ -5,7 +5,7 @@ use std::fs::File;
 use std::io::{Read, Write};
 use std::path::PathBuf;
 
-/// Decrypt a QMCv1 file
+/// Decrypt a QMCv1 file (QQMusic)
 #[derive(Args)]
 pub struct ArgsQMCv1 {
     /// Path to output file, e.g. /export/Music/song.flac

um_cli/src/cmd/qmc2.rs

@@ -8,7 +8,7 @@ use std::path::PathBuf;
 use umc_qmc::{footer, QMCv2Cipher};
 use umc_utils::base64;
 
-/// Decrypt a QMCv2 file
+/// Decrypt a QMCv2 file (QQMusic)
 #[derive(Args)]
 pub struct ArgsQMCv2 {
     /// Path to output file, e.g. /export/Music/song.flac

um_cli/src/main.rs

@@ -29,6 +29,7 @@ fn run_command(cli: &Cli) -> Result<i32> {
     match &cli.command {
         Some(Commands::QMCv1(cmd)) => cmd.run(&cli),
         Some(Commands::QMCv2(cmd)) => cmd.run(&cli),
+        Some(Commands::NCM(cmd)) => cmd.run(&cli),
         None => {
             // https://github.com/clap-rs/clap/issues/3857#issuecomment-1161796261
             todo!("implement a sensible default command, similar to um/cli");