v0.9.1 - Music Player Overhaul & Auto-Tier Fix

## Music Player
- Full music player with TWAV disk playback (DMA 128-sector batch reads)
- Clickable track list UI with polished glass-effect buttons
- Effects controls: SYNC (av offset), VIZ (13 modes), PAL (23 palettes), RAIN (3 presets)
- Fixed DMA buffer: heap-allocated Vec for correct HHDM virt_to_phys translation
- Fixed u16 truncation bug in load_track_data (usize-first min computation)
- Removed procedural lo-fi beat (disk-only playback)

## Desktop Auto-Tier System
- Fixed visualizer disappearing after ~4 seconds (auto-downgrade was too aggressive)
- Lowered FPS threshold from 30 to 18 (23fps with music+viz is acceptable)
- Increased downgrade counter from 180 to 360 frames (~6 seconds tolerance)
- Added auto-upgrade: FPS >= 35 for 300 frames restores tier back up
- Reset FPS counters after disk I/O to prevent transient dips triggering downgrade

## Browser & Network
- Replaced spin_loop() busy-waits with yield_thread() in TCP/HTTP/HTTPS
- Browser TCP timeout fix
- Music dock icon (IconType::Music, IconAction::OpenMusicPlayer)

## Disk I/O
- TWAV data disk on SATA port 3, find_data_port() scans all ports for TWAV magic
- VFS probes sector 0 for TWAV to avoid TrustFS/TWAV conflict

Author: Nathan

kernel/src/browser/mod.rs

@@ -288,7 +288,7 @@ impl Browser {
     }
 
     /// Extract external resources from the document
-    fn extract_resources(&mut self, base_url: &str) {
+    pub fn extract_resources(&mut self, base_url: &str) {
         self.pending_resources.clear();
         self.resources.clear();
 

kernel/src/desktop.rs

@@ -158,6 +158,21 @@ pub fn draw_about_icon(x: u32, y: u32, color: u32, _bg: u32) {
     framebuffer::fill_rect(x + 12, y + 24, 8, 2, light); // base
 }
 
+/// Draw a 32x32 music note icon
+pub fn draw_music_icon(x: u32, y: u32, color: u32, _bg: u32) {
+    let light = lighten(color, 1.3);
+    // Eighth note: oval head + stem + flag
+    // Note head (filled oval at bottom-left)
+    draw_filled_circle(x + 10, y + 24, 5, light);
+    draw_filled_circle(x + 10, y + 24, 4, color);
+    // Stem (vertical line going up-right)
+    framebuffer::fill_rect(x + 14, y + 6, 2, 19, light);
+    // Flag (curved line at top)
+    framebuffer::fill_rect(x + 16, y + 6, 2, 4, light);
+    framebuffer::fill_rect(x + 18, y + 8, 2, 4, light);
+    framebuffer::fill_rect(x + 20, y + 10, 2, 4, light);
+}
+
 /// Draw a 32x32 game controller icon (for games like Snake)
 pub fn draw_game_icon(x: u32, y: u32, color: u32, _bg: u32) {
     let dark = darken(color, 0.7);
@@ -283,6 +298,7 @@ pub enum IconType {
     Calculator,
     Network,
     About,
+    Music,
     Game,
     Editor,
     OpenGL,
@@ -302,6 +318,7 @@ pub fn draw_icon(icon_type: IconType, x: u32, y: u32, color: u32, bg: u32) {
         IconType::Calculator => draw_calculator_icon(x, y, color, bg),
         IconType::Network => draw_network_icon(x, y, color, bg),
         IconType::About => draw_about_icon(x, y, color, bg),
+        IconType::Music => draw_music_icon(x, y, color, bg),
         IconType::Game => draw_game_icon(x, y, color, bg),
         IconType::Editor => draw_editor_icon(x, y, color, bg),
         IconType::OpenGL => draw_opengl_icon(x, y, color, bg),

kernel/src/icons.rs

@@ -142,7 +142,8 @@ fn request_inner(method: &str, url: &str, content_type: Option<&str>, body: Opti
             break;
         }
 
-        core::hint::spin_loop();
+        // Yield to other threads so desktop stays responsive during fetch
+        crate::thread::yield_thread();
     }
 
     // Send FIN to close connection

kernel/src/netstack/http.rs

@@ -26,7 +26,7 @@ fn ensure_network_ready() {
             }
 
             // Small delay
-            for _ in 0..10000 { core::hint::spin_loop(); }
+            crate::thread::yield_thread();
         }
 
         if crate::netstack::dhcp::is_bound() {
@@ -135,8 +135,8 @@ fn get_inner(url: &str, depth: u32) -> Result<HttpsResponse, HttpsError> {
                     return Ok(len);
                 }
 
-                // Small delay
-                for _ in 0..10000 { core::hint::spin_loop(); }
+                // Yield to other threads
+                crate::thread::yield_thread();
             }
 
             recv_attempts += 1;
@@ -201,7 +201,7 @@ fn get_inner(url: &str, depth: u32) -> Result<HttpsResponse, HttpsError> {
             break;
         }
 
-        for _ in 0..10000 { core::hint::spin_loop(); }
+        crate::thread::yield_thread();
     }
 
     // Close connection

kernel/src/netstack/https.rs

@@ -862,7 +862,8 @@ pub fn wait_for_established(dest_ip: [u8; 4], dest_port: u16, src_port: u16, tim
         if spins > 2_000_000 {
             return false;
         }
-        core::hint::spin_loop();
+        // Yield to other threads so desktop frame loop stays responsive
+        crate::thread::yield_thread();
     }
 }
 
@@ -910,7 +911,7 @@ pub fn send_data(dest_ip: [u8; 4], dest_port: u16, src_port: u16, data: &[u8]) -
                 Err(e) if retries < 200 => {
                     // TX queue full or transient error — poll and retry
                     crate::netstack::poll();
-                    for _ in 0..2000 { core::hint::spin_loop(); }
+                    crate::thread::yield_thread();
                     retries += 1;
                 }
                 Err(e) => return Err(e),
@@ -920,14 +921,8 @@ pub fn send_data(dest_ip: [u8; 4], dest_port: u16, src_port: u16, data: &[u8]) -
         // Poll and pace between batches to let receiver process
         if (i + 1) % BATCH == 0 {
             crate::netstack::poll();
-            // Wait ~1ms real time to avoid overwhelming receiver
-            let wait_start = crate::time::uptime_ms();
-            loop {
-                core::hint::spin_loop();
-                if crate::time::uptime_ms().wrapping_sub(wait_start) >= 1 {
-                    break;
-                }
-            }
+            // Yield to let other threads run between batches
+            crate::thread::yield_thread();
         }
 
     }

