@@ -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\x00 Test 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