Add automatic WAV file splitting at 4GB limit

Implements seamless multi-part WAV file splitting to prevent corruption
when recordings exceed the 4GB RIFF format limit.

Features:
- Automatic detection when file approaches 4GB (~3.7GB safety threshold)
- Seamless splitting with zero audio data loss
- Multi-part file naming: file.wav, file_part2.wav, file_part3.wav, etc.
- Each part is a complete, valid WAV file with proper headers
- Files can be concatenated in any audio editor for frame-perfect stitching

Implementation details:
- Added MAX_FILE_SIZE constant (4,000,000,000 bytes)
- Track file part number and total data size across parts
- Parse and store base filename on Open() for multi-part naming
- Check file size before each WriteData() call
- If would exceed limit, call SplitToNextFile() first
- SplitToNextFile() finalizes current file and opens new part
- Reset per-file data size, increment part number
- Transparent to CaptureManager - no changes needed upstream

Technical notes:
- Conservative 3.7GB limit prevents any risk of corruption
- Accounts for WAV header overhead in size calculation
- Each file independently playable with correct duration
- Total recording time unlimited across multiple parts

Author: Bri

include/WavWriter.h

@@ -28,10 +28,16 @@ class WavWriter {
 private:
     void WriteWavHeader();
     void UpdateWavHeader();
+    bool SplitToNextFile();  // Open next file part seamlessly
+
+    static constexpr UINT64 MAX_FILE_SIZE = 4000000000ULL; // ~3.7GB safety limit
 
     std::ofstream m_file;
     std::wstring m_filename;
+    std::wstring m_baseFilename;     // Base filename without extension
     std::vector<BYTE> m_formatData;  // Store full format (WAVEFORMATEX or WAVEFORMATEXTENSIBLE)
-    UINT32 m_dataSize;
+    UINT32 m_dataSize;               // Data size in current file
+    UINT64 m_totalDataSize;          // Total data written across all parts
+    UINT32 m_filePartNumber;         // Current file part (1, 2, 3...)
     std::streampos m_dataStartPos;
 };

src/WavWriter.cpp

@@ -3,6 +3,8 @@
 
 WavWriter::WavWriter()
     : m_dataSize(0)
+    , m_totalDataSize(0)
+    , m_filePartNumber(1)
     , m_dataStartPos(0)
 {
 }
@@ -19,6 +21,18 @@ bool WavWriter::Open(const std::wstring& filename, const WAVEFORMATEX* format) {
     m_filename = filename;
     m_dataSize = 0;
 
+    // Extract base filename (remove extension) for multi-part file naming
+    size_t extPos = filename.rfind(L'.');
+    if (extPos != std::wstring::npos) {
+        m_baseFilename = filename.substr(0, extPos);
+    } else {
+        m_baseFilename = filename;
+    }
+
+    // Reset file part number for new recording
+    m_filePartNumber = 1;
+    m_totalDataSize = 0;
+
     // Calculate format size
     UINT32 formatSize = sizeof(WAVEFORMATEX);
     if (format->wFormatTag == WAVE_FORMAT_EXTENSIBLE && format->cbSize >= 22) {
@@ -47,12 +61,59 @@ bool WavWriter::WriteData(const BYTE* data, UINT32 size) {
         return false;
     }
 
+    // Calculate current file size (header + data)
+    // WAV header structure: RIFF(4) + size(4) + WAVE(4) + fmt(4) + fmtsize(4) + fmtdata + data(4) + datasize(4) + audiodata
+    UINT64 currentFileSize = 12 + 8 + static_cast<UINT64>(m_formatData.size()) + 8 + m_dataSize;
+
+    // Check if writing this data would exceed the 4GB limit
+    if (currentFileSize + size > MAX_FILE_SIZE) {
+        // Split to next file part before writing
+        if (!SplitToNextFile()) {
+            return false;
+        }
+    }
+
     m_file.write(reinterpret_cast<const char*>(data), size);
     m_dataSize += size;
+    m_totalDataSize += size;
 
     return m_file.good();
 }
 
+bool WavWriter::SplitToNextFile() {
+    // Update current file's header with final sizes
+    UpdateWavHeader();
+
+    // Close current file
+    m_file.close();
+
+    // Increment part number
+    m_filePartNumber++;
+
+    // Generate new filename: baseFilename_part2.wav, baseFilename_part3.wav, etc.
+    wchar_t partSuffix[32];
+    swprintf_s(partSuffix, L"_part%u.wav", m_filePartNumber);
+    std::wstring newFilename = m_baseFilename + partSuffix;
+
+    // Reset data size for new file
+    m_dataSize = 0;
+
+    // Open new file
+    m_file.open(newFilename, std::ios::binary | std::ios::out);
+    if (!m_file.is_open()) {
+        return false;
+    }
+
+    // Write header for new file
+    WriteWavHeader();
+    m_dataStartPos = m_file.tellp();
+
+    // Update current filename
+    m_filename = newFilename;
+
+    return true;
+}
+
 void WavWriter::Close() {
     if (!m_file.is_open()) {
         return;