From 566783c647fc85f1cfbe214e932aeb664e1f440d Mon Sep 17 00:00:00 2001
From: jakka <jakka@jakka.su>
Date: Thu, 17 Jul 2025 11:36:00 +0300
Subject: minor code rewrite and optimizations

---
 src/flac.rs | 46 +++++++++++++++++++++-------------------------
 1 file changed, 21 insertions(+), 25 deletions(-)

(limited to 'src')

diff --git a/src/flac.rs b/src/flac.rs
index 4d7c632..754d9c5 100644
--- a/src/flac.rs
+++ b/src/flac.rs
@@ -12,26 +12,24 @@ use std::{
 
 pub const CURRENT_VENDOR: &str = "reference libFLAC 1.5.0 20250211";
 
+const BADTAGS: [&str; 2] = ["encoded by", "encoder"];
+
 fn write_tags(filename: impl AsRef<Path>) -> Result<()> {
     let tags = Tag::read_from_path(&filename)?;
     let temp_name = filename.as_ref().with_extension("tmp");
     let mut output = Tag::read_from_path(&temp_name)?;
 
-    if let Some(streaminfo) = tags.get_streaminfo() {
-        output.set_streaminfo(streaminfo.clone());
-    }
-
     for block in tags.blocks() {
         match block {
-            Block::VorbisComment(comment) => {
-                for (key, val) in comment.comments.clone() {
-                    if key.to_lowercase() != "encoder" || key.to_lowercase() != "encoded by" {
-                        output.set_vorbis(key, val);
+            Block::VorbisComment(block) => {
+                for (key, val) in block.comments.iter() {
+                    if !BADTAGS.contains(&key.to_lowercase().as_str()) {
+                        output.set_vorbis(key, val.to_owned());
                     }
                 }
             }
-            Block::StreamInfo(_) | Block::Padding(_) => {}
-            _ => output.push_block(block.clone()),
+            Block::Padding(_) => {}
+            _ => output.push_block(block.to_owned()),
         }
     }
 
@@ -68,31 +66,23 @@ fn encode_file(filename: impl AsRef<Path>, handler: Arc<AtomicBool>) -> Result<b
 
     let mut frame_reader = decoder.blocks();
     let mut buffer = Vec::new();
-    let mut block_buffer =
-        Vec::with_capacity(streaminfo.max_block_size as usize * num_channels as usize);
-
-    loop {
-        if !handler.load(Ordering::SeqCst) {
-            let _ = encoder.finish();
-            std::fs::remove_file(temp_name)?;
-            return Ok(true);
-        }
+    let mut block_buffer = Vec::with_capacity(streaminfo.max_block_size as usize * num_channels);
+
+    while handler.load(Ordering::SeqCst) {
         match frame_reader.read_next_or_eof(block_buffer) {
             Ok(Some(block)) => {
-                for sample in 0..(block.len() / block.channels()) {
-                    for ch in 0..block.channels() {
-                        buffer.push(block.sample(ch, sample));
-                    }
+                for ch in 0..block.channels() {
+                    buffer.push(block.channel(ch));
                 }
 
-                if let Err(_) = encoder.process_interleaved(&buffer, block.len() / block.channels())
-                {
+                if encoder.process(&buffer).is_err() {
                     return Err(anyhow!(
                         "Error while processing samples:\t{:?}",
                         encoder.state()
                     ));
                 };
                 buffer.clear();
+                buffer = buffer.into_iter().map(|_| unreachable!()).collect();
                 block_buffer = block.into_buffer();
             }
             Ok(None) => break,
@@ -100,6 +90,12 @@ fn encode_file(filename: impl AsRef<Path>, handler: Arc<AtomicBool>) -> Result<b
         }
     }
 
+    if !handler.load(Ordering::SeqCst) {
+        let _ = encoder.finish();
+        std::fs::remove_file(temp_name)?;
+        return Ok(true);
+    }
+
     if let Err(enc) = encoder.finish() {
         return Err(anyhow!("Encoding failed:\t{:?}", enc.state()));
     }
-- 
cgit v1.3.1