Skip to content

Commit acfa561

Browse files
authored
Fix strict aliasing violations in wav_loader.h (pytorch#19480)
Differential Revision: D104470085 Pull Request resolved: pytorch#19480
1 parent 2dfe8e4 commit acfa561

2 files changed

Lines changed: 316 additions & 104 deletions

File tree

‎extension/llm/runner/test/test_wav_loader.cpp‎

Lines changed: 159 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -357,3 +357,162 @@ TEST_F(WavLoaderTest, LoadAudioDataAcceptsExactSizeMatch) {
357357
EXPECT_FLOAT_EQ(audio[0], 0.5f);
358358
EXPECT_FLOAT_EQ(audio[1], -0.5f);
359359
}
360+
361+
// === Additional tests for strict-aliasing fix (T262564446) ===
362+
363+
// Test that the buffer-based overload of load_wav_header works correctly
364+
TEST_F(WavLoaderTest, LoadHeaderFromBufferParsesCorrectly) {
365+
const std::vector<uint8_t> wav_bytes =
366+
make_pcm_wav_bytes(32, {100, -100, 0, INT32_MAX});
367+
TempFile file(wav_bytes.data(), wav_bytes.size());
368+
369+
// Load via file path (original API)
370+
std::unique_ptr<WavHeader> header_from_file = load_wav_header(file.path());
371+
372+
// Load via buffer (new overload)
373+
std::unique_ptr<WavHeader> header_from_buf = load_wav_header(
374+
reinterpret_cast<const char*>(wav_bytes.data()), wav_bytes.size());
375+
376+
ASSERT_NE(header_from_file, nullptr);
377+
ASSERT_NE(header_from_buf, nullptr);
378+
379+
// Both should produce identical results
380+
EXPECT_EQ(header_from_file->AudioFormat, header_from_buf->AudioFormat);
381+
EXPECT_EQ(header_from_file->NumOfChan, header_from_buf->NumOfChan);
382+
EXPECT_EQ(header_from_file->SamplesPerSec, header_from_buf->SamplesPerSec);
383+
EXPECT_EQ(header_from_file->bitsPerSample, header_from_buf->bitsPerSample);
384+
EXPECT_EQ(header_from_file->blockAlign, header_from_buf->blockAlign);
385+
EXPECT_EQ(header_from_file->bytesPerSec, header_from_buf->bytesPerSec);
386+
EXPECT_EQ(header_from_file->dataOffset, header_from_buf->dataOffset);
387+
EXPECT_EQ(header_from_file->Subchunk2Size, header_from_buf->Subchunk2Size);
388+
EXPECT_EQ(header_from_file->ChunkSize, header_from_buf->ChunkSize);
389+
EXPECT_EQ(header_from_file->Subchunk1Size, header_from_buf->Subchunk1Size);
390+
}
391+
392+
// Test that unaligned buffers are handled correctly (the core strict-aliasing
393+
// scenario: data pointer not aligned to uint32_t boundary).
394+
TEST_F(WavLoaderTest, LoadHeaderHandlesUnalignedBuffer) {
395+
const std::vector<uint8_t> wav_bytes =
396+
make_pcm_wav_bytes(16, {1000, -1000, 0});
397+
398+
// Create a buffer with 1-byte offset to guarantee misalignment
399+
std::vector<char> unaligned_buf(wav_bytes.size() + 1);
400+
std::memcpy(unaligned_buf.data() + 1, wav_bytes.data(), wav_bytes.size());
401+
402+
// Parse from the unaligned pointer - this would crash with reinterpret_cast
403+
// on alignment-sensitive platforms, but works fine with memcpy.
404+
const char* unaligned_data = unaligned_buf.data() + 1;
405+
std::unique_ptr<WavHeader> header =
406+
load_wav_header(unaligned_data, wav_bytes.size());
407+
408+
ASSERT_NE(header, nullptr);
409+
EXPECT_EQ(header->AudioFormat, 1); // PCM
410+
EXPECT_EQ(header->NumOfChan, 1);
411+
EXPECT_EQ(header->SamplesPerSec, 16000);
412+
EXPECT_EQ(header->bitsPerSample, 16);
413+
EXPECT_EQ(header->Subchunk2Size, 6); // 3 samples * 2 bytes
414+
}
415+
416+
// Test WAV file with extra chunks between fmt and data (e.g., LIST chunk).
417+
// The old code would mis-parse this because the naive memcpy of 44 bytes
418+
// would place wrong data into the struct fields.
419+
TEST_F(WavLoaderTest, LoadHeaderWithExtraChunkBetweenFmtAndData) {
420+
// Build a WAV with a "LIST" chunk inserted between fmt and data
421+
std::vector<uint8_t> bytes;
422+
423+
// RIFF header
424+
append_bytes(bytes, "RIFF");
425+
uint32_t placeholder_chunk_size = 0; // will fill later
426+
size_t chunk_size_offset = bytes.size();
427+
append_le32(bytes, placeholder_chunk_size);
428+
append_bytes(bytes, "WAVE");
429+
430+
// fmt chunk
431+
append_bytes(bytes, "fmt ");
432+
append_le32(bytes, 16); // Subchunk1Size
433+
append_le16(bytes, 1); // PCM
434+
append_le16(bytes, 2); // stereo
435+
append_le32(bytes, 44100); // sample rate
436+
append_le32(bytes, 44100 * 2 * 2); // byte rate
437+
append_le16(bytes, 4); // block align
438+
append_le16(bytes, 16); // bits per sample
439+
440+
// Extra LIST chunk (commonly found in WAV files from editors)
441+
append_bytes(bytes, "LIST");
442+
append_le32(bytes, 26); // chunk size
443+
// 26 bytes of arbitrary metadata
444+
const char* list_data = "INFOIART\x0e\x00\x00\x00Test Artist\x00\x00";
445+
bytes.insert(bytes.end(), list_data, list_data + 26);
446+
447+
// data chunk
448+
append_bytes(bytes, "data");
449+
uint32_t data_size = 8; // 2 stereo samples * 2 bytes each
450+
append_le32(bytes, data_size);
451+
// Sample data: L=1000, R=-1000, L=500, R=-500
452+
append_le16(bytes, 1000);
453+
append_le16(bytes, static_cast<uint16_t>(-1000));
454+
append_le16(bytes, 500);
455+
append_le16(bytes, static_cast<uint16_t>(-500));
456+
457+
// Fix up ChunkSize
458+
uint32_t total_chunk_size = static_cast<uint32_t>(bytes.size() - 8);
459+
std::memcpy(bytes.data() + chunk_size_offset, &total_chunk_size, 4);
460+
461+
TempFile file(bytes.data(), bytes.size());
462+
463+
std::unique_ptr<WavHeader> header = load_wav_header(file.path());
464+
ASSERT_NE(header, nullptr);
465+
466+
EXPECT_EQ(header->AudioFormat, 1);
467+
EXPECT_EQ(header->NumOfChan, 2);
468+
EXPECT_EQ(header->SamplesPerSec, 44100);
469+
EXPECT_EQ(header->bitsPerSample, 16);
470+
EXPECT_EQ(header->blockAlign, 4);
471+
EXPECT_EQ(header->Subchunk2Size, data_size);
472+
// dataOffset should point past the LIST chunk, to the actual audio data
473+
EXPECT_GT(header->dataOffset, 44u);
474+
}
475+
476+
// Test single-read optimization: verify load_wav_audio_data still works
477+
// correctly (this exercises the refactored single-pass code path).
478+
TEST_F(WavLoaderTest, LoadAudioDataSinglePassReading) {
479+
// Use a larger sample set to ensure the full pipeline works
480+
std::vector<float> samples(1000);
481+
for (int i = 0; i < 1000; ++i) {
482+
samples[i] = static_cast<float>(i) / 1000.0f - 0.5f;
483+
}
484+
const std::vector<uint8_t> wav_bytes = make_float_wav_bytes(samples);
485+
TempFile file(wav_bytes.data(), wav_bytes.size());
486+
487+
std::vector<float> audio = load_wav_audio_data(file.path());
488+
ASSERT_EQ(audio.size(), samples.size());
489+
490+
for (size_t i = 0; i < samples.size(); ++i) {
491+
EXPECT_FLOAT_EQ(audio[i], samples[i]);
492+
}
493+
}
494+
495+
// Test that 32-bit PCM with memcpy produces correct results at boundaries
496+
TEST_F(WavLoaderTest, LoadAudioData32BitPcmBoundaryValues) {
497+
const std::vector<int32_t> samples = {
498+
0,
499+
1,
500+
-1,
501+
32767,
502+
-32768,
503+
std::numeric_limits<int32_t>::max(),
504+
std::numeric_limits<int32_t>::min(),
505+
std::numeric_limits<int32_t>::max() / 2};
506+
const std::vector<uint8_t> wav_bytes = make_pcm_wav_bytes(32, samples);
507+
TempFile file(wav_bytes.data(), wav_bytes.size());
508+
509+
std::vector<float> audio = load_wav_audio_data(file.path());
510+
ASSERT_EQ(audio.size(), samples.size());
511+
512+
for (size_t i = 0; i < samples.size(); ++i) {
513+
float expected =
514+
static_cast<float>(static_cast<double>(samples[i]) * kOneOverIntMax);
515+
EXPECT_NEAR(audio[i], expected, 1e-6f)
516+
<< "Mismatch at sample " << i << " (value=" << samples[i] << ")";
517+
}
518+
}

0 commit comments

Comments
 (0)