Fix out-of-bounds read on short final chunk; harden example file read

Address two review findings:

- Slip::process_into_buffer copied `input_len`/`output_len` frames from
  the input buffer, but validate_buffers only guarantees `frames_to_read`
  frames are present. On a short final chunk (Indexing::partial_len set)
  that read past the validated region. Copy only `frames_to_read` frames;
  the remainder of the scratch is already zero-padded.

- The adjust_ratio_f64 example read samples with Read::read, which may
  return a short read and decode a corrupt trailing sample from leftover
  bytes. Use read_exact and stop on UnexpectedEof.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: HEnquist

examples/adjust_ratio_f64.rs

@@ -40,12 +40,15 @@ fn read_file<R: Read + Seek>(inbuffer: &mut R) -> Vec<f64> {
     let mut buffer = vec![0u8; BYTE_PER_SAMPLE];
     let mut data = Vec::new();
     loop {
-        let bytes_read = inbuffer.read(&mut buffer).unwrap();
-        if bytes_read == 0 {
-            break;
+        match inbuffer.read_exact(&mut buffer) {
+            Ok(()) => {
+                let value = f64::from_le_bytes(buffer.as_slice().try_into().unwrap());
+                data.push(value);
+            }
+            // A clean end of file stops the loop; a partial trailing read means a malformed file.
+            Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => break,
+            Err(e) => panic!("Error reading input file: {}", e),
         }
-        let value = f64::from_le_bytes(buffer.as_slice().try_into().unwrap());
-        data.push(value);
     }
     data
 }

src/slip.rs

@@ -413,11 +413,12 @@ where
             }
             if self.correction == 0 {
                 // No slip this chunk: read straight into the output scratch, skipping the
-                // input scratch and the redundant scratch-to-scratch copy.
+                // input scratch and the redundant scratch-to-scratch copy. Only `frames_to_read`
+                // frames are guaranteed present in `buffer_in` (see `validate_buffers`).
                 buffer_in.copy_from_channel_to_slice(
                     chan,
                     input_offset,
-                    &mut self.output_scratch[..output_len],
+                    &mut self.output_scratch[..frames_to_read],
                 );
                 // Zero pad if this is a short final chunk.
                 if frames_to_read < output_len {
@@ -426,10 +427,11 @@ where
                     }
                 }
             } else {
+                // Only `frames_to_read` frames are guaranteed present in `buffer_in`.
                 buffer_in.copy_from_channel_to_slice(
                     chan,
                     input_offset,
-                    &mut self.input_scratch[..input_len],
+                    &mut self.input_scratch[..frames_to_read],
                 );
                 // Zero pad if this is a short final chunk.
                 if frames_to_read < input_len {