cridecoder 0.2.1__tar.gz → 0.2.2__tar.gz

{cridecoder-0.2.1 → cridecoder-0.2.2}/.github/workflows/release-python.yml

@@ -58,7 +58,7 @@ jobs:
           VERSION="${GITHUB_REF_NAME#v}"
           sed -i '' "1,/^version = .*/{s/^version = .*/version = \"${VERSION}\"/;}" Cargo.toml
           sed -i '' "s/^version = .*/version = \"${VERSION}\"/" pyproject.toml
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
         with:
           python-version: |
             3.9
@@ -95,7 +95,7 @@ jobs:
           VERSION="${GITHUB_REF_NAME#v}"
           sed -i "0,/^version = .*/s//version = \"${VERSION}\"/" Cargo.toml
           sed -i "s/^version = .*/version = \"${VERSION}\"/" pyproject.toml
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
         with:
           python-version: |
             3.9

{cridecoder-0.2.1 → cridecoder-0.2.2}/Cargo.lock

@@ -28,7 +28,7 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "cridecoder"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "byteorder",
  "encoding_rs",
@@ -204,9 +204,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.28.2"
+version = "0.28.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf85e27e86080aafd5a22eae58a162e133a589551542b3e5cee4beb27e54f8e1"
+checksum = "91fd8e38a3b50ed1167fb981cd6fd60147e091784c427b8f7183a7ee32c31c12"
 dependencies = [
  "libc",
  "once_cell",
@@ -218,18 +218,18 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.28.2"
+version = "0.28.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bf94ee265674bf76c09fa430b0e99c26e319c945d96ca0d5a8215f31bf81cf7"
+checksum = "e368e7ddfdeb98c9bca7f8383be1648fd84ab466bf2bc015e94008db6d35611e"
 dependencies = [
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.28.2"
+version = "0.28.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "491aa5fc66d8059dd44a75f4580a2962c1862a1c2945359db36f6c2818b748dc"
+checksum = "7f29e10af80b1f7ccaf7f69eace800a03ecd13e883acfacc1e5d0988605f651e"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -237,9 +237,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.28.2"
+version = "0.28.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5d671734e9d7a43449f8480f8b38115df67bef8d21f76837fa75ee7aaa5e52e"
+checksum = "df6e520eff47c45997d2fc7dd8214b25dd1310918bbb2642156ef66a67f29813"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -249,9 +249,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.28.2"
+version = "0.28.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22faaa1ce6c430a1f71658760497291065e6450d7b5dc2bcf254d49f66ee700a"
+checksum = "c4cdc218d835738f81c2338f822078af45b4afdf8b2e33cbb5916f108b813acb"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -326,9 +326,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.149"
+version = "1.0.150"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9"
 dependencies = [
  "itoa",
  "memchr",

{cridecoder-0.2.1 → cridecoder-0.2.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cridecoder"
-version = "0.2.1"
+version = "0.2.2"
 edition = "2021"
 description = "CRI codec library for ACB/AWB, HCA audio, and USM video extraction"
 license = "MIT"
@@ -10,7 +10,18 @@ homepage = "https://github.com/Team-Haruki/cridecoder"
 readme = "README.md"
 keywords = ["cri", "hca", "acb", "usm", "audio"]
 categories = ["multimedia::audio", "multimedia::video", "parser-implementations"]
-exclude = ["*.acb", "*.usm", "*.hca", "*.wav", "*.m2v", "test_output_*"]
+exclude = [
+    "*.acb",
+    "*.usm",
+    "*.hca",
+    "*.wav",
+    "*.m2v",
+    "test_output_*",
+    ".DS_Store",
+    ".idea/*",
+    "Cargo.toml.orig",
+    "tests/__pycache__/*",
+]
 
 [lib]
 crate-type = ["cdylib", "rlib"]

{cridecoder-0.2.1 → cridecoder-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cridecoder
-Version: 0.2.1
+Version: 0.2.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{cridecoder-0.2.1 → cridecoder-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "cridecoder"
-version = "0.2.1"
+version = "0.2.2"
 description = "CRI codec library for ACB/AWB, HCA audio, and USM video extraction"
 readme = "README.md"
 license = { text = "MIT" }
@@ -23,4 +23,3 @@ free-threaded = true
 
 [tool.maturin]
 features = ["python"]
-include = [{ path = "cridecoder.pyi", format = "wheel" }]

{cridecoder-0.2.1 → cridecoder-0.2.2}/src/acb/afs.rs

@@ -1,6 +1,7 @@
 //! AFS2 archive parser
 
 use crate::reader::{align, Reader};
+use std::collections::HashMap;
 use std::io::{Read, Seek, SeekFrom};
 use thiserror::Error;
 
@@ -15,7 +16,7 @@ pub enum AfsError {
 }
 
 /// A file entry in an AFS2 archive
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
 pub struct AfsFileEntry {
     pub cue_id: i32,
     pub offset: u32,
@@ -27,6 +28,7 @@ pub struct AfsArchive<R: Read + Seek> {
     pub alignment: u32,
     pub subkey: u16,
     pub files: Vec<AfsFileEntry>,
+    cue_index: HashMap<i32, usize>,
     reader: Reader<R>,
 }
 
@@ -94,25 +96,30 @@ impl<R: Read + Seek> AfsArchive<R> {
             });
         }
 
+        let cue_index = files
+            .iter()
+            .enumerate()
+            .map(|(idx, file)| (file.cue_id, idx))
+            .collect();
+
         Ok(Self {
             alignment,
             subkey,
             files,
+            cue_index,
             reader: buf,
         })
     }
 
     /// Get file data for a specific cue ID
     pub fn file_data_for_cue_id(&mut self, cue_id: i32) -> Result<Vec<u8>, AfsError> {
-        for f in &self.files {
-            if f.cue_id == cue_id {
-                return self.file_data(f.clone());
-            }
+        if let Some(&idx) = self.cue_index.get(&cue_id) {
+            return self.file_data_at_index(idx);
         }
 
         // Fallback to first file if cue IDs start at 0
         if !self.files.is_empty() && self.files[0].cue_id == 0 {
-            return self.file_data(self.files[0].clone());
+            return self.file_data_at_index(0);
         }
 
         Err(AfsError::CueNotFound(cue_id))
@@ -120,6 +127,15 @@ impl<R: Read + Seek> AfsArchive<R> {
 
     /// Get file data for an entry
     pub fn file_data(&mut self, entry: AfsFileEntry) -> Result<Vec<u8>, AfsError> {
+        self.file_data_by_entry(&entry)
+    }
+
+    fn file_data_at_index(&mut self, index: usize) -> Result<Vec<u8>, AfsError> {
+        let entry = self.files[index];
+        self.file_data_by_entry(&entry)
+    }
+
+    fn file_data_by_entry(&mut self, entry: &AfsFileEntry) -> Result<Vec<u8>, AfsError> {
         Ok(self
             .reader
             .read_bytes_at(entry.size as usize, entry.offset as u64)?)

{cridecoder-0.2.1 → cridecoder-0.2.2}/src/acb/extractor.rs

@@ -23,14 +23,6 @@ pub enum ExtractError {
     InvalidAcb,
 }
 
-/// Audio track data extracted from an ACB/AWB container.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ExtractedAcbTrack {
-    pub name: String,
-    pub extension: String,
-    pub data: Vec<u8>,
-}
-
 /// Extract all audio files from an ACB file
 pub fn extract_acb<R: Read + Seek>(
     acb_file: R,
@@ -52,21 +44,6 @@ pub fn extract_acb<R: Read + Seek>(
     )
 }
 
-/// Extract all audio tracks from an ACB reader into memory.
-pub fn extract_acb_to_memory<R: Read + Seek>(
-    acb_file: R,
-    acb_file_path: Option<&Path>,
-) -> Result<Vec<ExtractedAcbTrack>, ExtractError> {
-    let utf = UtfTable::new(acb_file)?;
-
-    let track_list = TrackList::new(&utf)?;
-
-    let mut embedded_awb = load_embedded_awb(&utf.rows[0]);
-    let mut external_awbs = load_external_awbs(&utf.rows[0], acb_file_path);
-
-    extract_all_tracks_to_memory(&track_list, &mut embedded_awb, &mut external_awbs)
-}
-
 fn load_embedded_awb(
     row: &std::collections::HashMap<String, crate::acb::utf::Value>,
 ) -> Option<AfsArchive<Cursor<Vec<u8>>>> {
@@ -143,22 +120,6 @@ fn extract_all_tracks(
     Ok(outputs)
 }
 
-fn extract_all_tracks_to_memory(
-    track_list: &TrackList,
-    embedded_awb: &mut Option<AfsArchive<Cursor<Vec<u8>>>>,
-    external_awbs: &mut [AfsArchive<Cursor<Vec<u8>>>],
-) -> Result<Vec<ExtractedAcbTrack>, ExtractError> {
-    let mut outputs = Vec::new();
-
-    for track in &track_list.tracks {
-        if let Some(output) = extract_single_track_to_memory(track, embedded_awb, external_awbs)? {
-            outputs.push(output);
-        }
-    }
-
-    Ok(outputs)
-}
-
 fn extract_single_track(
     track: &Track,
     target_dir: &Path,
@@ -185,31 +146,6 @@ fn extract_single_track(
     Ok(Some(output_path.to_string_lossy().into_owned()))
 }
 
-fn extract_single_track_to_memory(
-    track: &Track,
-    embedded_awb: &mut Option<AfsArchive<Cursor<Vec<u8>>>>,
-    external_awbs: &mut [AfsArchive<Cursor<Vec<u8>>>],
-) -> Result<Option<ExtractedAcbTrack>, ExtractError> {
-    let ext = wave_type_extension(track.enc_type);
-    let extension = if ext.is_empty() {
-        track.enc_type.to_string()
-    } else {
-        ext.trim_start_matches('.').to_string()
-    };
-
-    let data = get_track_data(track, embedded_awb, external_awbs)?;
-    let data = match data {
-        Some(d) => d,
-        None => return Ok(None),
-    };
-
-    Ok(Some(ExtractedAcbTrack {
-        name: track.name.clone(),
-        extension,
-        data,
-    }))
-}
-
 fn get_track_data(
     track: &Track,
     embedded_awb: &mut Option<AfsArchive<Cursor<Vec<u8>>>>,

{cridecoder-0.2.1 → cridecoder-0.2.2}/src/acb.rs

@@ -12,6 +12,6 @@ pub use builder::{
     AcbBuilder, AfsArchiveBuilder, BuilderError, ColumnDef, TrackInput, UtfTableBuilder,
 };
 pub use consts::*;
-pub use extractor::{extract_acb, extract_acb_from_file, extract_acb_to_memory, ExtractedAcbTrack};
+pub use extractor::{extract_acb, extract_acb_from_file};
 pub use track::{Track, TrackList};
 pub use utf::{UtfHeader, UtfTable, Value};

{cridecoder-0.2.1 → cridecoder-0.2.2}/src/hca/decoder.rs

@@ -24,7 +24,6 @@ pub const HCA_MASK: u32 = 0x7F7F7F7F;
 pub const HCA_SUBFRAMES: usize = 8;
 pub const HCA_SAMPLES_PER_SUBFRAME: usize = 128;
 pub const HCA_SAMPLES_PER_FRAME: usize = HCA_SUBFRAMES * HCA_SAMPLES_PER_SUBFRAME;
-pub const HCA_MDCT_BITS: usize = 7;
 pub const HCA_MIN_CHANNELS: u32 = 1;
 pub const HCA_MAX_CHANNELS: usize = 16;
 pub const HCA_MIN_SAMPLE_RATE: u32 = 1;
@@ -726,16 +725,36 @@ impl ClHca {
 
     /// Read decoded samples as 16-bit PCM
     pub fn read_samples_16(&self, samples: &mut [i16]) {
-        const SCALE_F: f32 = 32768.0;
-
-        let mut idx = 0;
-        for i in 0..HCA_SUBFRAMES {
-            for j in 0..HCA_SAMPLES_PER_SUBFRAME {
-                for k in 0..self.channels as usize {
-                    let f = self.channel[k].wave[i][j];
-                    let s = (f * SCALE_F) as i32;
-                    samples[idx] = s.clamp(-32768, 32767) as i16;
-                    idx += 1;
+        let channels = self.channels as usize;
+
+        match channels {
+            1 => {
+                for i in 0..HCA_SUBFRAMES {
+                    let base = i * HCA_SAMPLES_PER_SUBFRAME;
+                    for j in 0..HCA_SAMPLES_PER_SUBFRAME {
+                        samples[base + j] = pcm_f32_to_i16(self.channel[0].wave[i][j]);
+                    }
+                }
+            }
+            2 => {
+                for i in 0..HCA_SUBFRAMES {
+                    let base = i * HCA_SAMPLES_PER_SUBFRAME * 2;
+                    for j in 0..HCA_SAMPLES_PER_SUBFRAME {
+                        let idx = base + j * 2;
+                        samples[idx] = pcm_f32_to_i16(self.channel[0].wave[i][j]);
+                        samples[idx + 1] = pcm_f32_to_i16(self.channel[1].wave[i][j]);
+                    }
+                }
+            }
+            _ => {
+                let mut idx = 0;
+                for i in 0..HCA_SUBFRAMES {
+                    for j in 0..HCA_SAMPLES_PER_SUBFRAME {
+                        for k in 0..channels {
+                            samples[idx] = pcm_f32_to_i16(self.channel[k].wave[i][j]);
+                            idx += 1;
+                        }
+                    }
                 }
             }
         }
@@ -899,8 +918,10 @@ impl ClHca {
             return Err(HcaError::ChecksumFailed);
         }
 
-        // Decrypt
-        cipher_decrypt(&self.cipher_table, &mut data[..self.frame_size as usize]);
+        // Decrypt only when the file uses a non-identity cipher.
+        if self.ciph_type != 0 {
+            cipher_decrypt(&self.cipher_table, &mut data[..self.frame_size as usize]);
+        }
 
         // Re-initialize bitreader after decryption
         let mut br = BitReader::with_offset(data, 2); // Skip sync word
@@ -1113,40 +1134,54 @@ impl ClHca {
     fn dequantize_coefficients(&mut self, ch: usize, br: &mut BitReader, subframe: usize) {
         let channel = &mut self.channel[ch];
         let cc_count = channel.coded_count;
+        let spectra = &mut channel.spectra[subframe];
 
-        for i in 0..cc_count {
+        for (i, sample) in spectra.iter_mut().enumerate().take(cc_count) {
             let resolution = channel.resolution[i];
-            let bits = MAX_BIT_TABLE[resolution as usize];
-            let code = br.read(bits as usize);
-
-            let qc: f32 = if resolution > 7 {
-                // Sign-magnitude form: sign is bit 0, magnitude is bits 1+
-                let sign = if (code & 1) != 0 { -1i32 } else { 1i32 };
-                let signed_code = sign * (code >> 1) as i32;
-                if signed_code == 0 {
-                    br.set_position(br.position() - 1);
+            let qc = match resolution {
+                0 => 0.0,
+                1..=7 => {
+                    let bits = MAX_BIT_TABLE[resolution as usize];
+                    let code = br.read(bits as usize);
+                    let index = ((resolution as usize) << 4) + code as usize;
+                    let skip = READ_BIT_TABLE[index] as i32 - bits as i32;
+                    if skip > 0 {
+                        br.skip(skip as usize);
+                    } else if skip < 0 {
+                        br.set_position(br.position().saturating_sub((-skip) as usize));
+                    }
+                    READ_VAL_TABLE[index]
                 }
-                signed_code as f32
-            } else {
-                // Prefix codebooks
-                let index = ((resolution as usize) << 4) + code as usize;
-                let skip = READ_BIT_TABLE[index] as i32 - bits as i32;
-                if skip > 0 {
-                    br.skip(skip as usize);
-                } else if skip < 0 {
-                    br.set_position(br.position().saturating_sub((-skip) as usize));
+                _ => {
+                    let bits = MAX_BIT_TABLE[resolution as usize];
+                    let code = br.read(bits as usize);
+                    // Sign-magnitude form: sign is bit 0, magnitude is bits 1+
+                    let sign = if (code & 1) != 0 { -1i32 } else { 1i32 };
+                    let signed_code = sign * (code >> 1) as i32;
+                    if signed_code == 0 {
+                        br.set_position(br.position() - 1);
+                    }
+                    signed_code as f32
                 }
-                READ_VAL_TABLE[index]
             };
 
-            channel.spectra[subframe][i] = channel.gain[i] * qc;
+            *sample = channel.gain[i] * qc;
         }
 
         // Clean rest of spectra
-        channel.spectra[subframe][cc_count..HCA_SAMPLES_PER_SUBFRAME].fill(0.0);
+        spectra[cc_count..HCA_SAMPLES_PER_SUBFRAME].fill(0.0);
     }
 
     fn decode_block_transform(&mut self) {
+        if self.min_resolution > 0 && self.bands_per_hfr_group == 0 && self.stereo_band_count == 0 {
+            for subframe in 0..HCA_SUBFRAMES {
+                for ch in 0..self.channels as usize {
+                    imdct_transform(&mut self.channel[ch], subframe);
+                }
+            }
+            return;
+        }
+
         for subframe in 0..HCA_SUBFRAMES {
             // Restore missing bands
             for ch in 0..self.channels as usize {
@@ -1286,6 +1321,13 @@ impl ClHca {
     }
 }
 
+#[inline]
+fn pcm_f32_to_i16(sample: f32) -> i16 {
+    const SCALE_F: f32 = 32768.0;
+    let scaled = (sample * SCALE_F) as i32;
+    scaled.clamp(-32768, 32767) as i16
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

{cridecoder-0.2.1 → cridecoder-0.2.2}/src/hca/hca_file.rs

@@ -155,6 +155,40 @@ impl<R: Read + Seek> HcaDecoder<R> {
         Ok((&self.fbuf[start_idx..], num_samples))
     }
 
+    /// Decode a single frame into interleaved 16-bit PCM samples.
+    ///
+    /// Returns the number of sample frames written, not the number of i16
+    /// values. The caller-provided buffer must fit one full decoded HCA frame.
+    pub fn decode_frame_i16(&mut self, pcm: &mut [i16]) -> Result<usize, HcaDecoderError> {
+        let frame_len = self.info.samples_per_block * self.info.channel_count as usize;
+        if pcm.len() < frame_len {
+            return Err(HcaDecoderError::InvalidSampleRange);
+        }
+
+        self.read_packet()?;
+        self.handle.decode_block(&mut self.buf)?;
+        self.handle.read_samples_16(&mut pcm[..frame_len]);
+
+        let samples = self.info.samples_per_block as i32;
+        let mut discard = 0;
+
+        if self.current_delay > 0 {
+            if self.current_delay >= samples {
+                self.current_delay -= samples;
+                return Ok(0);
+            }
+            discard = self.current_delay;
+            self.current_delay = 0;
+        }
+
+        let start = discard as usize * self.info.channel_count as usize;
+        if start > 0 {
+            pcm.copy_within(start..frame_len, 0);
+        }
+
+        Ok((samples - discard) as usize)
+    }
+
     /// Decode the entire HCA file and return all samples
     pub fn decode_all(&mut self) -> Result<Vec<f32>, HcaDecoderError> {
         self.reset();
@@ -177,6 +211,35 @@ impl<R: Read + Seek> HcaDecoder<R> {
         Ok(all_samples)
     }
 
+    /// Decode the entire HCA file as interleaved 16-bit PCM chunks.
+    ///
+    /// The callback receives only valid samples after encoder-delay trimming.
+    /// This is useful when piping HCA directly into an audio encoder without
+    /// materializing an intermediate WAV file.
+    pub fn decode_to_pcm16_chunks<F>(&mut self, mut on_chunk: F) -> Result<(), HcaDecoderError>
+    where
+        F: FnMut(&[i16]) -> Result<(), HcaDecoderError>,
+    {
+        self.reset();
+
+        let channels = self.info.channel_count as usize;
+        let mut pcm_buf = vec![0i16; self.info.samples_per_block * channels];
+
+        loop {
+            match self.decode_frame_i16(&mut pcm_buf) {
+                Ok(0) => {}
+                Ok(sample_frames) => {
+                    let sample_count = sample_frames * channels;
+                    on_chunk(&pcm_buf[..sample_count])?;
+                }
+                Err(HcaDecoderError::Eof) => break,
+                Err(e) => return Err(e),
+            }
+        }
+
+        Ok(())
+    }
+
     /// Seek to a specific sample position
     pub fn seek(&mut self, sample_num: u32) {
         let target_sample = sample_num + self.info.encoder_delay;
@@ -309,48 +372,47 @@ impl<R: Read + Seek> HcaDecoder<R> {
 
         w.write_all(&header)?;
 
-        let mut pcm_buf =
-            vec![0i16; self.info.samples_per_block * self.info.channel_count as usize];
-
-        loop {
-            match self.read_packet() {
-                Ok(()) => {}
-                Err(HcaDecoderError::Eof) => break,
-                Err(e) => return Err(e),
-            }
-
-            self.handle.decode_block(&mut self.buf)?;
-            self.handle.read_samples_16(&mut pcm_buf);
+        let frame_len = self.info.samples_per_block * self.info.channel_count as usize;
+        let mut data_buf = vec![0u8; frame_len * 2];
 
-            let samples = self.info.samples_per_block as i32;
-            let mut discard = 0;
-
-            if self.current_delay > 0 {
-                if self.current_delay >= samples {
-                    self.current_delay -= samples;
-                    continue;
-                }
-                discard = self.current_delay;
-                self.current_delay = 0;
-            }
-
-            let start = discard as usize * self.info.channel_count as usize;
-            let end = samples as usize * self.info.channel_count as usize;
-
-            if start >= end || end > pcm_buf.len() {
+        self.decode_to_pcm16_chunks(|pcm| {
+            if pcm.len() > frame_len {
                 return Err(HcaDecoderError::InvalidSampleRange);
             }
+            write_pcm_i16_le(w, pcm, &mut data_buf)?;
+            Ok(())
+        })
+    }
+}
 
-            // Write samples as little-endian bytes
-            let mut data = vec![0u8; (end - start) * 2];
-            for (i, &sample) in pcm_buf[start..end].iter().enumerate() {
-                data[i * 2..i * 2 + 2].copy_from_slice(&sample.to_le_bytes());
-            }
-            w.write_all(&data)?;
-        }
+#[cfg(target_endian = "little")]
+fn write_pcm_i16_le<W: Write>(
+    writer: &mut W,
+    samples: &[i16],
+    _scratch: &mut [u8],
+) -> io::Result<()> {
+    let bytes = unsafe {
+        // SAFETY: i16 is a plain integer type, and on little-endian targets its
+        // in-memory representation is exactly the little-endian PCM byte order.
+        std::slice::from_raw_parts(
+            samples.as_ptr().cast::<u8>(),
+            std::mem::size_of_val(samples),
+        )
+    };
+    writer.write_all(bytes)
+}
 
-        Ok(())
+#[cfg(not(target_endian = "little"))]
+fn write_pcm_i16_le<W: Write>(
+    writer: &mut W,
+    samples: &[i16],
+    scratch: &mut [u8],
+) -> io::Result<()> {
+    let byte_len = samples.len() * 2;
+    for (chunk, &sample) in scratch[..byte_len].chunks_exact_mut(2).zip(samples) {
+        chunk.copy_from_slice(&sample.to_le_bytes());
     }
+    writer.write_all(&scratch[..byte_len])
 }
 
 fn scale_frame_score(score: i32) -> i32 {