Bump to v0.4.1

Architecture:
- Each BD-J format in own file: paramount.rs, criterion.rs, pixelogic.rs, ctrm.rs
- Standard interface: detect() → bool, parse() → Option<Vec<StreamLabel>>
- PARSERS array in mod.rs — drop in a new parser with one line
- Shared vocab.rs for BD spec codec names only (MLP→TrueHD, AC3→Dolby Digital)
- All other label data passes through raw from disc — no guessing

Changes:
- New: paramount.rs (playlists.xml — Paramount/onQ format)
- Renamed: bluray_project.rs → pixelogic.rs
- Renamed: stream_properties.rs → criterion.rs
- Merged: language_streams.rs + menu_base.rs → ctrm.rs
- Removed: jar module (superseded by labels), dead apply functions
- Added: DriveSession::eject() with PREVENT ALLOW MEDIUM REMOVAL
- Added: DiscRegion enum (Free/BluRay/Dvd)
- Fixed: capture sector ranges now include all files (only skip STREAM/)
- Renamed: StreamLabel.region → variant (not a BD spec field)

CHANGELOG.md

@@ -0,0 +1,36 @@
+# Changelog
+
+## 0.4.0 (2026-04-07)
+
+### Labels — complete rewrite
+
+- **Detect-then-parse architecture**: each BD-J authoring format has its own parser module with `detect()` and `parse()` functions. Drop in a new parser with one line in the registry.
+- **5 format parsers**: Paramount (`playlists.xml`), Criterion (`streamproperties.xml`), Pixelogic (`bluray_project.bin`), Warner CTRM (`menu_base.prop` / `language_streams.txt`), shared label vocabulary (`vocab.rs`)
+- **Raw disc data principle**: label data passes through as-is from disc. Only BD-standard codec identifiers (MLP, AC3, DTS) are mapped to display names. Unknown authoring tool codes (csp, eda, cf) pass through raw.
+- **`variant` field**: replaces `region` — language dialect codes from authoring tools, not BD spec regions
+- Removed: old `jar` module (superseded by labels)
+- Removed: dead label apply functions from disc.rs
+
+### Drive
+
+- **`DriveSession::eject()`**: sends PREVENT ALLOW MEDIUM REMOVAL then START STOP UNIT. Works reliably after raw mode unlock.
+- **`DiscRegion` enum**: Free, BluRay(A/B/C), Dvd(1-8). UHD always region-free.
+
+### Capture
+
+- **Fixed sector range collection**: captures ALL files on disc (only skips STREAM/ video files and >50MB). Previously skipped BACKUP/, DUPLICATE/, and files >10MB which missed JAR content.
+
+## 0.3.1
+
+- Labels module: 4 disc file parsers for stream labels
+- Simplified labels API
+
+## 0.3.0
+
+- Initial public release
+- SCSI transport (Linux SG_IO, macOS IOKit)
+- UDF 2.50 filesystem reader
+- MPLS/CLPI parsers with full STN support
+- Drive identification + profile matching
+- 206 bundled drive profiles
+- AACS 1.0 decryption (VUK + unit keys)

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "libfreemkv"
-version = "0.3.1"
+version = "0.4.1"
 edition = "2021"
 license = "AGPL-3.0-only"
 description = "Open source raw disc access library for optical drives"

README.md

