Fix broken loop in streaming mode, code cleanup

dividebysandwich · dividebysandwich · commit baeb15abc8ac · 2025-11-07T21:42:57.000+01:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "rusty-pipes"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2024"
 
 [dependencies]
diff --git a/src/audio.rs b/src/audio.rs
@@ -17,7 +17,7 @@ use std::mem;
 
 use crate::app::{ActiveNote, AppMessage};
 use crate::organ::Organ;
-use crate::wav::{parse_wav_metadata, WavSampleReader};
+use crate::wav::{parse_wav_metadata, WavSampleReader, parse_smpl_chunk};
 use crate::wav_converter::SampleMetadata;
 
 const AUDIO_SAMPLE_RATE: u32 = 48000;
@@ -132,17 +132,24 @@ impl Voice {
                         let mut reader = BufReader::new(file);
 
                         // Assuming parse_wav_metadata is in a shared wav_reader mod
-                        let (fmt, loop_info_from_file, data_start, data_size) = 
-                            parse_wav_metadata(&mut reader)
+                        let (fmt, other_chunks, data_start, data_size) = 
+                            parse_wav_metadata(&mut reader, &path_buf)
                             .map_err(|e| anyhow!("[LoaderThread] Failed to parse WAV metadata for {:?}: {}", path_buf.clone(), e))?;
-                        
+
                         if fmt.sample_rate != sample_rate {
                             return Err(anyhow!(
                                 "[LoaderThread] File {:?} has wrong sample rate: {} (expected {}). Please re-process samples.",
                                 path_buf, fmt.sample_rate, sample_rate
                             ));
                         }
                         
+                        let mut loop_info_from_file = None;
+                        for chunk in other_chunks {
+                            if &chunk.id == b"smpl" {
+                                loop_info_from_file = parse_smpl_chunk(&chunk.data);
+                                break;
+                            }
+                        }
                         // Set metadata from file
                         loop_info = if is_attack_sample_clone { loop_info_from_file } else { None };
                         input_channels = fmt.num_channels as usize;
@@ -156,7 +163,7 @@ impl Voice {
                             log::debug!("[LoaderThread] Reading {:?} into memory for looping (streaming mode).", path_str);
                             samples_in_memory = decoder.collect();
                             use_memory_reader = true;
-                            source_is_finished = true;
+                            source_is_finished = false;
                         } else {
                             source = Some(Box::new(decoder));
                             source_is_finished = false;
diff --git a/src/wav.rs b/src/wav.rs
@@ -1,5 +1,6 @@
 use anyhow::{anyhow, Result};
 use std::io::{Seek, SeekFrom, Read, Cursor};
+use std::path::Path;
 use byteorder::{ReadBytesExt as OtherReadBytesExt, LittleEndian};
 
 const I16_MAX_F: f32 = 32768.0;  // 2^15
@@ -14,99 +15,70 @@ pub struct WavFmt {
     pub sample_rate: u32,
     pub bits_per_sample: u16,
 }
-
-impl WavFmt {
-    /// Parses the 'fmt ' chunk data.
-    fn parse(data: &[u8]) -> Result<Self> {
-        if data.len() < 16 {
-            return Err(anyhow!("'fmt ' chunk is too small: {} bytes", data.len()));
-        }
-        let mut cursor = Cursor::new(data);
-        let audio_format = cursor.read_u16::<LittleEndian>()?;
-        let num_channels = cursor.read_u16::<LittleEndian>()?;
-        let sample_rate = cursor.read_u32::<LittleEndian>()?;
-        let _byte_rate = cursor.read_u32::<LittleEndian>()?; // Not needed
-        let _block_align = cursor.read_u16::<LittleEndian>()?; // Not needed
-        let bits_per_sample = cursor.read_u16::<LittleEndian>()?;
-
-        if audio_format != 1 && audio_format != 3 {
-            return Err(anyhow!("Unsupported audio format: {} (only 1=PCM or 3=Float)", audio_format));
-        }
-        
-        log::trace!("[WavFmt] Parsed: {}ch, {}Hz, {}b, format={}", num_channels, sample_rate, bits_per_sample, audio_format);
-
-        Ok(Self {
-            audio_format,
-            num_channels,
-            sample_rate,
-            bits_per_sample,
-        })
-    }
+/// A struct to hold metadata chunks (like 'smpl') that we want to preserve.
+#[derive(Debug, Clone)]
+pub struct OtherChunk {
+    pub id: [u8; 4],
+    pub data: Vec<u8>,
 }
 
 /// Parses all necessary metadata from a WAV file in one pass.
 /// Returns (format, loop_info, data_chunk_start_pos, data_chunk_size)
 pub fn parse_wav_metadata<R: Read + Seek>(
-    reader: &mut R
-) -> Result<(WavFmt, Option<(u32, u32)>, u64, u32)> {
+    reader: &mut R,
+    full_path_for_logs: &Path,
+) -> Result<(WavFmt, Vec<OtherChunk>, u64, u32)> {
     let mut riff_header = [0; 4];
     reader.read_exact(&mut riff_header)?;
-    if &riff_header != b"RIFF" {
-        return Err(anyhow!("Not a RIFF file"));
-    }
+    if &riff_header != b"RIFF" { return Err(anyhow!("Not a RIFF file: {:?}", full_path_for_logs)); }
     let _file_size = reader.read_u32::<LittleEndian>()?;
     let mut wave_header = [0; 4];
     reader.read_exact(&mut wave_header)?;
-    if &wave_header != b"WAVE" {
-        return Err(anyhow!("Not a WAVE file"));
-    }
+    if &wave_header != b"WAVE" { return Err(anyhow!("Not a WAVE file: {:?}", full_path_for_logs)); }
 
-    let mut fmt: Option<WavFmt> = None;
-    let mut loop_info: Option<(u32, u32)> = None;
-    let mut data_info: Option<(u64, u32)> = None; // (start_pos, size_in_bytes)
+    let mut format_chunk: Option<WavFmt> = None;
+    let mut data_chunk_info: Option<(u64, u32)> = None; // (offset, size)
+    let mut other_chunks: Vec<OtherChunk> = Vec::new();
 
-    'chunk_loop: while let Ok(chunk_id) = reader.read_u32::<LittleEndian>().map(|id| id.to_le_bytes()) {
+    while let Ok(chunk_id) = reader.read_u32::<LittleEndian>().map(|id| id.to_le_bytes()) {
         let chunk_size = reader.read_u32::<LittleEndian>()?;
         let chunk_data_start_pos = reader.stream_position()?;
         let next_chunk_aligned_pos =
             chunk_data_start_pos + (chunk_size as u64 + (chunk_size % 2) as u64);
 
         match &chunk_id {
             b"fmt " => {
-                let mut chunk_data = vec![0; chunk_size as usize];
-                reader.read_exact(&mut chunk_data)?;
-                fmt = Some(WavFmt::parse(&chunk_data)?);
-            }
-            b"smpl" => {
-                let mut chunk_data = vec![0; chunk_size as usize];
-                reader.read_exact(&mut chunk_data)?;
-                loop_info = parse_smpl_chunk(&chunk_data);
+                let mut fmt_data = vec![0; chunk_size as usize];
+                reader.read_exact(&mut fmt_data)?;
+                let mut cursor = Cursor::new(fmt_data);
+                format_chunk = Some(WavFmt {
+                    audio_format: cursor.read_u16::<LittleEndian>()?,
+                    num_channels: cursor.read_u16::<LittleEndian>()?,
+                    sample_rate: cursor.read_u32::<LittleEndian>()?,
+                    bits_per_sample: {
+                        cursor.seek(SeekFrom::Start(14))?;
+                        cursor.read_u16::<LittleEndian>()?
+                    },
+                });
             }
             b"data" => {
-                // Found data, store its position and size.
-                data_info = Some((chunk_data_start_pos, chunk_size));
-                
-                // We MUST break here. Any 'smpl' chunk *must* come before 'data'.
-                // If it comes after, it's a non-standard file and we won't find it.
-                // This matches the behavior of the original parser.
-                break 'chunk_loop;
+                data_chunk_info = Some((chunk_data_start_pos, chunk_size));
             }
             _ => {
-                // Other chunk, skip it
+                let mut chunk_data = vec![0; chunk_size as usize];
+                reader.read_exact(&mut chunk_data)?;
+                other_chunks.push(OtherChunk { id: chunk_id, data: chunk_data });
             }
         }
-        
-        // Seek to the *start* of the next chunk
         if reader.seek(SeekFrom::Start(next_chunk_aligned_pos)).is_err() {
-            // End of file, break loop
-            break 'chunk_loop;
+            break; // Reached end of file
         }
     }
+    
+    let format = format_chunk.ok_or_else(|| anyhow!("File has no 'fmt ' chunk: {:?}", full_path_for_logs))?;
+    let (data_offset, data_size) = data_chunk_info.ok_or_else(|| anyhow!("File has no 'data' chunk: {:?}", full_path_for_logs))?;
 
-    let fmt = fmt.ok_or_else(|| anyhow!("'fmt ' chunk not found"))?;
-    let (data_start, data_size) = data_info.ok_or_else(|| anyhow!("'data' chunk not found"))?;
-
-    Ok((fmt, loop_info, data_start, data_size))
+    Ok((format, other_chunks, data_offset, data_size))
 }
 
 
diff --git a/src/wav_converter.rs b/src/wav_converter.rs
@@ -5,29 +5,13 @@ use std::io::{BufReader, BufWriter, Read, Seek, SeekFrom, Write, Cursor};
 use std::path::{Path, PathBuf};
 use rubato::{Resampler, SincFixedIn, SincInterpolationType, SincInterpolationParameters, WindowFunction};
 
-use crate::wav::parse_smpl_chunk;
+use crate::wav::{parse_smpl_chunk, WavFmt, OtherChunk};
 
 const TARGET_SAMPLE_RATE: u32 = 48000;
 const I16_MAX_F: f32 = 32768.0;  // 2^15
 const I24_MAX_F: f32 = 8388608.0; // 2^23
 const I32_MAX_F: f32 = 2147483648.0; // 2^31
 
-/// A simple struct to hold the format info we care about.
-#[derive(Debug, Clone, Copy)]
-pub struct WavFormat {
-    pub audio_format: u16,
-    pub channel_count: u16,
-    pub sampling_rate: u32,
-    pub bits_per_sample: u16,
-}
-
-/// A struct to hold metadata chunks (like 'smpl') that we want to preserve.
-#[derive(Debug, Clone)]
-pub struct OtherChunk {
-    pub id: [u8; 4],
-    pub data: Vec<u8>,
-}
-
 #[derive(Debug)]
 pub struct SampleMetadata {
     pub loop_info: Option<(u32, u32)>,
@@ -47,12 +31,12 @@ fn read_i24<R: Read>(reader: &mut R) -> std::io::Result<i32> {
 /// Helper to read all audio data from a reader into f32 waves
 fn read_f32_waves<R: Read>(
     mut reader: R, 
-    format: WavFormat, 
+    format: WavFmt,
     data_size: u32
 ) -> Result<Vec<Vec<f32>>> {
     let bytes_per_sample = (format.bits_per_sample / 8) as u32;
-    let num_frames = data_size / (bytes_per_sample * format.channel_count as u32);
-    let num_channels = format.channel_count as usize;
+    let num_frames = data_size / (bytes_per_sample * format.num_channels as u32);
+    let num_channels = format.num_channels as usize;
     let mut output_waves = vec![Vec::with_capacity(num_frames as usize); num_channels];
     
     for _ in 0..num_frames {
@@ -117,7 +101,7 @@ fn write_f32_waves_to_bytes(
 pub fn parse_wav_metadata<R: Read + Seek>(
     reader: &mut R,
     full_path_for_logs: &Path,
-) -> Result<(WavFormat, Vec<OtherChunk>, u64, u32)> {
+) -> Result<(WavFmt, Vec<OtherChunk>, u64, u32)> {
     let mut riff_header = [0; 4];
     reader.read_exact(&mut riff_header)?;
     if &riff_header != b"RIFF" { return Err(anyhow!("Not a RIFF file: {:?}", full_path_for_logs)); }
@@ -126,7 +110,7 @@ pub fn parse_wav_metadata<R: Read + Seek>(
     reader.read_exact(&mut wave_header)?;
     if &wave_header != b"WAVE" { return Err(anyhow!("Not a WAVE file: {:?}", full_path_for_logs)); }
 
-    let mut format_chunk: Option<WavFormat> = None;
+    let mut format_chunk: Option<WavFmt> = None;
     let mut data_chunk_info: Option<(u64, u32)> = None; // (offset, size)
     let mut other_chunks: Vec<OtherChunk> = Vec::new();
 
@@ -141,10 +125,10 @@ pub fn parse_wav_metadata<R: Read + Seek>(
                 let mut fmt_data = vec![0; chunk_size as usize];
                 reader.read_exact(&mut fmt_data)?;
                 let mut cursor = Cursor::new(fmt_data);
-                format_chunk = Some(WavFormat {
+                format_chunk = Some(WavFmt {
                     audio_format: cursor.read_u16::<LittleEndian>()?,
-                    channel_count: cursor.read_u16::<LittleEndian>()?,
-                    sampling_rate: cursor.read_u32::<LittleEndian>()?,
+                    num_channels: cursor.read_u16::<LittleEndian>()?,
+                    sample_rate: cursor.read_u32::<LittleEndian>()?,
                     bits_per_sample: {
                         cursor.seek(SeekFrom::Start(14))?;
                         cursor.read_u16::<LittleEndian>()?
@@ -181,10 +165,10 @@ pub fn load_sample_as_f32(path: &Path) -> Result<(Vec<f32>, SampleMetadata)> {
         parse_wav_metadata(&mut reader, path)?;
 
     // Sanity check
-    if format.sampling_rate != TARGET_SAMPLE_RATE {
+    if format.sample_rate != TARGET_SAMPLE_RATE {
         return Err(anyhow!(
             "Attempted to cache non-processed file: {:?} (Rate: {}Hz)",
-            path, format.sampling_rate
+            path, format.sample_rate
         ));
     }
 
@@ -199,7 +183,7 @@ pub fn load_sample_as_f32(path: &Path) -> Result<(Vec<f32>, SampleMetadata)> {
     
     let metadata = SampleMetadata {
         loop_info,
-        channel_count: format.channel_count,
+        channel_count: format.num_channels,
     };
 
     reader.seek(SeekFrom::Start(data_offset))?;
@@ -248,7 +232,7 @@ pub fn process_sample_file(
     let target_sample_rate = TARGET_SAMPLE_RATE;
     let target_is_float = format.audio_format == 3 && !convert_to_16_bit;
 
-    let needs_resample = format.sampling_rate != target_sample_rate || pitch_tuning_cents != 0.0;
+    let needs_resample = format.sample_rate != target_sample_rate || pitch_tuning_cents != 0.0;
     let needs_bit_change = target_bits != format.bits_per_sample || (format.audio_format == 3 && !target_is_float);
     
     // Early exit
@@ -267,7 +251,7 @@ pub fn process_sample_file(
     if pitch_tuning_cents != 0.0 {
         suffixes.push(format!("p{:+.1}", pitch_tuning_cents));
     }
-    if format.sampling_rate != target_sample_rate {
+    if format.sample_rate != target_sample_rate {
         suffixes.push(format!("{}k", target_sample_rate / 1000));
     }
 
@@ -294,7 +278,7 @@ pub fn process_sample_file(
     // Resample if needed
     let output_waves = if needs_resample {
         let pitch_factor = 2.0f64.powf(pitch_tuning_cents as f64 / 1200.0);
-        let effective_input_rate = format.sampling_rate as f64 / pitch_factor;
+        let effective_input_rate = format.sample_rate as f64 / pitch_factor;
         let resample_ratio = target_sample_rate as f64 / effective_input_rate;
 
         // Use high-quality Sinc resampler for offline processing
@@ -328,7 +312,7 @@ pub fn process_sample_file(
     let new_data_size = final_data_chunk.len() as u32;
     let new_bits_per_sample: u16 = target_bits;
     let new_audio_format = if target_is_float { 3 } else { 1 };
-    let new_block_align = format.channel_count * (new_bits_per_sample / 8);
+    let new_block_align = format.num_channels * (new_bits_per_sample / 8);
     let new_byte_rate = target_sample_rate * new_block_align as u32; // Use target rate
     
     let mut other_chunks_total_size: u32 = 0;
@@ -348,7 +332,7 @@ pub fn process_sample_file(
     writer.write_all(b"fmt ")?;
     writer.write_u32::<LittleEndian>(16)?; // chunk size (minimal PCM)
     writer.write_u16::<LittleEndian>(new_audio_format)?;
-    writer.write_u16::<LittleEndian>(format.channel_count)?;
+    writer.write_u16::<LittleEndian>(format.num_channels)?;
     writer.write_u32::<LittleEndian>(target_sample_rate)?; // <-- Write new rate
     writer.write_u32::<LittleEndian>(new_byte_rate)?;
     writer.write_u16::<LittleEndian>(new_block_align)?;