kernel/src/netstack/tcp.rs

@@ -10,27 +10,18 @@
 use alloc::string::String;
 use alloc::vec::Vec;
 use alloc::vec;
+use core::sync::atomic::{AtomicU8, Ordering};
 
 const SECTOR_SIZE: usize = 512;
-/// Read 8 sectors at a time (4KB = one page, DMA-safe).
-/// Using a small page-aligned intermediate buffer avoids issues with large heap
-/// allocations whose physical addresses may not be contiguous across pages.
-const DMA_READ_SECTORS: u16 = 8;
-const DMA_READ_BYTES: usize = DMA_READ_SECTORS as usize * SECTOR_SIZE; // 4096
+/// Read 128 sectors at a time (64KB) for fast bulk loading.
+/// AHCI supports up to 128 sectors per command; larger batches = fewer commands.
+const DMA_READ_SECTORS: u16 = 128;
+const DMA_READ_BYTES: usize = DMA_READ_SECTORS as usize * SECTOR_SIZE; // 65536
 /// Maximum tracks in v2 format
 const MAX_TRACKS: usize = 10;
 /// Bytes per track entry in header
 const ENTRY_SIZE: usize = 48;
 
-/// Page-aligned intermediate buffer for AHCI DMA reads.
-/// AHCI DMA requires a physically contiguous buffer. The kernel heap may
-/// not guarantee physical contiguity for large allocations.
-/// This small buffer is always within a single 4KB page.
-#[repr(C, align(4096))]
-struct DmaReadBuf([u8; DMA_READ_BYTES]);
-
-static mut DMA_READ_BUF: DmaReadBuf = DmaReadBuf([0u8; DMA_READ_BYTES]);
-
 /// Track info parsed from the disk header
 #[derive(Clone)]
 pub struct TrackInfo {
@@ -46,22 +37,33 @@ pub struct DiskTrackTable {
     pub tracks: Vec<TrackInfo>,
 }
 
+/// Cached AHCI port number for TWAV disk (0xFE = not scanned yet, 0xFF = not found)
+static CACHED_PORT: AtomicU8 = AtomicU8::new(0xFE);
+
 /// Try to find which AHCI port has our audio data disk.
+/// Result is cached after first scan to avoid repeated port probing.
 fn find_data_port() -> Option<u8> {
+    let cached = CACHED_PORT.load(Ordering::Relaxed);
+    if cached != 0xFE {
+        return if cached == 0xFF { None } else { Some(cached) };
+    }
     if !crate::drivers::ahci::is_initialized() {
         return None;
     }
     let devices = crate::drivers::ahci::list_devices();
     for dev in &devices {
-        if dev.port_num == 2 {
-            return Some(2);
-        }
-    }
-    for dev in &devices {
-        if dev.port_num > 1 && dev.device_type == crate::drivers::ahci::AhciDeviceType::Sata {
-            return Some(dev.port_num);
+        if dev.device_type == crate::drivers::ahci::AhciDeviceType::Sata && dev.sector_count > 64 {
+            let mut probe = alloc::vec![0u8; 512];
+            if crate::drivers::ahci::read_sectors(dev.port_num, 0, 1, &mut probe).is_ok() {
+                if probe.len() >= 4 && &probe[0..4] == b"TWAV" {
+                    crate::serial_println!("[DISK-AUDIO] Found TWAV disk on port {}", dev.port_num);
+                    CACHED_PORT.store(dev.port_num, Ordering::Relaxed);
+                    return Some(dev.port_num);
+                }
+            }
         }
     }
+    CACHED_PORT.store(0xFF, Ordering::Relaxed);
     None
 }
 
@@ -155,8 +157,10 @@ pub fn load_track_from_disk(track_idx: usize) -> Result<(Vec<u8>, String), &'sta
 }
 
 /// Load track data given a TrackInfo.
-/// Uses a small page-aligned DMA buffer to avoid physical address issues
-/// with large heap allocations.
+/// Uses a heap-allocated page-aligned DMA buffer so AHCI virt_to_phys
+/// (which subtracts HHDM offset) maps correctly.  Static .bss buffers
+/// live at the kernel's linked VA, outside the HHDM window, so DMA
+/// writes to the wrong physical address and we read back zeros.
 fn load_track_data(track: &TrackInfo) -> Result<(Vec<u8>, String), &'static str> {
     let port = find_data_port().ok_or("No data disk found on AHCI")?;
 
@@ -167,34 +171,37 @@ fn load_track_data(track: &TrackInfo) -> Result<(Vec<u8>, String), &'static str>
     crate::serial_println!("[DISK-AUDIO] Loading '{}': {} bytes, {} sectors from LBA {}",
         track.name, track.wav_size, track.sector_count, track.start_lba);
 
+    // Allocate DMA buffer FIRST (small, 64KB) before the large WAV buffer
+    // so the allocator can service it from a clean free-list.
+    let mut dma_buf = vec![0u8; DMA_READ_BYTES];
+
     let mut wav_buf = Vec::with_capacity(track.wav_size);
 
     let mut sectors_remaining = track.sector_count;
     let mut current_lba = track.start_lba;
 
     while sectors_remaining > 0 {
-        let chunk = (sectors_remaining as u16).min(DMA_READ_SECTORS);
-        let chunk_bytes = chunk as usize * SECTOR_SIZE;
-
-        // Read into page-aligned DMA-safe intermediate buffer
-        let bytes_read = unsafe {
-            crate::drivers::ahci::read_sectors(
-                port, current_lba, chunk,
-                &mut DMA_READ_BUF.0[..chunk_bytes],
-            )?
-        };
+        // Compute chunk in usize FIRST, then cast to u16.
+        // Avoids truncation: e.g. 102496_usize as u16 = 37120, but
+        // 102496_usize.min(128) = 128 then as u16 = 128.
+        let chunk_sectors = sectors_remaining.min(DMA_READ_SECTORS as usize);
+        let chunk = chunk_sectors as u16;
+        let chunk_bytes = chunk_sectors * SECTOR_SIZE;
+
+        crate::drivers::ahci::read_sectors(
+            port, current_lba, chunk,
+            &mut dma_buf[..chunk_bytes],
+        )?;
 
         // Copy from DMA buffer to target Vec (only up to what we still need)
         let needed = track.wav_size.saturating_sub(wav_buf.len());
-        let to_copy = bytes_read.min(needed);
+        let to_copy = chunk_bytes.min(needed);
         if to_copy > 0 {
-            unsafe {
-                wav_buf.extend_from_slice(&DMA_READ_BUF.0[..to_copy]);
-            }
+            wav_buf.extend_from_slice(&dma_buf[..to_copy]);
         }
 
-        current_lba += chunk as u64;
-        sectors_remaining -= chunk as usize;
+        current_lba += chunk_sectors as u64;
+        sectors_remaining -= chunk_sectors;
     }
 
     wav_buf.truncate(track.wav_size);
@@ -213,3 +220,11 @@ pub fn load_wav_from_disk() -> Result<Vec<u8>, &'static str> {
     let (data, _name) = load_track_from_disk(0)?;
     Ok(data)
 }