@@ -14,7 +14,7 @@ Part of the [freemkv](https://github.com/freemkv) project.
 
 ```toml
 [dependencies]
-libfreemkv = "0.3"
+libfreemkv = "0.4"
 ```
 
 ## Quick Start

src/clpi.rs

@@ -183,11 +183,32 @@ fn parse_cpi(data: &[u8]) -> Result<(Vec<EpCoarse>, Vec<EpFine>)> {
         return Ok((Vec::new(), Vec::new()));
     }
 
+    // Stream PID entry — bit-packed per BD spec (libbluray clpi_parse.c):
+    //   stream_PID: 16 bits           → ep_map[2..4]
+    //   reserved: 10 bits             ┐
+    //   EP_stream_type: 4 bits        │ ep_map[4..14] = 80 bits
+    //   num_EP_coarse: 16 bits        │ (10+4+16+18+32 = 80)
+    //   num_EP_fine: 18 bits          │
+    //   EP_map_start_address: 32 bits ┘
+    if ep_map.len() < 16 { return Ok((Vec::new(), Vec::new())); }
     let _stream_pid = u16::from_be_bytes([ep_map[2], ep_map[3]]);
-    // ep_map[4..6] = reserved + EP stream type
-    let num_coarse = u16::from_be_bytes([ep_map[6], ep_map[7]]) as usize;
-    let num_fine = u32::from_be_bytes([ep_map[8], ep_map[9], ep_map[10], ep_map[11]]) as usize;
-    let ep_map_offset = u32::from_be_bytes([ep_map[12], ep_map[13], ep_map[14], ep_map[15]]) as usize;
+
+    // Read 10 bytes (80 bits) from ep_map[4..14] for bit extraction
+    // Use two u64s since we need 80 bits
+    let hi = u64::from_be_bytes([ep_map[4], ep_map[5], ep_map[6], ep_map[7],
+                                  ep_map[8], ep_map[9], ep_map[10], ep_map[11]]);
+    let lo_bytes = [ep_map[12], ep_map[13]];
+
+    // Bit 0-9: reserved (10)
+    // Bit 10-13: EP_stream_type (4)
+    // Bit 14-29: num_coarse (16)
+    // Bit 30-47: num_fine (18)
+    // Bit 48-79: EP_map_start (32) — bits 48-63 in hi, bits 64-79 in lo
+    let num_coarse = ((hi >> 34) & 0xFFFF) as usize;
+    let num_fine = ((hi >> 16) & 0x3FFFF) as usize;
+    let ep_map_offset = (((hi & 0xFFFF) as u32) << 16)
+                        | (u16::from_be_bytes(lo_bytes) as u32);
+    let ep_map_offset = ep_map_offset as usize;
 
     // EP map for this stream starts at ep_map_offset relative to ep_map start
     if ep_map_offset + 4 > ep_map.len() {

src/disc.rs

@@ -14,21 +14,69 @@ use crate::udf;
 use crate::mpls;
 use crate::clpi;
 
+
 // ─── Public types ───────────────────────────────────────────────────────────
 
 /// A scanned Blu-ray disc.
 #[derive(Debug)]
 pub struct Disc {
+    /// UDF Volume Identifier from Primary Volume Descriptor (always present)
+    pub volume_id: String,
+    /// Disc title from META/DL/bdmt_eng.xml (None if disc has no metadata)
+    pub meta_title: Option<String>,
+    /// Disc format (BD, UHD, DVD)
+    pub format: DiscFormat,
     /// Disc capacity in sectors
     pub capacity_sectors: u32,
+    /// Disc capacity in bytes
+    pub capacity_bytes: u64,
+    /// Number of layers (1 = single, 2 = dual)
+    pub layers: u8,
     /// Titles sorted by duration (longest first), then playlist name
     pub titles: Vec<Title>,
+    /// Disc region
+    pub region: DiscRegion,
     /// AACS state — None if disc is unencrypted or keys unavailable
     pub aacs: Option<AacsState>,
     /// Whether this disc requires AACS decryption
     pub encrypted: bool,
 }
 
+/// Disc format.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum DiscFormat {
+    /// 4K UHD Blu-ray (HEVC 2160p)
+    Uhd,
+    /// Standard Blu-ray (1080p/1080i)
+    BluRay,
+    /// DVD
+    Dvd,
+    /// Unknown
+    Unknown,
+}
+
+/// Disc playback region.
+#[derive(Debug, Clone, PartialEq)]
+pub enum DiscRegion {
+    /// Region-free (all UHD discs, some BD/DVD)
+    Free,
+    /// Blu-ray regions (A/B/C or combination)
+    BluRay(Vec<BdRegion>),
+    /// DVD regions (1-8 or combination)
+    Dvd(Vec<u8>),
+}
+
+/// Blu-ray region codes.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum BdRegion {
+    /// Region A/1 — Americas, East Asia (Japan, Korea, Southeast Asia)
+    A,
+    /// Region B/2 — Europe, Africa, Australia, Middle East
+    B,
+    /// Region C/3 — Central/South Asia, China, Russia
+    C,
+}
+
 /// A title (one MPLS playlist).
 #[derive(Debug, Clone)]
 pub struct Title {
@@ -40,49 +88,88 @@ pub struct Title {
     pub duration_secs: f64,
     /// Total size in bytes
     pub size_bytes: u64,
-    /// Number of clips
-    pub clip_count: usize,
+    /// Clip references in playback order
+    pub clips: Vec<Clip>,
     /// All streams (video, audio, subtitle, etc.)
     pub streams: Vec<Stream>,
     /// Sector extents for ripping (clip LBA ranges)
     pub extents: Vec<Extent>,
 }
 
+/// A clip reference within a title.
+#[derive(Debug, Clone)]
+pub struct Clip {
+    /// Clip filename without extension (e.g. "00001")
+    pub clip_id: String,
+    /// In-time in 45kHz ticks
+    pub in_time: u32,
+    /// Out-time in 45kHz ticks
+    pub out_time: u32,
+    /// Duration in seconds
+    pub duration_secs: f64,
+    /// Source packet count (from CLPI, 0 if unavailable)
+    pub source_packets: u32,
+}
+
 /// A stream within a title.
 #[derive(Debug, Clone)]
-pub struct Stream {
-    /// Stream type
-    pub kind: StreamKind,
+pub enum Stream {
+    Video(VideoStream),
+    Audio(AudioStream),
+    Subtitle(SubtitleStream),
+}
+
+/// A video stream.
+#[derive(Debug, Clone)]
+pub struct VideoStream {
     /// MPEG-TS packet ID
     pub pid: u16,
-    /// Codec
+    /// Codec (HEVC, H.264, VC-1, MPEG-2)
     pub codec: Codec,
-    /// ISO 639-2 language code (e.g. "eng", "fra")
-    pub language: String,
-    /// Video resolution (e.g. "2160p", "1080p")
+    /// Resolution (e.g. "2160p", "1080p", "1080i")
     pub resolution: String,
-    /// Frame rate (e.g. "23.976")
+    /// Frame rate (e.g. "23.976", "25")
     pub frame_rate: String,
-    /// Channel layout (e.g. "5.1", "7.1", "stereo")
-    pub channels: String,
-    /// Sample rate (e.g. "48kHz")
-    pub sample_rate: String,
     /// HDR format
     pub hdr: HdrFormat,
     /// Color space
     pub color_space: ColorSpace,
-    /// Whether this is a secondary/enhancement stream
+    /// Whether this is a secondary stream (PiP, Dolby Vision EL)
     pub secondary: bool,
     /// Extra label (e.g. "Dolby Vision EL")
     pub label: String,
 }
 
-/// Stream type.
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum StreamKind {
-    Video,
-    Audio,
-    Subtitle,
+/// An audio stream.
+#[derive(Debug, Clone)]
+pub struct AudioStream {
+    /// MPEG-TS packet ID
+    pub pid: u16,
+    /// Codec (TrueHD, DTS-HD MA, DD, LPCM, etc.)
+    pub codec: Codec,
+    /// Channel layout (e.g. "5.1", "7.1", "stereo", "mono")
+    pub channels: String,
+    /// ISO 639-2 language code (e.g. "eng", "fra")
+    pub language: String,
+    /// Sample rate (e.g. "48kHz", "96kHz")
+    pub sample_rate: String,
+    /// Whether this is a secondary stream (commentary)
+    pub secondary: bool,
+    /// Extra label
+    pub label: String,
+}
+
+/// A subtitle stream.
+#[derive(Debug, Clone)]
+pub struct SubtitleStream {
+    /// MPEG-TS packet ID
+    pub pid: u16,
+    /// Codec (PGS)
+    pub codec: Codec,
+    /// ISO 639-2 language code (e.g. "eng", "fra")
+    pub language: String,
+    /// Whether this is a forced subtitle
+    pub forced: bool,
 }
 
 /// Video/audio codec.
@@ -210,46 +297,6 @@ impl Title {
     }
 }
 
-impl Stream {
-    /// Human-readable one-line description.
-    pub fn display(&self) -> String {
-        match self.kind {
-            StreamKind::Video => {
-                let mut parts = vec![self.codec.name().to_string()];
-                if !self.resolution.is_empty() { parts.push(self.resolution.clone()); }
-                if !self.frame_rate.is_empty() { parts.push(format!("{}fps", self.frame_rate)); }
-                if self.hdr != HdrFormat::Sdr { parts.push(self.hdr.name().to_string()); }
-                if self.color_space != ColorSpace::Unknown && self.color_space != ColorSpace::Bt709 {
-                    parts.push(self.color_space.name().to_string());
-                }
-                if self.secondary { parts.push(format!("[{}]", self.label)); }
-                parts.join(" ")
-            }
-            StreamKind::Audio => {
-                let mut parts = vec![self.codec.name().to_string()];
-                if !self.channels.is_empty() { parts.push(self.channels.clone()); }
-                if !self.sample_rate.is_empty() { parts.push(self.sample_rate.clone()); }
-                if !self.language.is_empty() { parts.push(format!("({})", self.language)); }
-                if self.secondary { parts.push("[secondary]".to_string()); }
-                parts.join(" ")
-            }
-            StreamKind::Subtitle => {
-                let mut parts = vec![self.codec.name().to_string()];
-                if !self.language.is_empty() { parts.push(format!("({})", self.language)); }
-                parts.join(" ")
-            }
-        }
-    }
-
-    /// Kind as a display string
-    pub fn kind_name(&self) -> &'static str {
-        match self.kind {
-            StreamKind::Video => "Video",
-            StreamKind::Audio => "Audio",
-            StreamKind::Subtitle => "Subtitle",
-        }
-    }
-}
 
 // ─── AACS state ─────────────────────────────────────────────────────────────
 
@@ -393,11 +440,17 @@ impl Disc {
         // Sort: longest first
         titles.sort_by(|a, b| b.duration_secs.partial_cmp(&a.duration_secs).unwrap_or(std::cmp::Ordering::Equal));
 
-        // Step 4: Detect AACS encryption
+        // Step 4: Read disc title from META/DL/bdmt_eng.xml
+        let meta_title = Self::read_meta_title(session, &udf_fs);
+
+        // Step 5: Enhance streams with disc config file labels (if available)
+        crate::labels::apply(session, &udf_fs, &mut titles);
+
+        // Step 6: Detect AACS encryption
         let encrypted = udf_fs.find_dir("/AACS").is_some()
             || udf_fs.find_dir("/BDMV/AACS").is_some();
 
-        // Step 5: If encrypted and KEYDB available, authenticate and derive keys
+        // Step 7: If encrypted and KEYDB available, authenticate and derive keys
         let aacs = if encrypted {
             if let Some(keydb_path) = opts.resolve_keydb() {
                 match Self::setup_aacs(session, &keydb_path) {
@@ -411,9 +464,31 @@ impl Disc {
             None
         };
 
+        // Derive disc format from main title video codec
+        let format = Self::detect_format(&titles);
+
+        // Derive layer count from capacity
+        // BD-25 single layer: up to ~12M sectors (~25GB)
+        // BD-50 dual layer: ~12M-25M sectors (~50GB)
+        // BD-66/100 UHD: 25M+ sectors
+        let layers = if capacity > 24_000_000 { 2 } else { 1 };
+
+        // UHD is always region-free. BD/DVD region parsing TODO.
+        let region = if format == DiscFormat::Uhd {
+            DiscRegion::Free
+        } else {
+            DiscRegion::Free // TODO: parse from index.bdmv
+        };
+
         Ok(Disc {
+            volume_id: udf_fs.volume_id.clone(),
+            meta_title: meta_title,
+            format,
             capacity_sectors: capacity,
+            capacity_bytes: capacity as u64 * 2048,
+            layers,
             titles,
+            region,
             aacs,
             encrypted,
         })
@@ -512,6 +587,62 @@ impl Disc {
 
     // ── Internal helpers ────────────────────────────────────────────────────
 
+    /// Detect disc format from the main title's video streams.
+    fn detect_format(titles: &[Title]) -> DiscFormat {
+        for title in titles.iter().take(3) {
+            for stream in &title.streams {
+                if let Stream::Video(v) = stream {
+                    if v.resolution.contains("2160") {
+                        return DiscFormat::Uhd;
+                    }
+                    if v.resolution.contains("1080") || v.resolution.contains("720") {
+                        return DiscFormat::BluRay;
+                    }
+                    if v.resolution.contains("480") || v.resolution.contains("576") {
+                        return DiscFormat::Dvd;
+                    }
+                }
+            }
+        }
+        DiscFormat::Unknown
+    }
+
+    /// Read disc title from META/DL/bdmt_eng.xml (Blu-ray Disc Meta Table).
+    /// Prefers English, falls back to first available language.
+    /// Returns None if META directory is empty or XML has no usable title.
+    fn read_meta_title(session: &mut DriveSession, udf_fs: &udf::UdfFs) -> Option<String> {
+        let meta_dir = udf_fs.find_dir("/BDMV/META")?;
+        for sub in &meta_dir.entries {
+            if !sub.is_dir { continue; }
+            let dl_path = format!("/BDMV/META/{}", sub.name);
+            if let Some(dl_dir) = udf_fs.find_dir(&dl_path) {
+                let xml_files: Vec<_> = dl_dir.entries.iter()
+                    .filter(|e| !e.is_dir && e.name.to_lowercase().ends_with(".xml"))
+                    .collect();
+
+                let eng = xml_files.iter().find(|e| e.name.to_lowercase().contains("eng"));
+                let target = eng.or_else(|| xml_files.first());
+
+                if let Some(entry) = target {
+                    let path = format!("{}/{}", dl_path, entry.name);
+                    if let Ok(data) = udf_fs.read_file(session, &path) {
+                        let xml = String::from_utf8_lossy(&data);
+                        if let Some(start) = xml.find("<di:name>") {
+                            let s = start + "<di:name>".len();
+                            if let Some(end) = xml[s..].find("</di:name>") {
+                                let title = xml[s..s + end].trim().to_string();
+                                if !title.is_empty() && title != "Blu-ray" {
+                                    return Some(title);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        None
+    }
+
     fn read_capacity(session: &mut DriveSession) -> Result<u32> {
         let cdb = [0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
         let mut buf = [0u8; 8];
@@ -539,47 +670,85 @@ impl Disc {
             return None;
         }
 
-        // Parse each clip for EP map → sector extents
+        // Parse each clip for size, duration, and sector extents
         let mut extents = Vec::new();
         let mut total_size: u64 = 0;
-        let clip_count = parsed.play_items.len();
+        let mut clips = Vec::with_capacity(parsed.play_items.len());
 
         for play_item in &parsed.play_items {
+            let clip_dur = play_item.out_time.saturating_sub(play_item.in_time) as f64 / 45000.0;
+            let mut pkt_count: u32 = 0;
+
             let clpi_path = format!("/BDMV/CLIPINF/{}.clpi", play_item.clip_id);
             if let Ok(clpi_data) = udf_fs.read_file(session, &clpi_path) {
                 if let Ok(clip_info) = clpi::parse(&clpi_data) {
-                    // Use EP map to get sector extents for this clip's time range
+                    pkt_count = clip_info.source_packet_count;
+                    total_size += pkt_count as u64 * 192;
+
                     let clip_extents = clip_info.get_extents(play_item.in_time, play_item.out_time);
-                    for ext in &clip_extents {
-                        total_size += ext.sector_count as u64 * 2048;
-                    }
                     extents.extend(clip_extents);
                 }
             }
+
+            clips.push(Clip {
+                clip_id: play_item.clip_id.clone(),
+                in_time: play_item.in_time,
+                out_time: play_item.out_time,
+                duration_secs: clip_dur,
+                source_packets: pkt_count,
+            });
         }
 
         // Build streams from STN table
         let streams: Vec<Stream> = parsed.streams.iter().map(|s| {
-            let kind = match s.stream_type {
-                1 => StreamKind::Video,
-                2 => StreamKind::Audio,
-                3 => StreamKind::Subtitle,
-                _ => StreamKind::Video,
-            };
             let codec = Codec::from_coding_type(s.coding_type);
-            Stream {
-                kind,
-                pid: s.pid,
-                codec,
-                language: s.language.clone(),
-                resolution: format_resolution(s.video_format, s.video_rate),
-                frame_rate: format_framerate(s.video_rate),
-                channels: format_channels(s.audio_format),
-                sample_rate: format_samplerate(s.audio_rate),
-                hdr: HdrFormat::Sdr,
-                color_space: ColorSpace::Unknown,
-                secondary: false,
-                label: String::new(),
+            match s.stream_type {
+                1 | 6 | 7 => Stream::Video(VideoStream {
+                    pid: s.pid,
+                    codec,
+                    resolution: format_resolution(s.video_format, s.video_rate),
+                    frame_rate: format_framerate(s.video_rate),
+                    hdr: match s.dynamic_range {
+                        1 => HdrFormat::Hdr10,
+                        2 => HdrFormat::DolbyVision,
+                        _ => HdrFormat::Sdr,
+                    },
+                    color_space: match s.color_space {
+                        1 => ColorSpace::Bt709,
+                        2 => ColorSpace::Bt2020,
+                        _ => ColorSpace::Unknown,
+                    },
+                    secondary: s.secondary,
+                    label: match s.stream_type {
+                        7 => "Dolby Vision EL".to_string(),
+                        _ => String::new(),
+                    },
+                }),
+                2 | 5 => Stream::Audio(AudioStream {
+                    pid: s.pid,
+                    codec,
+                    channels: format_channels(s.audio_format),
+                    language: s.language.clone(),
+                    sample_rate: format_samplerate(s.audio_rate),
+                    secondary: s.stream_type == 5,
+                    label: String::new(),
+                }),
+                3 => Stream::Subtitle(SubtitleStream {
+                    pid: s.pid,
+                    codec,
+                    language: s.language.clone(),
+                    forced: false, // TODO: parse from MPLS stream attributes
+                }),
+                _ => Stream::Video(VideoStream {
+                    pid: s.pid,
+                    codec,
+                    resolution: String::new(),
+                    frame_rate: String::new(),
+                    hdr: HdrFormat::Sdr,
+                    color_space: ColorSpace::Unknown,
+                    secondary: false,
+                    label: String::new(),
+                }),
             }
         }).collect();
 
@@ -591,7 +760,7 @@ impl Disc {
             playlist_id,
             duration_secs,
             size_bytes: total_size,
-            clip_count,
+            clips,
             streams,
             extents,
         })

src/drive.rs

@@ -36,6 +36,7 @@ impl DriveSession {
     /// for sector reads, disc scanning, and content extraction.
     pub fn open(device: &Path) -> Result<Self> {
         let mut session = Self::open_no_unlock(device)?;
+        session.wait_ready()?;
         let _ = session.unlock(); // silently ignore — unencrypted discs don't need it
         Ok(session)
     }
@@ -85,6 +86,24 @@ impl DriveSession {
         })
     }
 
+    /// Wait for the drive to become ready (disc spun up).
+    /// Polls TEST UNIT READY up to 30 seconds.
+    pub fn wait_ready(&mut self) -> Result<()> {
+        let tur = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00]; // TEST UNIT READY
+        for _ in 0..60 {
+            let mut buf = [0u8; 0];
+            if self.scsi.as_mut().execute(
+                &tur, crate::scsi::DataDirection::None, &mut buf, 5000
+            ).is_ok() {
+                return Ok(());
+            }
+            std::thread::sleep(std::time::Duration::from_millis(500));
+        }
+        Err(Error::DeviceNotFound {
+            path: format!("{}: drive not ready after 30s", self.device_path),
+        })
+    }
+
     /// Device path this session was opened on.
     pub fn device_path(&self) -> &str {
         &self.device_path
@@ -144,6 +163,22 @@ impl DriveSession {
         Ok(result.bytes_transferred)
     }
 
+    /// Eject the disc tray.
+    ///
+    /// Sends PREVENT ALLOW MEDIUM REMOVAL (allow) first to release any
+    /// locks, then START STOP UNIT with LoEj=1 to open the tray.
+    pub fn eject(&mut self) -> Result<()> {
+        // PREVENT ALLOW MEDIUM REMOVAL: allow removal
+        let allow_cdb = [0x1Eu8, 0, 0, 0, 0x00, 0];
+        let mut buf = [0u8; 0];
+        let _ = self.scsi.as_mut().execute(&allow_cdb, crate::scsi::DataDirection::None, &mut buf, 5_000);
+
+        // START STOP UNIT: LoEj=1, Start=0
+        let eject_cdb = [0x1Bu8, 0, 0, 0, 0x02, 0];
+        self.scsi.as_mut().execute(&eject_cdb, crate::scsi::DataDirection::None, &mut buf, 30_000)?;
+        Ok(())
+    }
+
     /// Execute a raw SCSI CDB. Used by parsers and AACS handshake.
     pub fn scsi_execute(
         &mut self,

src/identity.rs

@@ -39,6 +39,9 @@ pub struct DriveId {
     /// Format: CCYYMMDDHHMI (12 ASCII characters)
     pub firmware_date: String,
 
+    /// Drive serial number — GET CONFIGURATION Feature 0108h
+    pub serial_number: String,
+
     /// Raw 96-byte INQUIRY response for additional parsing if needed.
     pub raw_inquiry: Vec<u8>,
 }
@@ -63,10 +66,29 @@ impl DriveId {
             String::new()
         };
 
-        Ok(Self::from_inquiry(&inquiry, &firmware_date))
+        // GET CONFIGURATION Feature 0108h — Serial Number
+        let mut gc_serial = vec![0u8; 256];
+        let cdb_serial = [0x46, 0x02, 0x01, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00];
+        let serial_number = if let Ok(r) = transport.execute(&cdb_serial, DataDirection::FromDevice, &mut gc_serial, 5000) {
+            if r.bytes_transferred > 12 {
+                String::from_utf8_lossy(&gc_serial[12..r.bytes_transferred])
+                    .trim().to_string()
+            } else { String::new() }
+        } else { String::new() };
+
+        Ok(DriveId {
+            vendor_id: ascii_field(&inquiry, 8, 16),
+            product_id: ascii_field(&inquiry, 16, 32),
+            product_revision: ascii_field(&inquiry, 32, 36),
+            vendor_specific: ascii_field(&inquiry, 36, 43),
+            firmware_date,
+            serial_number,
+            raw_inquiry: inquiry.to_vec(),
+        })
     }
 
     /// Build identity from raw INQUIRY bytes and firmware date string.
+    /// Used by tests and when serial isn't available.
     pub fn from_inquiry(inquiry: &[u8], firmware_date: &str) -> Self {
         DriveId {
             vendor_id: ascii_field(inquiry, 8, 16),
@@ -74,6 +96,7 @@ impl DriveId {
             product_revision: ascii_field(inquiry, 32, 36),
             vendor_specific: ascii_field(inquiry, 36, 43),
             firmware_date: firmware_date.to_string(),
+            serial_number: String::new(),
             raw_inquiry: inquiry.to_vec(),
         }
     }

src/jar.rs

@@ -2,29 +2,24 @@
 //!
 //! Blu-ray discs with BD-J menus store the menu application as Java JAR files
 //! in BDMV/JAR/. These contain .class files with string constants that label
-//! audio and subtitle tracks (e.g. "eng_ADES_US_" = Descriptive Audio US).
+//! audio and subtitle tracks.
 //!
-//! with no way to tell them apart (e.g. 3x "AC-3 5.1 English").
+//! Multiple label formats exist across studios:
+//!   - Label format: "eng_MLP_", "fra_AudioStream3" (Warner UHD, e.g. Barbie, Dune)
+//!   - TextField format: "TextField,Audio1,English Dolby Atmos,..." (A24/Lionsgate, e.g. Civil War)
 //!
-//! The JAR is a ZIP file. Each .class file has a Java constant pool containing
-//! UTF-8 string literals. We scan for patterns like:
-//!   {lang}_{codec}_{variant}_   → audio track labels
-//!   {lang}_PGStream{n}          → subtitle track labels
-//!   MAIN_FEATURE                → playlist identification
-//!   FORCED_TRAILER              → forced content identification
-//!
-//! This is best-effort: if the JAR doesn't contain labels or the format
-//! is unexpected, we return empty results. The caller falls back to
-//! showing streams without labels.
+//! Labels match to streams by STN index — the Nth audio label in the JAR
+//! corresponds to the Nth audio stream in the MPLS STN table. This is defined
+//! by the BD-J API where stream numbers = STN indices (1-based).
 
 use std::io::Read;
 
 /// Labels extracted from a BD-J JAR file.
 #[derive(Debug, Default)]
 pub struct JarLabels {
-    /// Audio track labels in STN order: (language, codec_hint, variant, raw_label)
+    /// Audio track labels in STN order
     pub audio: Vec<TrackLabel>,
-    /// Subtitle track labels: (language, stream_index, raw_label)
+    /// Subtitle track labels in STN order
     pub subtitle: Vec<TrackLabel>,
     /// Playlist purpose labels (MAIN_FEATURE, FORCED_TRAILER, etc.)
     pub playlists: Vec<String>,
@@ -33,155 +28,230 @@ pub struct JarLabels {
 /// A parsed track label from the JAR.
 #[derive(Debug, Clone)]
 pub struct TrackLabel {
-    /// ISO 639-2 language code (e.g. "eng", "fra")
-    pub language: String,
-    /// Codec or type hint (e.g. "MLP", "AC3", "ADES", "PGStream")
-    pub hint: String,
-    /// Variant or region (e.g. "US", "UK", "3", "4")
-    pub variant: String,
-    /// Human-readable description derived from the label
+    /// Human-readable description (e.g. "English Dolby Atmos", "TrueHD", "Descriptive Audio (US)")
     pub description: String,
+    /// ISO 639-2 language code if available (e.g. "eng", "fra")
+    pub language: String,
+    /// Codec hint if available (e.g. "MLP"=TrueHD, "AC3"=DD, "DTS")
+    pub codec_hint: String,
     /// The raw string from the class file
     pub raw: String,
 }
 
-impl TrackLabel {
-    /// Parse a label string like "eng_ADES_US_" or "dan_PGStream4"
-    fn parse(s: &str) -> Option<Self> {
-        let clean = s.trim_end_matches('_');
-        let parts: Vec<&str> = clean.splitn(3, '_').collect();
-        if parts.len() < 2 {
-            return None;
+/// Extract track labels from a JAR file (raw ZIP bytes).
+///
+/// Tries multiple format parsers. Returns None if no labels found.
+pub fn extract_labels(jar_data: &[u8]) -> Option<JarLabels> {
+    let strings = extract_all_jar_strings(jar_data)?;
+
+    // Try each format parser in order
+    try_textfield_format(&strings)
+        .or_else(|| try_label_format(&strings))
+        .or_else(|| try_playlist_only(&strings))
+}
+
+// ── Format 1: TextField (A24/Lionsgate) ─────────────────────────────────────
+//
+// Pattern: "TextField,Audio{N},{description},..."
+//          "TextField,Subtitle{N},{description},..."
+// Found in: Civil War, and similar A24/Lionsgate discs
+
+fn try_textfield_format(strings: &[String]) -> Option<JarLabels> {
+    let mut audio: Vec<(u32, String, String)> = Vec::new(); // (index, description, raw)
+    let mut subtitle: Vec<(u32, String, String)> = Vec::new();
+    let mut playlists = Vec::new();
+
+    for s in strings {
+        if s.starts_with("TextField,Audio") {
+            // TextField,Audio{N},{description},...
+            let parts: Vec<&str> = s.splitn(4, ',').collect();
+            if parts.len() >= 3 {
+                let key = parts[1]; // "Audio1", "Audio2", etc.
+                let desc = parts[2].to_string();
+                if let Some(num_str) = key.strip_prefix("Audio") {
+                    if let Ok(idx) = num_str.parse::<u32>() {
+                        if !desc.is_empty() {
+                            audio.push((idx, desc, s.clone()));
+                        }
+                    }
+                }
+            }
+        } else if s.starts_with("TextField,Subtitle") {
+            let parts: Vec<&str> = s.splitn(4, ',').collect();
+            if parts.len() >= 3 {
+                let key = parts[1];
+                let desc = parts[2].to_string();
+                if let Some(num_str) = key.strip_prefix("Subtitle") {
+                    if let Ok(idx) = num_str.parse::<u32>() {
+                        if !desc.eq_ignore_ascii_case("None") && !desc.is_empty() {
+                            subtitle.push((idx, desc, s.clone()));
+                        }
+                    }
+                }
+            }
         }
 
-        let language = parts[0].to_string();
-        // Language should be 2-3 lowercase letters
-        if language.len() < 2 || language.len() > 3 || !language.chars().all(|c| c.is_ascii_lowercase()) {
-            return None;
+        collect_playlist_label(s, &mut playlists);
+    }
+
+    if audio.is_empty() && subtitle.is_empty() {
+        return None;
+    }
+
+    // Sort by index to ensure STN order
+    audio.sort_by_key(|a| a.0);
+    subtitle.sort_by_key(|s| s.0);
+
+    Some(JarLabels {
+        audio: audio.into_iter().map(|(_, desc, raw)| TrackLabel {
+            description: desc, language: String::new(), codec_hint: String::new(), raw,
+        }).collect(),
+        subtitle: subtitle.into_iter().map(|(_, desc, raw)| TrackLabel {
+            description: desc, language: String::new(), codec_hint: String::new(), raw,
+        }).collect(),
+        playlists,
+    })
+}
+
+// ── Format 2: Label strings (Warner UHD) ────────────────────────────────────
+//
+// Pattern: "eng_MLP_", "fra_AudioStream3", "dan_PGStream4"
+// Found in: Barbie, Dune Part Two, and similar Warner UHD discs
+
+fn try_label_format(strings: &[String]) -> Option<JarLabels> {
+    let mut audio = Vec::new();
+    let mut subtitle = Vec::new();
+    let mut playlists = Vec::new();
+
+    for s in strings {
+        if let Some(label) = parse_label_string(s) {
+            if label.is_audio && !audio.iter().any(|a: &TrackLabel| a.raw == label.raw) {
+                audio.push(TrackLabel {
+                    description: label.description, language: label.language,
+                    codec_hint: label.codec_hint, raw: label.raw,
+                });
+            } else if label.is_subtitle && !subtitle.iter().any(|a: &TrackLabel| a.raw == label.raw) {
+                subtitle.push(TrackLabel {
+                    description: label.description, language: label.language,
+                    codec_hint: label.codec_hint, raw: label.raw,
+                });
+            }
         }
 
-        let hint = parts[1].to_string();
-        let variant = if parts.len() > 2 { parts[2].to_string() } else { String::new() };
-
-        let description = match hint.as_str() {
-            "MLP" => "TrueHD".to_string(),
-            "AC3" => {
-                if variant.is_empty() { "compatibility".to_string() }
-                else { variant.clone() }
-            }
-            "DTS" => "DTS".to_string(),
-            "LPCM" => "LPCM".to_string(),
-            "ADES" => {
-                if variant.is_empty() { "Descriptive Audio".to_string() }
-                else { format!("Descriptive Audio ({})", variant) }
-            }
-            h if h.starts_with("AudioStream") => String::new(), // generic, no extra info
-            h if h.starts_with("PGStream") => String::new(),    // generic subtitle
-            _ => String::new(),
-        };
-
-        Some(TrackLabel {
-            language,
-            hint,
-            variant,
-            description,
-            raw: s.to_string(),
-        })
+        collect_playlist_label(s, &mut playlists);
     }
 
-    /// Is this an audio track label?
-    fn is_audio(&self) -> bool {
-        matches!(self.hint.as_str(), "MLP" | "AC3" | "DTS" | "LPCM" | "ADES")
-            || self.hint.starts_with("AudioStream")
+    if audio.is_empty() && subtitle.is_empty() {
+        return None;
     }
 
-    /// Is this a subtitle track label?
-    fn is_subtitle(&self) -> bool {
-        self.hint.starts_with("PGStream")
+    Some(JarLabels { audio, subtitle, playlists })
+}
+
+struct ParsedLabel {
+    description: String,
+    language: String,
+    codec_hint: String,
+    raw: String,
+    is_audio: bool,
+    is_subtitle: bool,
+}
+
+fn parse_label_string(s: &str) -> Option<ParsedLabel> {
+    let clean = s.trim_end_matches('_');
+    let parts: Vec<&str> = clean.splitn(3, '_').collect();
+    if parts.len() < 2 { return None; }
+
+    let language = parts[0];
+    if language.len() < 2 || language.len() > 3 || !language.chars().all(|c| c.is_ascii_lowercase()) {
+        return None;
+    }
+
+    let hint = parts[1];
+    let variant = if parts.len() > 2 { parts[2] } else { "" };
+
+    // Only set description when the JAR adds info beyond what MPLS provides.
+    // Codec (MLP, AC3, DTS) is already known from the stream. Don't make up labels.
+    let (description, codec_hint, is_audio, is_subtitle) = match hint {
+        "MLP" => (String::new(), "MLP".to_string(), true, false),
+        "AC3" => (String::new(), "AC3".to_string(), true, false),
+        "DTS" => (String::new(), "DTS".to_string(), true, false),
+        "LPCM" => (String::new(), "LPCM".to_string(), true, false),
+        "ADES" => {
+            // Descriptive Audio — real value-add, can't be derived from MPLS
+            let d = if variant.is_empty() { "Descriptive Audio".to_string() }
+                    else { format!("Descriptive Audio ({})", variant) };
+            (d, "ADES".to_string(), true, false)
+        }
+        h if h.starts_with("AudioStream") => (String::new(), String::new(), true, false),
+        h if h.starts_with("PGStream") => (String::new(), String::new(), false, true),
+        _ => return None,
+    };
+
+    Some(ParsedLabel {
+        description, language: language.to_string(), codec_hint,
+        raw: s.to_string(), is_audio, is_subtitle,
+    })
+}
+
+// ── Format 3: Playlist-only ─────────────────────────────────────────────────
+//
+// Some JARs have no track labels but do have playlist purpose markers.
+
+fn try_playlist_only(strings: &[String]) -> Option<JarLabels> {
+    let mut playlists = Vec::new();
+    for s in strings {
+        collect_playlist_label(s, &mut playlists);
+    }
+    if playlists.is_empty() { return None; }
+    Some(JarLabels { audio: Vec::new(), subtitle: Vec::new(), playlists })
+}
+
+// ── Common helpers ──────────────────────────────────────────────────────────
+
+fn collect_playlist_label(s: &str, playlists: &mut Vec<String>) {
+    if matches!(s.as_ref(),
+        "MAIN_FEATURE" | "MAIN_FEATURE_INTRO" |
+        "FORCED_TRAILER" | "INTL_FORCED_TRAILER" |
+        "commentary_extras" | "extras"
+    ) {
+        if !playlists.iter().any(|p| p == s) {
+            playlists.push(s.to_string());
+        }
     }
 }
 
-/// Extract track labels from a JAR file (raw ZIP bytes).
-///
-/// Returns None if the JAR can't be parsed or contains no labels.
-/// This is best-effort — failure is not an error.
-pub fn extract_labels(jar_data: &[u8]) -> Option<JarLabels> {
+/// Extract all UTF-8 string constants from all .class files in a JAR.
+fn extract_all_jar_strings(jar_data: &[u8]) -> Option<Vec<String>> {
     let cursor = std::io::Cursor::new(jar_data);
     let mut archive = zip::ZipArchive::new(cursor).ok()?;
 
-    let mut all_audio = Vec::new();
-    let mut all_subtitle = Vec::new();
-    let mut all_playlists = Vec::new();
+    let mut all_strings = Vec::new();
 
     for i in 0..archive.len() {
         let mut file = archive.by_index(i).ok()?;
-        if !file.name().ends_with(".class") {
-            continue;
-        }
+        if !file.name().ends_with(".class") { continue; }
 
         let mut data = Vec::new();
         file.read_to_end(&mut data).ok()?;
 
-        let strings = extract_class_strings(&data);
-
-        for s in &strings {
-            // Track labels: {lang}_{type}_{variant}_
-            if let Some(label) = TrackLabel::parse(s) {
-                if label.is_audio() && !all_audio.iter().any(|a: &TrackLabel| a.raw == label.raw) {
-                    all_audio.push(label);
-                } else if label.is_subtitle() && !all_subtitle.iter().any(|a: &TrackLabel| a.raw == label.raw) {
-                    all_subtitle.push(label);
-                }
-            }
-
-            // Playlist purpose labels
-            if matches!(s.as_str(),
-                "MAIN_FEATURE" | "MAIN_FEATURE_INTRO" |
-                "FORCED_TRAILER" | "INTL_FORCED_TRAILER" |
-                "commentary_extras" | "extras"
-            ) {
-                if !all_playlists.contains(s) {
-                    all_playlists.push(s.clone());
-                }
-            }
-        }
+        extract_class_strings(&data, &mut all_strings);
     }
 
-    if all_audio.is_empty() && all_subtitle.is_empty() {
-        return None;
-    }
-
-    Some(JarLabels {
-        audio: all_audio,
-        subtitle: all_subtitle,
-        playlists: all_playlists,
-    })
+    if all_strings.is_empty() { return None; }
+    Some(all_strings)
 }
 
-/// Extract all UTF-8 string constants from a Java .class file's constant pool.
-///
-/// Java class file format:
-///   [0:4]   magic (0xCAFEBABE)
-///   [4:6]   minor version
-///   [6:8]   major version
-///   [8:10]  constant_pool_count
-///   [10:]   constant_pool entries
-///
-/// CONSTANT_Utf8 (tag=1): u8 tag + u16 length + bytes
-/// We only extract these — they contain all string literals.
-fn extract_class_strings(data: &[u8]) -> Vec<String> {
-    let mut strings = Vec::new();
-
-    // Verify Java class magic
+/// Extract UTF-8 string constants from a Java .class file's constant pool.
+fn extract_class_strings(data: &[u8], out: &mut Vec<String>) {
     if data.len() < 10 || &data[0..4] != &[0xCA, 0xFE, 0xBA, 0xBE] {
-        return strings;
+        return;
     }
 
     let cp_count = ((data[8] as u16) << 8 | data[9] as u16) as usize;
     let mut pos = 10;
+    let mut entry = 1;
 
-    // Parse constant pool entries
-    let mut entry = 1; // constant pool is 1-indexed
     while entry < cp_count && pos < data.len() {
         let tag = data[pos];
         pos += 1;
@@ -195,32 +265,21 @@ fn extract_class_strings(data: &[u8]) -> Vec<String> {
                 if pos + len > data.len() { break; }
 
                 if let Ok(s) = std::str::from_utf8(&data[pos..pos + len]) {
-                    // Only keep strings that look like track labels
-                    // Must contain underscore and be reasonable length
-                    if s.len() >= 5 && s.len() <= 100 && s.contains('_') {
-                        strings.push(s.to_string());
+                    if s.len() >= 3 && s.len() <= 500 {
+                        out.push(s.to_string());
                     }
                 }
                 pos += len;
             }
-            // CONSTANT_Integer, CONSTANT_Float
             3 | 4 => { pos += 4; }
-            // CONSTANT_Long, CONSTANT_Double (take 2 entries)
             5 | 6 => { pos += 8; entry += 1; }
-            // CONSTANT_Class, CONSTANT_String, CONSTANT_MethodType
             7 | 8 | 16 => { pos += 2; }
-            // CONSTANT_Fieldref, CONSTANT_Methodref, CONSTANT_InterfaceMethodref,
-            // CONSTANT_NameAndType, CONSTANT_InvokeDynamic
             9 | 10 | 11 | 12 | 18 => { pos += 4; }
-            // CONSTANT_MethodHandle
             15 => { pos += 3; }
-            // Unknown tag — can't continue parsing safely
             _ => { break; }
         }
         entry += 1;
     }
-
-    strings
 }
 
 #[cfg(test)]
@@ -228,36 +287,56 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_parse_audio_labels() {
-        let l = TrackLabel::parse("eng_MLP_").unwrap();
-        assert_eq!(l.language, "eng");
-        assert_eq!(l.hint, "MLP");
-        assert_eq!(l.description, "TrueHD");
-        assert!(l.is_audio());
-
-        let l = TrackLabel::parse("eng_ADES_US_").unwrap();
-        assert_eq!(l.language, "eng");
-        assert_eq!(l.hint, "ADES");
-        assert_eq!(l.variant, "US");
-        assert_eq!(l.description, "Descriptive Audio (US)");
-        assert!(l.is_audio());
-
-        let l = TrackLabel::parse("fra_AudioStream3").unwrap();
-        assert_eq!(l.language, "fra");
-        assert!(l.is_audio());
+    fn test_textfield_audio() {
+        let strings = vec![
+            "TextField,Audio1,English Dolby Atmos,Font,296,763,275,25,left".to_string(),
+            "TextField,Audio2,English Descriptive Audio,Font,296,803,275,25,left".to_string(),
+            "TextField,Audio3,Spanish 5.1 Dolby Digital,Font,296,843,275,25,left".to_string(),
+        ];
+        let labels = try_textfield_format(&strings).unwrap();
+        assert_eq!(labels.audio.len(), 3);
+        assert_eq!(labels.audio[0].description, "English Dolby Atmos");
+        assert_eq!(labels.audio[1].description, "English Descriptive Audio");
+        assert_eq!(labels.audio[2].description, "Spanish 5.1 Dolby Digital");
     }
 
     #[test]
-    fn test_parse_subtitle_labels() {
-        let l = TrackLabel::parse("dan_PGStream4").unwrap();
-        assert_eq!(l.language, "dan");
-        assert!(l.is_subtitle());
+    fn test_textfield_subtitle_skips_none() {
+        let strings = vec![
+            "TextField,Subtitle0,None,Font,1312,843,275,25,left".to_string(),
+            "TextField,Subtitle1,English SDH,Font,1312,763,275,25,left".to_string(),
+            "TextField,Subtitle2,Spanish,Font,1312,803,275,25,left".to_string(),
+        ];
+        let labels = try_textfield_format(&strings).unwrap();
+        assert_eq!(labels.subtitle.len(), 2);
+        assert_eq!(labels.subtitle[0].description, "English SDH");
+        assert_eq!(labels.subtitle[1].description, "Spanish");
     }
 
     #[test]
-    fn test_reject_non_labels() {
-        assert!(TrackLabel::parse("substring").is_none());
-        assert!(TrackLabel::parse("equals").is_none());
-        assert!(TrackLabel::parse("Code").is_none());
+    fn test_label_format_audio() {
+        let strings = vec![
+            "eng_MLP_".to_string(),
+            "eng_ADES_US_".to_string(),
+            "fra_AudioStream3".to_string(),
+        ];
+        let labels = try_label_format(&strings).unwrap();
+        assert_eq!(labels.audio.len(), 3);
+        assert_eq!(labels.audio[0].description, ""); // MLP — codec already known from stream
+        assert_eq!(labels.audio[1].description, "Descriptive Audio (US)"); // ADES — real value-add
+    }
+
+    #[test]
+    fn test_label_format_subtitle() {
+        let strings = vec!["dan_PGStream4".to_string()];
+        let labels = try_label_format(&strings).unwrap();
+        assert_eq!(labels.subtitle.len(), 1);
+    }
+
+    #[test]
+    fn test_no_labels() {
+        let strings = vec!["java/lang/Object".to_string(), "toString".to_string()];
+        assert!(try_textfield_format(&strings).is_none());
+        assert!(try_label_format(&strings).is_none());
     }
 }

src/labels/criterion.rs

@@ -0,0 +1,159 @@
+//! Criterion Collection — `streamproperties.xml` + `playbackconfig.xml`
+//!
+//! Clean structured XML with Content/Qualifier per stream and
+//! stream number mapping via playbackconfig.
+
+use crate::drive::DriveSession;
+use crate::udf::UdfFs;
+use super::{StreamLabel, StreamLabelType, LabelPurpose, LabelQualifier};
+use std::collections::HashMap;
+
+pub fn detect(udf: &UdfFs) -> bool {
+    super::jar_file_exists(udf, "streamproperties.xml")
+}
+
+pub fn parse(session: &mut DriveSession, udf: &UdfFs) -> Option<Vec<StreamLabel>> {
+    let sp_data = super::read_jar_file(session, udf, "streamproperties.xml")?;
+    let sp_text = std::str::from_utf8(&sp_data).ok()?;
+
+    let stream_infos = parse_stream_infos(sp_text);
+    if stream_infos.is_empty() { return None; }
+
+    // Stream number mapping from playbackconfig.xml
+    let mut stream_map: HashMap<String, u16> = HashMap::new();
+    if let Some(pc_data) = super::read_jar_file(session, udf, "playbackconfig.xml") {
+        if let Ok(pc_text) = std::str::from_utf8(&pc_data) {
+            parse_playback_config(pc_text, &mut stream_map);
+        }
+    }
+
+    let mut labels = Vec::new();
+    let mut audio_idx: u16 = 1;
+    let mut sub_idx: u16 = 1;
+
+    for info in &stream_infos {
+        let stream_num = stream_map.get(&info.id).copied().unwrap_or_else(|| {
+            match info.stream_type {
+                StreamLabelType::Audio => { let n = audio_idx; audio_idx += 1; n }
+                StreamLabelType::Subtitle => { let n = sub_idx; sub_idx += 1; n }
+            }
+        });
+
+        labels.push(StreamLabel {
+            stream_number: stream_num,
+            stream_type: info.stream_type,
+            language: info.language.clone(),
+            name: String::new(),
+            purpose: info.purpose,
+            qualifier: info.qualifier,
+            codec_hint: String::new(),
+            variant: info.variant.clone(),
+        });
+    }
+
+    if labels.is_empty() { return None; }
+    Some(labels)
+}
+
+struct StreamInfo {
+    id: String,
+    stream_type: StreamLabelType,
+    language: String,
+    variant: String,
+    purpose: LabelPurpose,
+    qualifier: LabelQualifier,
+}
+
+fn parse_stream_infos(xml: &str) -> Vec<StreamInfo> {
+    let mut infos = Vec::new();
+    let mut pos = 0;
+
+    while pos < xml.len() {
+        let (tag, stream_type) = if let Some(p) = xml[pos..].find("<AudioStreamInfos>") {
+            (p + pos, StreamLabelType::Audio)
+        } else if let Some(p) = xml[pos..].find("<SubtitleStreamInfos>") {
+            (p + pos, StreamLabelType::Subtitle)
+        } else {
+            break;
+        };
+
+        let end_tag = match stream_type {
+            StreamLabelType::Audio => "</AudioStreamInfos>",
+            StreamLabelType::Subtitle => "</SubtitleStreamInfos>",
+        };
+
+        let block_end = match xml[tag..].find(end_tag) {
+            Some(p) => tag + p + end_tag.len(),
+            None => break,
+        };
+
+        let block = &xml[tag..block_end];
+        let id = extract_tag(block, "ID").unwrap_or_default();
+        let lang_id = extract_tag(block, "LangInfoID").unwrap_or_default();
+        let content = extract_tag(block, "Content").unwrap_or_default();
+        let qualifier_str = extract_tag(block, "Qualifier").unwrap_or_default();
+
+        let (language, variant) = if lang_id.contains('_') {
+            let parts: Vec<&str> = lang_id.splitn(2, '_').collect();
+            (parts[0].to_lowercase(), parts[1].to_string())
+        } else {
+            (lang_id.to_lowercase(), String::new())
+        };
+
+        let purpose = match content.as_str() {
+            "COMMENTARY" => LabelPurpose::Commentary,
+            _ => LabelPurpose::Normal,
+        };
+
+        let qualifier = match qualifier_str.as_str() {
+            "SDH" => LabelQualifier::Sdh,
+            "DS" => LabelQualifier::DescriptiveService,
+            _ => LabelQualifier::None,
+        };
+
+        infos.push(StreamInfo { id, stream_type, language, variant, purpose, qualifier });
+        pos = block_end;
+    }
+    infos
+}
+
+fn parse_playback_config(xml: &str, map: &mut HashMap<String, u16>) {
+    let mut pos = 0;
+    while pos < xml.len() {
+        let tag_start = if let Some(p) = xml[pos..].find("<AudioStreams>") {
+            Some(p + pos)
+        } else if let Some(p) = xml[pos..].find("<SubtitlesStreams>") {
+            Some(p + pos)
+        } else {
+            None
+        };
+
+        let tag_start = match tag_start {
+            Some(p) => p,
+            None => break,
+        };
+
+        let block_end = xml[tag_start..].find("</AudioStreams>")
+            .or_else(|| xml[tag_start..].find("</SubtitlesStreams>"))
+            .map(|p| tag_start + p + 20)
+            .unwrap_or(xml.len());
+
+        let block = &xml[tag_start..block_end];
+
+        if let (Some(stream_id_str), Some(info_id)) = (extract_tag(block, "StreamID"), extract_tag(block, "StreamInfo_ID")) {
+            if let Ok(stream_num) = stream_id_str.parse::<u16>() {
+                map.insert(info_id, stream_num);
+            }
+        }
+
+        pos = block_end;
+    }
+}
+
+fn extract_tag(xml: &str, tag: &str) -> Option<String> {
+    let open = format!("<{}>", tag);
+    let close = format!("</{}>", tag);
+    let start = xml.find(&open)? + open.len();
+    let end = xml[start..].find(&close)? + start;
+    Some(xml[start..end].trim().to_string())
+}

src/labels/ctrm.rs

@@ -0,0 +1,208 @@
+//! Warner CTRM — `menu_base.prop` and/or `language_streams.txt`
+//!
+//! Two sub-formats from the same framework. A disc may have one or both.
+//! When both exist, language_streams.txt provides structured types while
+//! menu_base.prop provides stream number → button name mapping.
+
+use crate::drive::DriveSession;
+use crate::udf::UdfFs;
+use super::{StreamLabel, StreamLabelType, LabelPurpose, LabelQualifier, vocab};
+use std::collections::HashMap;
+
+pub fn detect(udf: &UdfFs) -> bool {
+    super::jar_file_exists(udf, "menu_base.prop")
+        || super::jar_file_exists(udf, "language_streams.txt")
+}
+
+pub fn parse(session: &mut DriveSession, udf: &UdfFs) -> Option<Vec<StreamLabel>> {
+    // Try language_streams.txt first (richer structured data)
+    let ls_labels = parse_language_streams(session, udf);
+
+    // Try menu_base.prop (stream numbers + key names)
+    let mb_labels = parse_menu_base(session, udf);
+
+    // If we have both, merge: language_streams for structure, menu_base for names
+    match (ls_labels, mb_labels) {
+        (Some(ls), Some(mb)) => Some(merge(ls, mb)),
+        (Some(ls), None) => Some(ls),
+        (None, Some(mb)) => Some(mb),
+        (None, None) => None,
+    }
+}
+
+fn merge(ls: Vec<StreamLabel>, mb: Vec<StreamLabel>) -> Vec<StreamLabel> {
+    // language_streams has better type/purpose data, menu_base has button names
+    // Match by stream number + type, take name from menu_base
+    let mut result = ls;
+    for label in &mut result {
+        if let Some(mb_match) = mb.iter().find(|m|
+            m.stream_type == label.stream_type && m.stream_number == label.stream_number
+        ) {
+            if label.name.is_empty() && !mb_match.name.is_empty() {
+                label.name = mb_match.name.clone();
+            }
+        }
+    }
+    result
+}
+
+// ── language_streams.txt parser ────────────────────────────────────────────
+
+fn parse_language_streams(session: &mut DriveSession, udf: &UdfFs) -> Option<Vec<StreamLabel>> {
+    let data = super::read_jar_file(session, udf, "language_streams.txt")?;
+    let text = std::str::from_utf8(&data).ok()?;
+
+    let mut labels = Vec::new();
+
+    for line in text.lines() {
+        let line = line.trim();
+        if line.is_empty() || line.starts_with('#') { continue; }
+
+        let parts: Vec<&str> = line.split(',').map(|s| s.trim()).collect();
+        if parts.len() < 4 { continue; }
+
+        let type_str = parts[1];
+        let stream_num: u16 = match parts[2].parse() {
+            Ok(n) => n,
+            Err(_) => continue,
+        };
+        let language = parts[3].to_string();
+        let variant = if parts.len() > 4 { parts[4].to_string() } else { String::new() };
+
+        let (stream_type, purpose, qualifier) = match type_str {
+            "audio_production" => (StreamLabelType::Audio, LabelPurpose::Normal, LabelQualifier::None),
+            "audio_commentary" => (StreamLabelType::Audio, LabelPurpose::Commentary, LabelQualifier::None),
+            "audio_ime" => (StreamLabelType::Audio, LabelPurpose::Ime, LabelQualifier::None),
+            "subtitle_production" => (StreamLabelType::Subtitle, LabelPurpose::Normal, LabelQualifier::None),
+            "subtitle_commentary" => (StreamLabelType::Subtitle, LabelPurpose::Commentary, LabelQualifier::None),
+            "subtitle_narrative" => (StreamLabelType::Subtitle, LabelPurpose::Normal, LabelQualifier::Forced),
+            "subtitle_dual" => (StreamLabelType::Subtitle, LabelPurpose::Normal, LabelQualifier::None),
+            "subtitle_bonus" => (StreamLabelType::Subtitle, LabelPurpose::Normal, LabelQualifier::None),
+            "subtitle_ime" => (StreamLabelType::Subtitle, LabelPurpose::Ime, LabelQualifier::None),
+            "subtitle_ime_narrative" => (StreamLabelType::Subtitle, LabelPurpose::Ime, LabelQualifier::Forced),
+            _ => continue,
+        };
+
+        // Classify variant code
+        let mut codec_hint = String::new();
+        let mut variant_code = String::new();
+        let mut final_purpose = purpose;
+
+        if !variant.is_empty() {
+            match variant.as_str() {
+                // Codec variants — use shared label vocab
+                "atmos" | "MLP" | "AC3" | "DTS" | "DDL" => {
+                    codec_hint = vocab::codec(&variant).to_string();
+                }
+                // Purpose variants
+                "eda" => final_purpose = LabelPurpose::Descriptive,
+                // Dialect variants — pass through raw code from disc
+                "csp" | "cs" | "lsp" | "ls" | "cf" | "pf" | "bp" | "pp" => {
+                    variant_code = variant.clone();
+                }
+                // Unknown — store as-is in codec_hint
+                _ => codec_hint = variant.clone(),
+            }
+        }
+
+        labels.push(StreamLabel {
+            stream_number: stream_num,
+            stream_type,
+            language,
+            name: String::new(),
+            purpose: final_purpose,
+            qualifier,
+            codec_hint,
+            variant: variant_code,
+        });
+    }
+
+    if labels.is_empty() { return None; }
+    Some(labels)
+}
+
+// ── menu_base.prop parser ──────────────────────────────────────────────────
+
+fn parse_menu_base(session: &mut DriveSession, udf: &UdfFs) -> Option<Vec<StreamLabel>> {
+    let data = super::read_jar_file(session, udf, "menu_base.prop")?;
+    let text = std::str::from_utf8(&data).ok()?;
+
+    // Parse key=value, group by prefix
+    let mut entries: HashMap<String, HashMap<String, String>> = HashMap::new();
+
+    for line in text.lines() {
+        let line = line.trim();
+        if line.is_empty() || line.starts_with('#') { continue; }
+        let eq_pos = match line.find('=') {
+            Some(p) => p,
+            None => continue,
+        };
+        let full_key = &line[..eq_pos];
+        let value = &line[eq_pos + 1..];
+
+        if let Some(dot_pos) = full_key.rfind('.') {
+            let prefix = full_key[..dot_pos].to_string();
+            let key = full_key[dot_pos + 1..].to_string();
+            entries.entry(prefix).or_default().insert(key, value.to_string());
+        }
+    }
+
+    let mut labels = Vec::new();
+
+    for (prefix, props) in &entries {
+        // Audio: has "streamNumber" or "audioStream" and audio-related class
+        let is_audio = props.get("class").map_or(false, |c| c.contains("AudioButton"))
+            || prefix.starts_with("audio_");
+        let is_subtitle = props.get("class").map_or(false, |c| c.contains("SubtitleButton"))
+            || prefix.starts_with("subtitle_");
+
+        let stream_num_str = props.get("streamNumber")
+            .or_else(|| props.get("audioStream"))
+            .or_else(|| props.get("subtitleStream"));
+
+        let stream_num: u16 = match stream_num_str.and_then(|s| s.parse().ok()) {
+            Some(n) if n > 0 => n,
+            _ => continue,
+        };
+
+        if !is_audio && !is_subtitle { continue; }
+
+        let name = props.get("name").cloned().unwrap_or_default();
+        let name_lower = name.to_lowercase();
+
+        let purpose = if name_lower.contains("comment") || prefix.contains("comm") {
+            LabelPurpose::Commentary
+        } else {
+            LabelPurpose::Normal
+        };
+
+        let qualifier = if is_subtitle && name_lower.contains("sdh") {
+            LabelQualifier::Sdh
+        } else {
+            LabelQualifier::None
+        };
+
+        let stream_type = if is_audio { StreamLabelType::Audio } else { StreamLabelType::Subtitle };
+
+        // Try to extract language from audioLanguage/subtitleLanguage prop
+        let language = props.get("audioLanguage")
+            .or_else(|| props.get("subtitleLanguage"))
+            .cloned()
+            .unwrap_or_default();
+
+        labels.push(StreamLabel {
+            stream_number: stream_num,
+            stream_type,
+            language,
+            name,
+            purpose,
+            qualifier,
+            codec_hint: String::new(),
+            variant: String::new(),
+        });
+    }
+
+    if labels.is_empty() { return None; }
+    labels.sort_by_key(|l| (l.stream_type as u8, l.stream_number));
+    Some(labels)
+}

src/labels/mod.rs

@@ -0,0 +1,175 @@
+//! Stream label extraction from BD-J disc files.
+//!
+//! Each parser module represents one BD-J authoring framework.
+//! To add a new format:
+//!   1. Create `src/labels/myformat.rs`
+//!   2. Implement `pub fn detect(udf: &UdfFs) -> bool`
+//!   3. Implement `pub fn parse(session: &mut DriveSession, udf: &UdfFs) -> Option<Vec<StreamLabel>>`
+//!   4. Add `mod myformat;` below and one line to `PARSERS` array
+
+mod paramount;
+mod criterion;
+mod pixelogic;
+mod ctrm;
+pub mod vocab;
+
+use crate::drive::DriveSession;
+use crate::udf::UdfFs;
+use crate::disc::{Title, Stream};
+
+/// A stream label extracted from disc config files.
+#[derive(Debug, Clone)]
+pub struct StreamLabel {
+    /// STN index (1-based)
+    pub stream_number: u16,
+    /// Audio or Subtitle
+    pub stream_type: StreamLabelType,
+    /// ISO 639-2 language code
+    pub language: String,
+    /// Display name (e.g. "Commentary", "Descriptive Audio")
+    pub name: String,
+    /// Stream purpose
+    pub purpose: LabelPurpose,
+    /// Additional qualifier
+    pub qualifier: LabelQualifier,
+    /// Codec hint from config (e.g. "TrueHD", "Dolby Digital", "Dolby Atmos")
+    pub codec_hint: String,
+    /// Regional variant (e.g. "US", "UK", "Castilian", "Canadian")
+    pub variant: String,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum StreamLabelType {
+    Audio,
+    Subtitle,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum LabelPurpose {
+    Normal,
+    Commentary,
+    Descriptive,
+    Score,
+    Ime,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum LabelQualifier {
+    None,
+    Sdh,
+    DescriptiveService,
+    Forced,
+}
+
+// ── Parser registry ────────────────────────────────────────────────────────
+//
+// Each entry: (name, detect_fn, parse_fn)
+// Order = priority. First match wins. Highest quality output first.
+
+type DetectFn = fn(&UdfFs) -> bool;
+type ParseFn = fn(&mut DriveSession, &UdfFs) -> Option<Vec<StreamLabel>>;
+
+const PARSERS: &[(&str, DetectFn, ParseFn)] = &[
+    ("paramount",  paramount::detect,  paramount::parse),
+    ("criterion",  criterion::detect,  criterion::parse),
+    ("pixelogic",  pixelogic::detect,  pixelogic::parse),
+    ("ctrm",       ctrm::detect,       ctrm::parse),
+    // ("deluxe",  deluxe::detect,     deluxe::parse),  // TODO: bytecode parser
+];
+
+/// Search disc for config files, extract labels, apply to streams.
+/// This is 100% optional — if anything fails, streams are untouched.
+pub fn apply(session: &mut DriveSession, udf: &UdfFs, titles: &mut [Title]) {
+    let labels = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        extract(session, udf)
+    })).unwrap_or_default();
+    if labels.is_empty() { return; }
+
+    for title in titles.iter_mut() {
+        let mut audio_idx: u16 = 0;
+        let mut sub_idx: u16 = 0;
+
+        for stream in &mut title.streams {
+            match stream {
+                Stream::Audio(a) => {
+                    audio_idx += 1;
+                    if let Some(label) = labels.iter().find(|l|
+                        l.stream_type == StreamLabelType::Audio && l.stream_number == audio_idx
+                    ) {
+                        let mut parts = Vec::new();
+                        match label.purpose {
+                            LabelPurpose::Commentary => parts.push("Commentary".to_string()),
+                            LabelPurpose::Descriptive => parts.push("Descriptive Audio".to_string()),
+                            LabelPurpose::Score => parts.push("Score".to_string()),
+                            LabelPurpose::Ime => parts.push("IME".to_string()),
+                            LabelPurpose::Normal => {}
+                        }
+                        if !label.variant.is_empty() {
+                            parts.push(format!("({})", label.variant));
+                        }
+                        if !label.codec_hint.is_empty() {
+                            parts.push(label.codec_hint.clone());
+                        }
+                        if !parts.is_empty() {
+                            a.label = parts.join(" ");
+                        } else if !label.name.is_empty() {
+                            a.label = label.name.clone();
+                        }
+                    }
+                }
+                Stream::Subtitle(s) => {
+                    sub_idx += 1;
+                    if let Some(label) = labels.iter().find(|l|
+                        l.stream_type == StreamLabelType::Subtitle && l.stream_number == sub_idx
+                    ) {
+                        if label.qualifier == LabelQualifier::Forced {
+                            s.forced = true;
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+}
+
+fn extract(session: &mut DriveSession, udf: &UdfFs) -> Vec<StreamLabel> {
+    for (_name, detect, parse) in PARSERS {
+        if detect(udf) {
+            if let Some(labels) = parse(session, udf) {
+                return labels;
+            }
+        }
+    }
+    Vec::new()
+}
+
+// ── Shared helpers ─────────────────────────────────────────────────────────
+
+/// Check if a file exists in any BDMV/JAR subdirectory.
+pub(crate) fn jar_file_exists(udf: &UdfFs, filename: &str) -> bool {
+    find_jar_file(udf, filename).is_some()
+}
+
+/// Find a file in any BDMV/JAR subdirectory, return its path.
+pub(crate) fn find_jar_file(udf: &UdfFs, filename: &str) -> Option<String> {
+    let jar_dir = udf.find_dir("/BDMV/JAR")?;
+    for entry in &jar_dir.entries {
+        if entry.is_dir {
+            let path = format!("/BDMV/JAR/{}/{}", entry.name, filename);
+            // Check if file exists in this subdirectory
+            for child in &entry.entries {
+                if !child.is_dir && child.name.eq_ignore_ascii_case(filename) {
+                    return Some(path);
+                }
+            }
+        }
+    }
+    None
+}
+
+/// Read a file from any BDMV/JAR subdirectory by filename.
+pub(crate) fn read_jar_file(session: &mut DriveSession, udf: &UdfFs, filename: &str) -> Option<Vec<u8>> {
+    let path = find_jar_file(udf, filename)?;
+    udf.read_file(session, &path).ok().filter(|d| !d.is_empty())
+}

src/labels/paramount.rs

@@ -0,0 +1,142 @@
+//! Paramount/onQ — `playlists.xml`
+//!
+//! Richest structured format. Complete language lists with forced flags
+//! and commentary indices per playlist, all in XML attributes.
+//!
+//! ```xml
+//! <playlist name="Feature" id="00222"
+//!   aud="eng,deu,spa,spa,fra"
+//!   sub="eng,eng,zho,ces,dan"
+//!   forced_sub="0,0,0,1,0"
+//!   aud_com1_idx="10"
+//!   sub_com1_idx="23,24,25" />
+//! ```
+
+use crate::drive::DriveSession;
+use crate::udf::UdfFs;
+use super::{StreamLabel, StreamLabelType, LabelPurpose, LabelQualifier};
+
+pub fn detect(udf: &UdfFs) -> bool {
+    super::jar_file_exists(udf, "playlists.xml")
+}
+
+pub fn parse(session: &mut DriveSession, udf: &UdfFs) -> Option<Vec<StreamLabel>> {
+    let data = super::read_jar_file(session, udf, "playlists.xml")?;
+    let text = std::str::from_utf8(&data).ok()?;
+
+    // Find the feature playlist — longest duration or name="Feature"
+    let feature = find_feature_playlist(text)?;
+
+    let mut labels = Vec::new();
+
+    // Parse audio streams
+    if let Some(aud) = extract_attr(&feature, "aud") {
+        let com_idx = extract_attr(&feature, "aud_com1_idx")
+            .and_then(|s| s.parse::<usize>().ok());
+
+        for (i, lang) in aud.split(',').enumerate() {
+            let lang = lang.trim();
+            if lang.is_empty() { continue; }
+            let purpose = if com_idx == Some(i) {
+                LabelPurpose::Commentary
+            } else {
+                LabelPurpose::Normal
+            };
+            labels.push(StreamLabel {
+                stream_number: (i + 1) as u16,
+                stream_type: StreamLabelType::Audio,
+                language: lang.to_string(),
+                name: String::new(),
+                purpose,
+                qualifier: LabelQualifier::None,
+                codec_hint: String::new(),
+                variant: String::new(),
+            });
+        }
+    }
+
+    // Parse subtitle streams
+    if let Some(sub) = extract_attr(&feature, "sub") {
+        let forced: Vec<bool> = extract_attr(&feature, "forced_sub")
+            .map(|s| s.split(',').map(|f| f.trim() == "1").collect())
+            .unwrap_or_default();
+
+        let com_indices: Vec<usize> = extract_attr(&feature, "sub_com1_idx")
+            .map(|s| s.split(',').filter_map(|i| i.trim().parse().ok()).collect())
+            .unwrap_or_default();
+
+        for (i, lang) in sub.split(',').enumerate() {
+            let lang = lang.trim();
+            if lang.is_empty() { continue; }
+
+            let purpose = if com_indices.contains(&i) {
+                LabelPurpose::Commentary
+            } else {
+                LabelPurpose::Normal
+            };
+
+            let qualifier = if forced.get(i).copied().unwrap_or(false) {
+                LabelQualifier::Forced
+            } else {
+                LabelQualifier::None
+            };
+
+            labels.push(StreamLabel {
+                stream_number: (i + 1) as u16,
+                stream_type: StreamLabelType::Subtitle,
+                language: lang.to_string(),
+                name: String::new(),
+                purpose,
+                qualifier,
+                codec_hint: String::new(),
+                variant: String::new(),
+            });
+        }
+    }
+
+    if labels.is_empty() { return None; }
+    Some(labels)
+}
+
+/// Find the feature playlist element (the one with the most audio tracks).
+fn find_feature_playlist(xml: &str) -> Option<String> {
+    let mut best: Option<String> = None;
+    let mut best_aud_count = 0;
+
+    let mut pos = 0;
+    while let Some(start) = xml[pos..].find("<playlist ") {
+        let abs_start = pos + start;
+        let end = match xml[abs_start..].find("/>") {
+            Some(p) => abs_start + p + 2,
+            None => break,
+        };
+        let element = &xml[abs_start..end];
+
+        // Prefer name="Feature" explicitly
+        if let Some(name) = extract_attr(element, "name") {
+            if name.eq_ignore_ascii_case("Feature") {
+                return Some(element.to_string());
+            }
+        }
+
+        // Otherwise pick the one with the most audio streams
+        if let Some(aud) = extract_attr(element, "aud") {
+            let count = aud.split(',').count();
+            if count > best_aud_count {
+                best_aud_count = count;
+                best = Some(element.to_string());
+            }
+        }
+
+        pos = end;
+    }
+    best
+}
+
+/// Extract an XML attribute value from an element string.
+fn extract_attr<'a>(element: &'a str, name: &str) -> Option<String> {
+    let needle = format!("{}=\"", name);
+    let start = element.find(&needle)? + needle.len();
+    let end = element[start..].find('"')? + start;
+    Some(element[start..end].to_string())
+}

src/labels/pixelogic.rs

@@ -0,0 +1,134 @@
+//! Pixelogic — `bluray_project.bin`
+//!
+//! Binary file with embedded UTF-8 token strings in STN order per
+//! playlist section. Most common format (5/10 test discs).
+//!
+//! Token format: `{lang}_{codec?}_{purpose?}_{region?}_`
+
+use crate::drive::DriveSession;
+use crate::udf::UdfFs;
+use super::{StreamLabel, StreamLabelType, LabelPurpose, LabelQualifier, vocab};
+
+/// Known audio codec tokens
+const AUDIO_CODECS: &[&str] = &["MLP", "AC3", "DTS", "DDL", "WAV", "AC"];
+/// Known region tokens
+const REGIONS: &[&str] = &["US", "UK", "CF", "PF", "CS", "LS", "BP", "PP", "SM", "TM", "CAN", "DUM", "FLE"];
+
+pub fn detect(udf: &UdfFs) -> bool {
+    super::jar_file_exists(udf, "bluray_project.bin")
+}
+
+pub fn parse(session: &mut DriveSession, udf: &UdfFs) -> Option<Vec<StreamLabel>> {
+    let data = super::read_jar_file(session, udf, "bluray_project.bin")?;
+    let strings = extract_strings(&data);
+
+    let mut labels = Vec::new();
+    let mut in_feature = false;
+    let mut audio_num: u16 = 0;
+    let mut sub_num: u16 = 0;
+
+    for s in &strings {
+        // Detect feature section start
+        if s.starts_with("FPL_") || s.starts_with("SEG_MainFeature") {
+            if in_feature { break; }
+            in_feature = true;
+            audio_num = 0;
+            sub_num = 0;
+            continue;
+        }
+
+        // Detect section end
+        if in_feature && (s.starts_with("SEG_") || s.starts_with("SF_") || s.starts_with("FPL_")) {
+            break;
+        }
+
+        if !in_feature { continue; }
+
+        if let Some(label) = parse_token(s) {
+            match label.stream_type {
+                StreamLabelType::Audio => {
+                    audio_num += 1;
+                    labels.push(StreamLabel { stream_number: audio_num, ..label });
+                }
+                StreamLabelType::Subtitle => {
+                    sub_num += 1;
+                    labels.push(StreamLabel { stream_number: sub_num, ..label });
+                }
+            }
+        }
+    }
+
+    if labels.is_empty() { return None; }
+    Some(labels)
+}
+
+fn parse_token(s: &str) -> Option<StreamLabel> {
+    let clean = s.trim().trim_start_matches('\t').trim_end_matches('_');
+    let parts: Vec<&str> = clean.split('_').collect();
+    if parts.len() < 2 { return None; }
+
+    let lang = parts[0];
+    if lang.len() != 3 || !lang.chars().all(|c| c.is_ascii_lowercase()) {
+        return None;
+    }
+
+    let mut codec = String::new();
+    let mut purpose = LabelPurpose::Normal;
+    let mut qualifier = LabelQualifier::None;
+    let mut variant = String::new();
+    let mut is_subtitle = false;
+    let mut is_audio = false;
+
+    for &part in &parts[1..] {
+        if part.is_empty() { continue; }
+        if AUDIO_CODECS.contains(&part) { codec = vocab::codec(part).to_string(); is_audio = true; }
+        else if part == "ADES" { purpose = LabelPurpose::Descriptive; is_audio = true; }
+        else if part == "ACOM" { purpose = LabelPurpose::Commentary; is_audio = true; }
+        else if part == "ADLG" { is_audio = true; }
+        else if part == "ATRI" { is_audio = true; }
+        else if part == "SDH" { qualifier = LabelQualifier::Sdh; is_subtitle = true; }
+        else if part == "SDLG" { is_subtitle = true; }
+        else if part == "SCOM" { purpose = LabelPurpose::Commentary; is_subtitle = true; }
+        else if part == "STRI" { is_subtitle = true; }
+        else if part == "TXT" { is_subtitle = true; }
+        else if part == "FOR" { qualifier = LabelQualifier::Forced; }
+        else if REGIONS.contains(&part) { variant = part.to_string(); }
+        else if part.starts_with("PGStream") { is_subtitle = true; }
+        else { return None; }
+    }
+
+    if !is_audio && !is_subtitle { return None; }
+
+    let stream_type = if is_subtitle { StreamLabelType::Subtitle } else { StreamLabelType::Audio };
+
+    Some(StreamLabel {
+        stream_number: 0,
+        stream_type,
+        language: lang.to_string(),
+        name: String::new(),
+        purpose,
+        qualifier,
+        codec_hint: codec,
+        variant,
+    })
+}
+
+fn extract_strings(data: &[u8]) -> Vec<String> {
+    let mut strings = Vec::new();
+    let mut current = String::new();
+
+    for &b in data {
+        if b >= 0x20 && b < 0x7f {
+            current.push(b as char);
+        } else {
+            if current.len() > 3 {
+                strings.push(current.clone());
+            }
+            current.clear();
+        }
+    }
+    if current.len() > 3 {
+        strings.push(current);
+    }
+    strings
+}

src/labels/vocab.rs

@@ -0,0 +1,27 @@
+//! Shared label vocabulary — values we are 100% confident about.
+//!
+//! Labels come from BD-J authoring tool files (bluray_project.bin,
+//! playlists.xml, menu_base.prop, etc.) — NOT from BD spec fields.
+//! This is NOT for MPLS/CLPI/STN data. Those follow the BD spec directly.
+//!
+//! Rules:
+//! - Only map values we are 100% certain about (published codec names).
+//! - Unknown codes (csp, eda, cf, etc.) pass through raw from disc.
+//! - The app/CLI handles display text, not the lib.
+
+/// Map a codec identifier found in label data to its display name.
+///
+/// These are well-known codec identifiers used across multiple BD-J
+/// authoring tools. NOT BD spec STN codec IDs — those are decoded
+/// separately in mpls.rs.
+pub fn codec(code: &str) -> &str {
+    match code {
+        "MLP" => "TrueHD",
+        "AC3" | "AC" => "Dolby Digital",
+        "DTS" => "DTS",
+        "DDL" => "Dolby Digital Plus",
+        "WAV" => "PCM",
+        "atmos" => "Dolby Atmos",
+        _ => code,
+    }
+}

src/lib.rs

@@ -77,8 +77,8 @@ pub mod udf;
 pub mod mpls;
 pub mod clpi;
 pub mod disc;
-pub mod jar;
 pub mod aacs;
+pub mod labels;
 
 pub use error::{Error, Result};
 pub use drive::DriveSession;
@@ -87,5 +87,6 @@ pub use profile::{DriveProfile, Chipset};
 pub use platform::{Platform, DriveStatus};
 pub use scsi::ScsiTransport;
 pub use speed::DriveSpeed;
-pub use disc::{Disc, Title, Stream, StreamKind, Codec, HdrFormat, ColorSpace,
+pub use disc::{Disc, DiscFormat, Title, Clip, Stream, VideoStream, AudioStream, SubtitleStream,
+               Codec, HdrFormat, ColorSpace,
                Extent, ContentReader, AacsState, KeySource, ScanOptions};

src/mpls.rs

@@ -35,22 +35,28 @@ pub struct PlayItem {
 /// A stream entry from the STN table.
 #[derive(Debug, Clone)]
 pub struct StreamEntry {
-    /// Stream category: 1=primary video, 2=primary audio, 3=PG subtitle, 4=IG
+    /// Stream category: 1=video, 2=audio, 3=PG subtitle, 4=IG, 5=secondary audio, 6=secondary video, 7=DV EL
     pub stream_type: u8,
     /// MPEG-TS PID
     pub pid: u16,
     /// Coding type (0x24=HEVC, 0x1B=H264, 0x83=TrueHD, etc.)
     pub coding_type: u8,
-    /// Video format (1=480i, 6=1080p, 8=2160p, etc.)
+    /// Video format (1=480i, 4=1080i, 5=720p, 6=1080p, 8=2160p)
     pub video_format: u8,
-    /// Video frame rate (1=23.976, 3=25, 4=29.97, etc.)
+    /// Video frame rate (1=23.976, 2=24, 3=25, 4=29.97, 6=50, 7=59.94)
     pub video_rate: u8,
-    /// Audio format (3=stereo, 6=5.1, 12=7.1, etc.)
+    /// Audio channel layout (1=mono, 3=stereo, 6=5.1, 12=7.1)
     pub audio_format: u8,
     /// Audio sample rate (1=48kHz, 4=96kHz, 5=192kHz)
     pub audio_rate: u8,
     /// ISO 639-2 language code (e.g. "eng")
     pub language: String,
+    /// HDR dynamic range (0=SDR, 1=HDR10, 2=Dolby Vision)
+    pub dynamic_range: u8,
+    /// Color space (0=unknown, 1=BT.709, 2=BT.2020)
+    pub color_space: u8,
+    /// Whether this is a secondary stream (commentary, PiP, DV EL)
+    pub secondary: bool,
 }
 
 /// Parse an MPLS file from raw bytes.
@@ -58,40 +64,31 @@ pub fn parse(data: &[u8]) -> Result<Playlist> {
     if data.len() < 40 {
         return Err(Error::DiscError { detail: "MPLS too short".into() });
     }
-
-    // Header: "MPLS" + version (4 bytes ASCII)
     if &data[0..4] != b"MPLS" {
         return Err(Error::DiscError { detail: "not an MPLS file".into() });
     }
-    let version = String::from_utf8_lossy(&data[4..8]).to_string();
 
-    // Offsets table at bytes 8-19
+    let version = String::from_utf8_lossy(&data[4..8]).to_string();
     let playlist_start = u32::from_be_bytes([data[8], data[9], data[10], data[11]]) as usize;
 
     if playlist_start + 10 > data.len() {
         return Err(Error::DiscError { detail: "MPLS playlist offset out of range".into() });
     }
 
-    // PlayList section
     let pl = &data[playlist_start..];
     let num_play_items = u16::from_be_bytes([pl[6], pl[7]]) as usize;
 
     let mut play_items = Vec::with_capacity(num_play_items);
     let mut streams = Vec::new();
-    let mut pos = 10; // start of first play item
+    let mut pos = 10;
 
     for item_idx in 0..num_play_items {
-        if playlist_start + pos + 2 > data.len() {
-            break;
-        }
-
+        if pos + 2 > pl.len() { break; }
         let item_length = u16::from_be_bytes([pl[pos], pl[pos + 1]]) as usize;
-        if playlist_start + pos + item_length + 2 > data.len() {
-            break;
-        }
+        if pos + 2 + item_length > pl.len() { break; }
 
         let item = &pl[pos + 2..pos + 2 + item_length];
-        if item.len() < 20 { break; }
+        if item.len() < 20 { pos += 2 + item_length; continue; }
 
         let clip_id = String::from_utf8_lossy(&item[0..5]).to_string();
         let connection_condition = item[9] & 0x0F;
@@ -99,83 +96,91 @@ pub fn parse(data: &[u8]) -> Result<Playlist> {
         let out_time = u32::from_be_bytes([item[16], item[17], item[18], item[19]]);
 
         // Parse STN table from the first play item
-        if item_idx == 0 && item.len() > 32 {
-            // UO mask is 8 bytes (64 bits) at offset 20
-            // STN table starts after: 2 bytes length + 2 bytes reserved + UO mask (8 bytes)
-            // STN offset within play_item = 20 (UO start)
-            // Actually: offset 20 = UO_mask_table (8 bytes)
-            //           offset 28 = random_access_flag + ... (2 bytes)
-            //           offset 30 = still_mode (1 byte) + still_time (2 bytes if still)
-            // Then STN table
-            // The STN table position varies. Let's find it by looking for the STN length field.
+        // PlayItem layout after out_time:
+        //   [20:28] UO_mask_table (8 bytes)
+        //   [28]    misc flags (1 byte)
+        //   [29]    still_mode (1 byte)
+        //   [30:32] still_time (2 bytes)
+        //   [32:]   STN_table
+        const STN_OFFSET: usize = 32;
+        if item_idx == 0 && item.len() > STN_OFFSET + 16 {
+            // STN header: length(2) + reserved(2) + counts(8) + reserved(4) = 16 bytes
+            let n_video = item[STN_OFFSET + 4] as usize;
+            let n_audio = item[STN_OFFSET + 5] as usize;
+            let n_pg = item[STN_OFFSET + 6] as usize;
+            let n_ig = item[STN_OFFSET + 7] as usize;
+            let n_sec_audio = item[STN_OFFSET + 8] as usize;
+            let n_sec_video = item[STN_OFFSET + 9] as usize;
+            let _n_pip_pg = item[STN_OFFSET + 10] as usize;
+            let n_dv = item[STN_OFFSET + 11] as usize;
 
-            // Per BD spec: play_item structure after out_time:
-            //   [20..28] UO_mask_table (8 bytes)
-            //   [28] misc flags (1 byte)
-            //   [29] still_mode (1 byte)
-            //   [30..32] still_time (2 bytes) if still_mode != 0
-            //   Then STN_table
+            let mut spos = STN_OFFSET + 16;
 
-            let still_mode = if item.len() > 29 { item[29] } else { 0 };
-            let stn_offset = if still_mode != 0 { 32 } else { 32 };
-            // Actually it's always 32 based on our previous work (UO mask = 8 bytes, not 64)
-
-            if item.len() > stn_offset + 6 {
-                let stn = &item[stn_offset..];
-                let _stn_length = u16::from_be_bytes([stn[0], stn[1]]) as usize;
-                if stn.len() > 6 {
-                    // reserved 2 bytes at [2..4]
-                    let n_video = stn[4] as usize;
-                    let n_audio = stn[5] as usize;
-                    let n_pg = if stn.len() > 6 { stn[6] as usize } else { 0 };
-                    let n_ig = if stn.len() > 7 { stn[7] as usize } else { 0 };
-
-                    // Parse stream entries starting at offset 8
-                    // But there's another 2 bytes reserved before entries
-                    let mut stn_pos = 8;
-                    // Possible 2 more reserved bytes
-                    // Let's skip and parse entries
-
-                    // Primary video streams
-                    for _ in 0..n_video {
-                        if let Some((entry, len)) = parse_stream_entry(stn, stn_pos, 1) {
-                            streams.push(entry);
-                            stn_pos += len;
-                        } else {
-                            break;
-                        }
-                    }
-
-                    // Primary audio streams
-                    for _ in 0..n_audio {
-                        if let Some((entry, len)) = parse_stream_entry(stn, stn_pos, 2) {
-                            streams.push(entry);
-                            stn_pos += len;
-                        } else {
-                            break;
-                        }
-                    }
-
-                    // PG (subtitle) streams
-                    for _ in 0..n_pg {
-                        if let Some((entry, len)) = parse_stream_entry(stn, stn_pos, 3) {
-                            streams.push(entry);
-                            stn_pos += len;
-                        } else {
-                            break;
-                        }
-                    }
-
-                    // IG streams
-                    for _ in 0..n_ig {
-                        if let Some((entry, len)) = parse_stream_entry(stn, stn_pos, 4) {
-                            streams.push(entry);
-                            stn_pos += len;
-                        } else {
-                            break;
-                        }
-                    }
-                }
+            // Primary video
+            for _ in 0..n_video {
+                if let Some((entry, next)) = parse_stream_entry(item, spos, 1) {
+                    streams.push(entry);
+                    spos = next;
+                } else { break; }
+            }
+            // Primary audio
+            for _ in 0..n_audio {
+                if let Some((entry, next)) = parse_stream_entry(item, spos, 2) {
+                    streams.push(entry);
+                    spos = next;
+                } else { break; }
+            }
+            // PG subtitles
+            for _ in 0..n_pg {
+                if let Some((entry, next)) = parse_stream_entry(item, spos, 3) {
+                    streams.push(entry);
+                    spos = next;
+                } else { break; }
+            }
+            // IG (skip but advance)
+            for _ in 0..n_ig {
+                if let Some((_, next)) = parse_stream_entry(item, spos, 4) {
+                    spos = next;
+                } else { break; }
+            }
+            // Secondary audio
+            for _ in 0..n_sec_audio {
+                if let Some((mut entry, next)) = parse_stream_entry(item, spos, 2) {
+                    entry.stream_type = 5;
+                    entry.secondary = true;
+                    streams.push(entry);
+                    // Skip extra ref bytes: num_refs(1) + reserved(1) + refs + padding
+                    if next < item.len() {
+                        let n_refs = item[next] as usize;
+                        spos = next + 2 + n_refs + (n_refs % 2);
+                    } else { spos = next; }
+                } else { break; }
+            }
+            // Secondary video (PiP)
+            for _ in 0..n_sec_video {
+                if let Some((mut entry, next)) = parse_stream_entry(item, spos, 1) {
+                    entry.stream_type = 6;
+                    entry.secondary = true;
+                    streams.push(entry);
+                    // Skip extra ref bytes (audio refs + PG refs)
+                    if next + 2 < item.len() {
+                        let n_arefs = item[next] as usize;
+                        let after_arefs = next + 2 + n_arefs + (n_arefs % 2);
+                        if after_arefs < item.len() {
+                            let n_prefs = item[after_arefs] as usize;
+                            spos = after_arefs + 2 + n_prefs + (n_prefs % 2);
+                        } else { spos = after_arefs; }
+                    } else { spos = next; }
+                } else { break; }
+            }
+            // Dolby Vision enhancement layer
+            for _ in 0..n_dv {
+                if let Some((mut entry, next)) = parse_stream_entry(item, spos, 1) {
+                    entry.stream_type = 7;
+                    entry.secondary = true;
+                    streams.push(entry);
+                    spos = next;
+                } else { break; }
             }
         }
 
@@ -197,87 +202,70 @@ pub fn parse(data: &[u8]) -> Result<Playlist> {
 }
 
 /// Parse one stream entry from the STN table.
-/// Returns (StreamEntry, bytes consumed) or None.
-fn parse_stream_entry(stn: &[u8], pos: usize, stream_type: u8) -> Option<(StreamEntry, usize)> {
-    if pos + 2 > stn.len() { return None; }
+/// Returns (StreamEntry, next position) or None.
+fn parse_stream_entry(item: &[u8], pos: usize, stream_type: u8) -> Option<(StreamEntry, usize)> {
+    if pos + 2 > item.len() { return None; }
 
-    // Stream entry format:
-    //   [0] length of stream entry (1 byte)
-    //   [1] stream_type (1=PlayItem, 2=SubPath, 3=InMux)
-    //   Then stream_pid reference (varies by stream_type)
-    //   Then stream attributes
+    // Stream entry: length(1) + data
+    let se_len = item[pos] as usize;
+    let se_end = pos + 1 + se_len;
+    if se_end > item.len() { return None; }
 
-    let entry_len = stn[pos] as usize;
-    if entry_len < 4 || pos + 1 + entry_len > stn.len() { return None; }
-
-    let entry = &stn[pos + 1..pos + 1 + entry_len];
-
-    // Stream entry: type(1) + ref_type-dependent PID extraction
-    // For type 1 (PlayItem stream): [0]=type, [1..3]=ref_to_stream_PID_of_playItem
-    // ref format: [0] = subpath/playitem ref type, [1..2] = PID (big-endian u16)
-    let pid = if entry.len() >= 3 {
-        u16::from_be_bytes([entry[1], entry[2]])
+    // PID from stream entry (type 0x01 = PlayItem stream: PID at bytes 2-3)
+    let pid = if item[pos + 1] == 0x01 && pos + 4 <= item.len() {
+        u16::from_be_bytes([item[pos + 2], item[pos + 3]])
     } else {
         0
     };
 
-    // Stream attributes follow after the PID reference
-    // Attributes block: length(1) + coding_type(1) + format-specific data + language(3)
-    let attr_start = pos + 1 + entry_len;
-    if attr_start + 2 > stn.len() { return None; }
+    // Stream attributes: length(1) + coding_type(1) + format-specific data
+    if se_end + 2 > item.len() { return None; }
+    let sa_len = item[se_end] as usize;
+    let sa_end = se_end + 1 + sa_len;
+    if sa_end > item.len() || sa_len < 1 { return None; }
 
-    let attr_len = stn[attr_start] as usize;
-    if attr_len < 4 || attr_start + 1 + attr_len > stn.len() {
-        return Some((StreamEntry {
-            stream_type, pid, coding_type: 0, video_format: 0, video_rate: 0,
-            audio_format: 0, audio_rate: 0, language: String::new(),
-        }, 1 + entry_len + 1 + attr_len.max(1)));
-    }
-
-    let attr = &stn[attr_start + 1..attr_start + 1 + attr_len];
-    let coding_type = attr[0];
+    let sa = &item[se_end + 1..se_end + 1 + sa_len];
+    let coding_type = sa[0];
 
     let mut video_format = 0u8;
     let mut video_rate = 0u8;
     let mut audio_format = 0u8;
     let mut audio_rate = 0u8;
+    let mut dynamic_range = 0u8;
+    let mut color_space_val = 0u8;
     let mut language = String::new();
 
     match stream_type {
         1 => {
-            // Video: coding_type(1) + format_and_rate(1) + ...
-            if attr.len() >= 2 {
-                video_format = (attr[1] >> 4) & 0x0F;
-                video_rate = attr[1] & 0x0F;
+            // Video: coding_type(1) + format_rate(1) + [hdr_info(1) if HEVC]
+            if sa.len() >= 2 {
+                video_format = (sa[1] >> 4) & 0x0F;
+                video_rate = sa[1] & 0x0F;
+            }
+            if coding_type == 0x24 && sa.len() > 2 {
+                dynamic_range = (sa[2] >> 4) & 0x0F;
+                color_space_val = sa[2] & 0x0F;
             }
         }
         2 => {
-            // Audio: coding_type(1) + format_and_rate(1) + language(3)
-            if attr.len() >= 2 {
-                audio_format = (attr[1] >> 4) & 0x0F;
-                audio_rate = attr[1] & 0x0F;
+            // Audio: coding_type(1) + format_rate(1) + language(3)
+            if sa.len() >= 2 {
+                audio_format = (sa[1] >> 4) & 0x0F;
+                audio_rate = sa[1] & 0x0F;
             }
-            if attr.len() >= 5 {
-                language = String::from_utf8_lossy(&attr[2..5]).to_string();
+            if sa.len() >= 5 {
+                language = String::from_utf8_lossy(&sa[2..5]).to_string();
             }
         }
-        3 => {
-            // PG subtitle: coding_type(1) + language(3)
-            if attr.len() >= 4 {
-                language = String::from_utf8_lossy(&attr[1..4]).to_string();
-            }
-        }
-        4 => {
-            // IG: coding_type(1) + language(3)
-            if attr.len() >= 4 {
-                language = String::from_utf8_lossy(&attr[1..4]).to_string();
+        3 | 4 => {
+            // PG/IG: coding_type(1) + language(3)
+            if sa.len() >= 4 {
+                language = String::from_utf8_lossy(&sa[1..4]).to_string();
             }
         }
         _ => {}
     }
 
-    let total_consumed = 1 + entry_len + 1 + attr_len;
-
     Some((StreamEntry {
         stream_type,
         pid,
@@ -287,5 +275,8 @@ fn parse_stream_entry(stn: &[u8], pos: usize, stream_type: u8) -> Option<(Stream
         audio_format,
         audio_rate,
         language,
-    }, total_consumed))
+        dynamic_range,
+        color_space: color_space_val,
+        secondary: false,
+    }, sa_end))
 }

src/scsi/linux.rs

@@ -116,4 +116,5 @@ impl ScsiTransport for SgIoTransport {
             sense,
         })
     }
+
 }

src/scsi/macos.rs

@@ -368,6 +368,7 @@ impl ScsiTransport for MacScsiTransport {
             sense,
         })
     }
+
 }
 
 // ── IOKit service discovery ─────────────────────────────────────────────────

src/scsi/mod.rs

@@ -56,6 +56,7 @@ pub trait ScsiTransport {
         data: &mut [u8],
         timeout_ms: u32,
     ) -> Result<ScsiResult>;
+
 }
 
 // ── Platform-agnostic open ──────────────────────────────────────────────────

src/udf.rs

@@ -26,11 +26,15 @@ use crate::drive::DriveSession;
 pub struct UdfFs {
     /// Root directory with full tree
     pub root: DirEntry,
+    /// UDF Volume Identifier from Primary Volume Descriptor
+    pub volume_id: String,
     /// Physical partition start (absolute sector)
     partition_start: u32,
     /// Metadata partition start (absolute sector)
     /// For UDF 2.50 discs, all file/directory references use metadata-relative LBAs
     metadata_start: u32,
+    /// Metadata partition size in sectors
+    metadata_sectors: u32,
 }
 
 /// A directory or file entry.
@@ -47,6 +51,12 @@ pub struct DirEntry {
 }
 
 impl UdfFs {
+    /// Physical partition start sector.
+    pub fn partition_start(&self) -> u32 { self.partition_start }
+
+    /// Metadata partition start sector.
+    pub fn metadata_start(&self) -> u32 { self.metadata_start }
+
     /// Find a directory by path (e.g. "/BDMV/PLAYLIST").
     /// Path matching is case-insensitive.
     pub fn find_dir(&self, path: &str) -> Option<&DirEntry> {
@@ -102,6 +112,59 @@ impl UdfFs {
         Ok(data)
     }
 
+    /// Collect all sector ranges needed for disc-info and AACS.
+    ///
+    /// Returns a list of (start_lba, sector_count) ranges covering:
+    ///   - UDF structure (AVDP, VDS, metadata partition, directories)
+    ///   - BDMV/PLAYLIST/*.mpls, CLIPINF/*.clpi, JAR/*, META/*, *.bdmv
+    ///   - AACS/* (Content*.cer, Unit_Key_RO.inf, CPSUnit*.cci)
+    ///
+    /// Skips: STREAM/ (video), BACKUP/, DUPLICATE/,
+    ///   MKB_RO.inf, ContentHash*, ContentRevocation*
+    pub fn metadata_sector_ranges(&self, session: &mut DriveSession) -> Result<Vec<(u32, u32)>> {
+        let mut ranges = Vec::new();
+
+        // UDF structure: sector 0 through end of metadata partition
+        // Covers AVDP, VDS, partition descriptor, metadata ICB, FSD, all directories
+        let meta_end = self.metadata_start + self.metadata_sectors;
+        ranges.push((0, meta_end));
+
+        // Walk tree, collect ranges for each metadata file
+        self.collect_file_ranges(session, &self.root, &mut ranges)?;
+
+        // Merge overlapping/adjacent ranges and sort
+        ranges.sort_by_key(|r| r.0);
+        let merged = merge_ranges(&ranges);
+        Ok(merged)
+    }
+
+    fn collect_file_ranges(&self, session: &mut DriveSession, entry: &DirEntry, ranges: &mut Vec<(u32, u32)>) -> Result<()> {
+        for child in &entry.entries {
+            if child.is_dir {
+                // Only skip STREAM — those are the multi-GB video files
+                if child.name.eq_ignore_ascii_case("STREAM") {
+                    continue;
+                }
+                self.collect_file_ranges(session, child, ranges)?;
+            } else {
+                // Include the ICB sector itself (in metadata partition)
+                ranges.push((self.meta_to_abs(child.meta_lba), 1));
+
+                // Include file data — skip only truly huge files (MKB_RO.inf = 134MB)
+                if child.size > 50_000_000 {
+                    continue;
+                }
+
+                if let Ok((data_lba, data_len)) = self.read_icb_extent(session, child.meta_lba) {
+                    let abs_start = self.partition_start + data_lba;
+                    let sector_count = (data_len + 2047) / 2048;
+                    ranges.push((abs_start, sector_count));
+                }
+            }
+        }
+        Ok(())
+    }
+
     /// Convert a metadata-partition-relative LBA to an absolute sector number.
     fn meta_to_abs(&self, meta_lba: u32) -> u32 {
         self.metadata_start + meta_lba
@@ -181,6 +244,8 @@ pub fn read_filesystem(session: &mut DriveSession) -> Result<UdfFs> {
     let mut partition_start: u32 = 0;
     let mut num_partition_maps: u32 = 0;
     let mut lvd_sector: Option<u32> = None;
+    let mut volume_id = String::new();
+    let mut metadata_size_bytes: u32 = 0;
 
     for i in 32..64 {
         let mut desc = [0u8; 2048];
@@ -188,6 +253,10 @@ pub fn read_filesystem(session: &mut DriveSession) -> Result<UdfFs> {
 
         let desc_tag = u16::from_le_bytes([desc[0], desc[1]]);
         match desc_tag {
+            // Primary Volume Descriptor — volume identifier at offset 24, 32-byte d-string
+            1 => {
+                volume_id = parse_dstring(&desc[24..56]);
+            }
             // Partition Descriptor — tells us where the physical partition starts
             5 => {
                 partition_start = u32::from_le_bytes([desc[188], desc[189], desc[190], desc[191]]);
@@ -241,8 +310,9 @@ pub fn read_filesystem(session: &mut DriveSession) -> Result<UdfFs> {
                     let l_ea = u32::from_le_bytes([meta_icb[208], meta_icb[209],
                                                    meta_icb[210], meta_icb[211]]) as usize;
                     let ad_off = 216 + l_ea;
-                    let _ad_len = u32::from_le_bytes([meta_icb[ad_off], meta_icb[ad_off + 1],
+                    let ad_len = u32::from_le_bytes([meta_icb[ad_off], meta_icb[ad_off + 1],
                                                       meta_icb[ad_off + 2], meta_icb[ad_off + 3]]) & 0x3FFFFFFF;
+                    metadata_size_bytes = ad_len;
                     let ad_pos = u32::from_le_bytes([meta_icb[ad_off + 4], meta_icb[ad_off + 5],
                                                      meta_icb[ad_off + 6], meta_icb[ad_off + 7]]);
                     // Metadata content starts at partition_start + ad_pos
@@ -281,10 +351,14 @@ pub fn read_filesystem(session: &mut DriveSession) -> Result<UdfFs> {
     // Step 5: Read root directory and build file tree
     let root = read_directory(session, partition_start, metadata_start, root_lba, "", 0)?;
 
+    let metadata_sectors = (metadata_size_bytes + 2047) / 2048;
+
     Ok(UdfFs {
         root,
+        volume_id,
         partition_start,
         metadata_start,
+        metadata_sectors,
     })
 }
 
@@ -456,6 +530,52 @@ fn parse_udf_name(data: &[u8]) -> String {
     }
 }
 
+/// Merge overlapping or adjacent (start, count) ranges.
+fn merge_ranges(ranges: &[(u32, u32)]) -> Vec<(u32, u32)> {
+    if ranges.is_empty() { return Vec::new(); }
+    let mut result = vec![ranges[0]];
+    for &(start, count) in &ranges[1..] {
+        let last = result.last_mut().unwrap();
+        let last_end = last.0 + last.1;
+        if start <= last_end + 1 {
+            // Overlapping or adjacent — extend
+            let new_end = (start + count).max(last_end);
+            last.1 = new_end - last.0;
+        } else {
+            result.push((start, count));
+        }
+    }
+    result
+}
+
+/// Parse a UDF d-string (fixed-length field with length byte at the end).
+/// Used for Volume Identifier and other UDF descriptor strings.
+/// The first byte of content is a compression ID: 8 = ASCII, 16 = UTF-16BE.
+fn parse_dstring(data: &[u8]) -> String {
+    if data.is_empty() { return String::new(); }
+    let len = *data.last().unwrap() as usize;
+    if len == 0 || len > data.len() { return String::new(); }
+    let content = &data[..len];
+    if content.is_empty() { return String::new(); }
+    match content[0] {
+        8 => String::from_utf8_lossy(&content[1..]).trim_end_matches('\0').trim().to_string(),
+        16 => {
+            let mut s = String::new();
+            let chars = &content[1..];
+            for i in (0..chars.len()).step_by(2) {
+                if i + 1 < chars.len() {
+                    let c = ((chars[i] as u16) << 8) | chars[i + 1] as u16;
+                    if c != 0 {
+                        if let Some(ch) = char::from_u32(c as u32) { s.push(ch); }
+                    }
+                }
+            }
+            s.trim().to_string()
+        }
+        _ => String::from_utf8_lossy(&content[1..]).trim_end_matches('\0').trim().to_string(),
+    }
+}
+
 /// Read a single 2048-byte sector from the drive.
 /// Uses standard READ(10) — no unlock required.
 fn read_sector(session: &mut DriveSession, lba: u32, buf: &mut [u8]) -> Result<()> {