[llm] Beef up wav loader to read audio format 3 (float format)

This PR adds test coverage for WAV files using audio format 3 (IEEE float format), which allows direct reading of float values without normalization. The existing `**wav_loader.h**` implementation already supports this format (lines 179-185), but there was no test coverage for this code path.

**Test additions in `**test_wav_loader.cpp**`:**

1.  Added `append_float()` helper function to serialize float values into byte arrays
2.  Added `make_float_wav_bytes()` helper function to generate WAV files with audio format 3 (IEEE float)
3.  Added `LoadAudioDataFloatFormatReadsDirectly` test case that verifies:
    *   WAV header correctly identifies audio format as 3
    *   Float samples are read directly without normalization
    *   Output float values match the input exactly

The new test case `LoadAudioDataFloatFormatReadsDirectly` validates that:

*   A WAV file with audio format 3 (IEEE float, 32-bit) is correctly parsed
*   The audio format is detected as 3 in the header
*   Float values [0.0f, 0.5f, -0.5f, 1.0f, -1.0f] are read directly without normalization
*   All float values match exactly using `EXPECT_FLOAT_EQ`

Run the test with:

`buck2 test //extension/llm/runner/test:test_wav_loader`

The WAV loader already has logic to handle IEEE float format (audio format 3) differently from PCM integer formats, but this code path was not covered by tests. This test ensures the float format path works correctly and prevents regressions.

Author: larryliu0820

extension/llm/runner/test/test_wav_loader.cpp

@@ -51,6 +51,13 @@ void append_le32(std::vector<uint8_t>& out, uint32_t value) {
   out.push_back(static_cast<uint8_t>((value >> 24) & 0xFF));
 }
 
+void append_float(std::vector<uint8_t>& out, float value) {
+  const uint8_t* bytes = reinterpret_cast<const uint8_t*>(&value);
+  for (size_t i = 0; i < sizeof(float); ++i) {
+    out.push_back(bytes[i]);
+  }
+}
+
 std::vector<uint8_t> make_pcm_wav_bytes(
     int bits_per_sample,
     const std::vector<int32_t>& samples,
@@ -91,6 +98,41 @@ std::vector<uint8_t> make_pcm_wav_bytes(
   return bytes;
 }
 
+std::vector<uint8_t> make_float_wav_bytes(
+    const std::vector<float>& samples,
+    uint16_t num_channels = 1,
+    uint32_t sample_rate = 16000) {
+  const size_t bytes_per_sample = sizeof(float);
+  const uint32_t subchunk2_size =
+      static_cast<uint32_t>(samples.size() * bytes_per_sample);
+  const uint32_t byte_rate = sample_rate * num_channels * bytes_per_sample;
+  const uint16_t block_align = num_channels * bytes_per_sample;
+  const uint32_t chunk_size = 36 + subchunk2_size;
+
+  std::vector<uint8_t> bytes;
+  bytes.reserve(44 + subchunk2_size);
+
+  append_bytes(bytes, "RIFF");
+  append_le32(bytes, chunk_size);
+  append_bytes(bytes, "WAVE");
+  append_bytes(bytes, "fmt ");
+  append_le32(bytes, 16);
+  append_le16(bytes, 3); // AudioFormat IEEE Float
+  append_le16(bytes, num_channels);
+  append_le32(bytes, sample_rate);
+  append_le32(bytes, byte_rate);
+  append_le16(bytes, block_align);
+  append_le16(bytes, 32); // bits per sample
+  append_bytes(bytes, "data");
+  append_le32(bytes, subchunk2_size);
+
+  for (float sample : samples) {
+    append_float(bytes, sample);
+  }
+
+  return bytes;
+}
+
 } // namespace
 
 TEST_F(WavLoaderTest, LoadHeaderParsesPcmMetadata) {
@@ -153,3 +195,21 @@ TEST_F(WavLoaderTest, LoadHeaderReturnsNullWhenMagicMissing) {
   std::unique_ptr<WavHeader> header = load_wav_header(file.path());
   EXPECT_EQ(header, nullptr);
 }
+
+TEST_F(WavLoaderTest, LoadAudioDataFloatFormatReadsDirectly) {
+  const std::vector<float> samples = {0.0f, 0.5f, -0.5f, 1.0f, -1.0f};
+  const std::vector<uint8_t> wav_bytes = make_float_wav_bytes(samples);
+  TempFile file(wav_bytes.data(), wav_bytes.size());
+
+  std::unique_ptr<WavHeader> header = load_wav_header(file.path());
+  ASSERT_NE(header, nullptr);
+  EXPECT_EQ(header->AudioFormat, 3);
+  EXPECT_EQ(header->bitsPerSample, 32);
+
+  std::vector<float> audio = load_wav_audio_data(file.path());
+  ASSERT_EQ(audio.size(), samples.size());
+
+  for (size_t i = 0; i < samples.size(); ++i) {
+    EXPECT_FLOAT_EQ(audio[i], samples[i]);
+  }
+}

extension/llm/runner/wav_loader.h

@@ -168,18 +168,29 @@ inline std::vector<float> load_wav_audio_data(const std::string& fp) {
   size_t data_offset = header->dataOffset;
   size_t data_size = header->Subchunk2Size;
   int bits_per_sample = header->bitsPerSample;
+  int audio_format = header->AudioFormat;
 
   std::vector<float> audio_data;
 
   if (bits_per_sample == 32) {
     size_t num_samples = data_size / 4;
     audio_data.resize(num_samples);
-    const int32_t* input_buffer =
-        reinterpret_cast<const int32_t*>(data + data_offset);
 
-    for (size_t i = 0; i < num_samples; ++i) {
-      audio_data[i] = static_cast<float>(
-          static_cast<double>(input_buffer[i]) * kOneOverIntMax);
+    if (audio_format == 3) {
+      // IEEE float format - read directly as floats
+      const float* input_buffer =
+          reinterpret_cast<const float*>(data + data_offset);
+      for (size_t i = 0; i < num_samples; ++i) {
+        audio_data[i] = input_buffer[i];
+      }
+    } else {
+      // PCM integer format - normalize from int32
+      const int32_t* input_buffer =
+          reinterpret_cast<const int32_t*>(data + data_offset);
+      for (size_t i = 0; i < num_samples; ++i) {
+        audio_data[i] = static_cast<float>(
+            static_cast<double>(input_buffer[i]) * kOneOverIntMax);
+      }
     }
   } else if (bits_per_sample == 16) {
     size_t num_samples = data_size / 2;