+
+/// Get track names for the UI (reads header only, fast).
+pub fn get_track_names() -> Vec<String> {
+    match read_track_table() {
+        Ok(table) => table.tracks.iter().map(|t| t.name.clone()).collect(),
+        Err(_) => Vec::new(),
+    }
+}

kernel/src/trustdaw/disk_audio.rs

@@ -280,8 +280,17 @@ pub fn init() {
     if !root_mounted && crate::drivers::ahci::is_initialized() {
         let devices = crate::drivers::ahci::list_devices();
         // Use the first non-optical AHCI port with sectors > 0
+        // Skip disks that have TWAV magic (audio data disks)
         for dev in &devices {
             if dev.sector_count > 64 {
+                // Check if this disk has TWAV magic — skip audio data disks
+                let mut probe = alloc::vec![0u8; 512];
+                if crate::drivers::ahci::read_sectors(dev.port_num, 0, 1, &mut probe).is_ok() {
+                    if probe.len() >= 4 && &probe[0..4] == b"TWAV" {
+                        crate::log!("[VFS] Skipping AHCI port {} (TWAV audio data disk)", dev.port_num);
+                        continue;
+                    }
+                }
                 let backend = Arc::new(fat32::AhciBlockReader::new(dev.port_num as usize, 0));
                 match trustfs::TrustFs::new(backend, dev.sector_count) {
                     Ok(trustfs) => {

kernel/src/vfs/mod.rs

@@ -61,6 +61,20 @@ Write-Output "Step 4: Configure VM..."
 & $VBM storagectl $VMName --name "SATA" --add sata --controller IntelAhci --portcount 4 2>&1
 & $VBM storageattach $VMName --storagectl "SATA" --port 0 --device 0 --type dvddrive --medium $ISOPath 2>&1
 
+# Audio data disk on AHCI port 3 (raw sectors with WAV tracks)
+# Port 2 is used by TrustFS for the root filesystem
+$DataDisk = "C:\Users\nathan\Documents\Scripts\OSrust\builds\trustos_data.img"
+if (Test-Path $DataDisk) {
+    # Convert raw .img to VDI for VirtualBox
+    $DataVDI = "C:\Users\nathan\Documents\Scripts\OSrust\builds\trustos_data.vdi"
+    Remove-Item $DataVDI -ErrorAction SilentlyContinue
+    & $VBM convertfromraw $DataDisk $DataVDI --format VDI 2>&1
+    & $VBM storageattach $VMName --storagectl "SATA" --port 3 --device 0 --type hdd --medium $DataVDI 2>&1
+    Write-Output "Audio data disk attached on SATA port 3"
+} else {
+    Write-Output "WARNING: No audio data disk found at $DataDisk"
+}
+
 # Serial
 Remove-Item $SerialLog -ErrorAction SilentlyContinue
 & $VBM modifyvm $VMName --uart1 0x3F8 4 --uartmode1 file $SerialLog 2>&1