Add macOS SCSI support via IOKit SCSITaskDeviceInterface

IOKit backend for macOS optical drives. Accepts BSD device paths
(/dev/disk2), walks IORegistry to find authoring device, sends
SCSI commands through SCSITaskDeviceInterface COM vtable.

.github/workflows/update-readme.yml

@@ -0,0 +1,35 @@
+name: Update README version
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: write
+
+jobs:
+  update:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: main
+
+      - name: Update version in README
+        run: |
+          VERSION="${{ github.event.release.tag_name }}"
+          FILE="README.md"
+
+          # Update cargo dependency version (e.g. "0.2" -> "0.3")
+          MAJOR_MINOR="${VERSION#v}"
+          MAJOR_MINOR="${MAJOR_MINOR%.*}"
+          sed -i "s|libfreemkv = \"[0-9]*\.[0-9]*\"|libfreemkv = \"${MAJOR_MINOR}\"|" "$FILE"
+
+      - name: Commit and push
+        run: |
+          VERSION="${{ github.event.release.tag_name }}"
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add README.md
+          git diff --cached --quiet || git commit -m "Update to libfreemkv ${VERSION}"
+          git push

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "libfreemkv"
-version = "0.2.1"
+version = "0.3.1"
 edition = "2021"
 license = "AGPL-3.0-only"
 description = "Open source raw disc access library for optical drives"
@@ -15,14 +15,16 @@ sha1 = "0.10"
 aes = "0.8"
 cbc = "0.1"
 flate2 = "1"
+num-bigint = "0.4"
+num-traits = "0.2"
+num-integer = "0.1"
+rand = "0.8"
+cmac = "0.7"
+zip = { version = "2", default-features = false, features = ["deflate"] }
 
 [target.'cfg(target_os = "linux")'.dependencies]
 libc = "0.2"
 
-[[bin]]
-name = "freemkv-info"
-path = "src/bin/freemkv_info.rs"
+[target.'cfg(target_os = "macos")'.dependencies]
+libc = "0.2"
 
-[[bin]]
-name = "freemkv-test"
-path = "src/bin/freemkv_test.rs"

README.md

@@ -1,147 +1,97 @@
 [![Crates.io](https://img.shields.io/crates/v/libfreemkv)](https://crates.io/crates/libfreemkv)
+[![docs.rs](https://img.shields.io/docsrs/libfreemkv)](https://docs.rs/libfreemkv)
 [![License: AGPL-3.0](https://img.shields.io/badge/license-AGPL--3.0-blue)](LICENSE)
-[![Drives: 206](https://img.shields.io/badge/drives-206-brightgreen)]()
 
 # libfreemkv
 
-Rust library for raw sector access on optical drives. Identifies drives using standard SCSI commands, matches them against 206 bundled profiles, and unlocks raw read mode. No external files, no configuration.
+Rust library for 4K UHD / Blu-ray optical drives. Drive access, disc scanning, AACS decryption, and content reading in one crate. Bundled drive profiles — no external files needed.
+
+**[API Documentation](https://docs.rs/libfreemkv)** · **[Technical Docs](docs/)**
 
 Part of the [freemkv](https://github.com/freemkv) project.
 
 ## Install
 
-### As a library
-
 ```toml
 [dependencies]
-libfreemkv = "0.2"
+libfreemkv = "0.3"
 ```
 
-### Prebuilt binaries
-
-Download from [GitHub Releases](https://github.com/freemkv/libfreemkv/releases):
-
-| Platform | Architecture | Download |
-|----------|-------------|----------|
-| Linux | x86_64 | [freemkv-info](https://github.com/freemkv/libfreemkv/releases/latest) |
-| Linux | aarch64 | [freemkv-info](https://github.com/freemkv/libfreemkv/releases/latest) |
-
-## Usage
+## Quick Start
 
 ```rust
-use libfreemkv::DriveSession;
+use libfreemkv::{DriveSession, Disc, ScanOptions};
 use std::path::Path;
 
+// Open drive — profiles are bundled, auto-identified
 let mut session = DriveSession::open(Path::new("/dev/sr0"))?;
 
-session.unlock()?;       // activate raw read mode
-session.calibrate()?;    // optimize read speed
+// Scan disc — UDF, playlists, streams, AACS (all automatic)
+let disc = Disc::scan(&mut session, &ScanOptions::default())?;
 
-let mut buf = vec![0u8; 2048];
-let n = session.read_sectors(0, 1, &mut buf)?;
-```
+for title in &disc.titles {
+    println!("{} — {} streams", title.duration_display(), title.streams.len());
+}
 
-## How It Works
-
-1. **INQUIRY** (SPC-4 §6.4) — reads vendor_id, product_id, product_revision, vendor_specific
-2. **GET CONFIGURATION 010C** (MMC-6 §5.3.10) — reads firmware_date
-3. **Profile match** — five fields uniquely identify the drive against 206 bundled profiles
-4. **READ BUFFER** — single command with per-drive mode/buffer_id activates raw read mode
-5. **Signature verify** — drive responds with 4-byte signature + "MMkv" confirmation
-
-No fingerprints. No encrypted lookups. All identification uses standard SCSI fields.
-
-## API
-
-```rust
-// Open and auto-identify
-let mut session = DriveSession::open(device_path)?;
-
-// Drive identity
-session.drive_id.vendor_id       // "HL-DT-ST"
-session.drive_id.product_id      // "BD-RE BU40N"
-session.drive_id.product_revision // "1.03"
-session.drive_id.vendor_specific  // "NM00000"
-session.drive_id.firmware_date    // "211810241934"
-
-// Profile data
-session.profile.chipset           // Chipset::MediaTek
-session.profile.unlock_mode       // 0x01
-session.profile.unlock_buf_id     // 0x44
-session.profile.signature         // [0x99, 0x9e, 0xc3, 0x75]
-
-// Operations
-session.unlock()?;                // activate raw mode
-session.calibrate()?;             // speed optimization
-session.read_sectors(lba, count, &mut buf)?;
-session.status()?;                // feature flags
-session.read_config()?;           // drive configuration
-session.read_register(index)?;    // hardware registers
-```
-
-## Chipset Support
-
-| Chipset | Status | Drives | Brands |
-|---------|--------|--------|--------|
-| MediaTek MT1959 | Supported | 206 | LG, ASUS, HP |
-| Renesas | Planned | -- | Pioneer |
-
-Each profile stores per-drive `unlock_mode` and `unlock_buf_id` — the exact CDB bytes for that drive's unlock command. A single `Mt1959` implementation handles all MediaTek variants.
-
-## Drive Profile
-
-Each bundled profile (compiled into the binary):
-
-```json
-{
-  "vendor_id": "HL-DT-ST",
-  "product_id": "BD-RE BU40N     ",
-  "product_revision": "1.03",
-  "vendor_specific": "NM00000",
-  "firmware_date": "211810241934",
-  "chipset": "mediatek",
-  "unlock_mode": 1,
-  "unlock_buf_id": 68,
-  "signature": "999ec375",
-  "register_offsets": ["10e291", "11ab1c"]
+// Read content (decrypted transparently if AACS keys available)
+let mut reader = disc.open_title(&mut session, 0)?;
+while let Some(unit) = reader.read_unit()? {
+    // 6144 bytes of content per aligned unit
 }
 ```
 
-## Error Codes
+## What It Does
 
-Structured errors for programmatic handling — no user-facing English text in the library.
+- **Drive access** — open, identify, unlock for raw reads
+- **Disc scanning** — UDF 2.50 filesystem, MPLS playlists, CLPI clip info, BD-J labels
+- **AACS decryption** — transparent key resolution and content decrypt (1.0 + 2.0)
+- **Content reading** — sector reads with automatic decryption
 
-| Code | Error | Meaning |
-|------|-------|---------|
-| E1000 | DeviceNotFound | Device path doesn't exist |
-| E1001 | DevicePermission | No access (try sudo or cdrom group) |
-| E2000 | UnsupportedDrive | No matching profile |
-| E2001 | ProfileNotFound | Profile lookup failed |
-| E3000 | UnlockFailed | Unlock command rejected |
-| E3001 | SignatureMismatch | Response signature wrong |
-| E3002 | NotUnlocked | Operation requires unlock first |
-| E4000 | ScsiError | SCSI command failed |
-| E5000 | IoError | System I/O error |
+AACS decryption requires a KEYDB.cfg file. If available at `~/.config/aacs/KEYDB.cfg` or passed via `ScanOptions`, the library handles everything — handshake, key derivation, and per-sector decryption — without the application needing to know anything about encryption.
 
 ## Architecture
 
-```
-DriveSession
-├── ScsiTransport     SG_IO (Linux) / IOKit (macOS, planned)
-├── DriveProfile      per-drive parameters (bundled JSON, compiled in)
-├── DriveId           INQUIRY + GET_CONFIG 010C fields
-└── Platform
-    ├── Mt1959        MediaTek MT1959 (206 drives)
-    └── (Renesas)     Pioneer (planned)
+```text
+DriveSession           — open, identify, unlock, read sectors
+  ├── ScsiTransport    — SG_IO (Linux), IOKit (macOS)
+  ├── DriveProfile     — per-drive unlock parameters (bundled)
+  └── Platform         — MediaTek (supported), Renesas (planned)
+
+Disc                   — scan titles, streams, AACS state
+  ├── UDF reader       — Blu-ray UDF 2.50 with metadata partitions
+  ├── MPLS parser      — playlists → titles + clips + streams
+  ├── CLPI parser      — clip info → EP map → sector extents
+  ├── JAR parser       — BD-J audio track labels
+  └── AACS             — key resolution + content decryption
 ```
 
-## Platform
+See [docs/](docs/) for detailed technical documentation on each module.
 
-Linux only today (SG_IO ioctl). The `ScsiTransport` trait abstracts the platform — macOS IOKit and Windows SPTI backends are planned.
+## Error Codes
+
+All errors are structured with numeric codes. No user-facing English text — applications format their own messages.
+
+| Range | Category |
+|-------|----------|
+| E1xxx | Device errors (not found, permission) |
+| E2xxx | Profile errors (unsupported drive) |
+| E3xxx | Unlock errors (failed, signature) |
+| E4xxx | SCSI errors (command failed, timeout) |
+| E5xxx | I/O errors |
+| E6xxx | Disc format errors |
+| E7xxx | AACS errors |
+
+## Platform Support
+
+| Platform | Status | Backend |
+|----------|--------|---------|
+| Linux | Supported | SG_IO ioctl |
+| macOS | Supported | IOKit SCSITask |
+| Windows | Planned | SPTI |
 
 ## Contributing
 
-Run `freemkv info --share` with the [freemkv CLI](https://github.com/freemkv/freemkv) to submit your drive's profile.
+Run `freemkv info --share` with the [freemkv CLI](https://github.com/freemkv/freemkv) to contribute your drive's profile.
 
 ## License
 

build.rs

@@ -0,0 +1,7 @@
+fn main() {
+    #[cfg(target_os = "macos")]
+    {
+        println!("cargo:rustc-link-lib=framework=IOKit");
+        println!("cargo:rustc-link-lib=framework=CoreFoundation");
+    }
+}

docs/README.md

@@ -0,0 +1,32 @@
+# libfreemkv Documentation
+
+Technical documentation for [libfreemkv](https://github.com/freemkv/libfreemkv), the open source optical drive library.
+
+## Start Here
+
+**[Disc to Rip: End-to-End Flow](disc-to-rip.md)** — How the library goes from a disc in the drive to decrypted content. Read this first.
+
+## Reference
+
+| Document | What it covers |
+|----------|---------------|
+| [Architecture](architecture.md) | Module map, design principles, error codes, platform support |
+| [Drive Access](drive-access.md) | DriveSession, SCSI transport, profiles, unlock, why raw mode is needed |
+| [AACS Encryption](aacs.md) | Key resolution (4 paths), content decryption, bus encryption, SCSI handshake |
+| [UDF Filesystem](udf.md) | UDF 2.50 with metadata partitions, pointer chain, how files are read from disc |
+| [MPLS Playlists](mpls.md) | Playlist format, play items, STN stream table, coding types |
+| [CLPI Clip Info](clpi.md) | EP map (coarse + fine entries), timestamp-to-sector mapping, extent calculation |
+
+## Reading Order
+
+If you want to understand the whole library:
+
+1. **[Disc to Rip](disc-to-rip.md)** — the big picture
+2. **[Architecture](architecture.md)** — how modules fit together
+3. **[Drive Access](drive-access.md)** — how we talk to hardware
+4. **[UDF](udf.md)** → **[MPLS](mpls.md)** → **[CLPI](clpi.md)** — how disc content is structured
+5. **[AACS](aacs.md)** — how encryption works and how we break it
+
+## API Documentation
+
+Generated API docs are on [docs.rs/libfreemkv](https://docs.rs/libfreemkv).

docs/aacs.md

@@ -0,0 +1,320 @@
+# AACS Encryption Support
+
+## Overview
+
+AACS (Advanced Access Content System) is the encryption layer used by Blu-ray and UHD 4K discs to protect content. libfreemkv implements AACS decryption to enable transparent disc access.
+
+There are two major versions:
+
+- **AACS 1.0** -- Used by standard Blu-ray discs. Relies on a custom 160-bit elliptic curve for bus authentication and AES-128 for content encryption. Processing keys and device keys can derive the media key from the disc's Media Key Block (MKB).
+
+- **AACS 2.0** -- Used by UHD 4K Blu-ray discs. Adds a per-sector bus encryption layer (read_data_key) on top of the standard content encryption. Uses P-256/SHA-256 for its native handshake, though drives accept AACS 1.0 host certificates for backward compatibility.
+
+Both versions use AES-128-CBC for content decryption with a fixed initialization vector. The fundamental key hierarchy is the same: a Volume Unique Key (VUK) decrypts per-title unit keys, which in turn decrypt the content stream.
+
+
+## Architecture
+
+AACS support is split across two modules:
+
+### `aacs.rs` -- Keys and Decryption
+
+Handles everything related to key resolution and content decryption:
+
+- KEYDB.cfg parsing (device keys, processing keys, host certificates, per-disc entries)
+- Disc hash computation (SHA-1 of `Unit_Key_RO.inf`)
+- VUK resolution chain (4 paths, described below)
+- MKB record parsing and media key derivation
+- Subset-difference tree traversal (AACS-G3 key derivation)
+- Unit_Key_RO.inf parsing and unit key decryption
+- Content Certificate parsing (AACS version detection)
+- Aligned unit decryption (AES-128-CBC)
+- Bus decryption (AACS 2.0 read_data_key layer)
+
+### `aacs_handshake.rs` -- SCSI Authentication
+
+Handles the drive-level SCSI authentication protocol:
+
+- ECDH key agreement on the AACS 160-bit curve
+- ECDSA signing and verification
+- Bus key derivation
+- AGID management (allocate/invalidate)
+- Volume ID retrieval (encrypted with bus key, verified by AES-CMAC)
+- Read Data Key retrieval (for AACS 2.0 bus decryption)
+- AACS LA public key certificate verification
+
+
+## Key Resolution Chain
+
+When a disc is scanned, `resolve_keys()` attempts four paths in priority order. The first path that succeeds is used.
+
+### Path 1: KEYDB VUK Lookup (fastest)
+
+```
+Unit_Key_RO.inf --> SHA-1 --> disc_hash --> KEYDB lookup --> VUK
+```
+
+The disc hash is computed as the SHA-1 digest of the raw `Unit_Key_RO.inf` file from the disc's `/AACS/` directory. This hash is used as the lookup key in `KEYDB.cfg`. If a matching entry contains a VUK (`V` field), it is used directly.
+
+This is the fast path and resolves the vast majority of discs in a well-maintained KEYDB.
+
+### Path 2: KEYDB Media Key + Volume ID
+
+```
+KEYDB media_key + Volume ID (from SCSI handshake) --> VUK derivation
+```
+
+If the disc hash is not in the KEYDB but a KEYDB entry has a matching Volume ID (`I` field) and a media key (`M` field), the VUK is derived:
+
+```
+VUK = AES-128-ECB-DECRYPT(media_key, volume_id) XOR volume_id
+```
+
+Requires a successful SCSI handshake to obtain the Volume ID.
+
+### Path 3: MKB + Processing Keys
+
+```
+MKB (from disc) + processing_keys (from KEYDB) --> media_key --> VUK
+```
+
+Processing keys are pre-computed keys that work against specific MKB versions. For each processing key, the library:
+
+1. Parses the MKB to extract the Verify Media Key Record (`mk_dv`), subset-difference index, and conditional values (cvalues).
+2. Tries each processing key against each UV/cvalue pair: `mk = AES-DEC(pk, cvalue) XOR cvalue`.
+3. Validates the derived media key: `AES-ECB(mk, mk_dv)` must produce 12 leading zero bytes.
+4. Derives VUK from the validated media key and Volume ID.
+
+### Path 4: MKB + Device Keys (Subset-Difference Tree)
+
+```
+MKB + device_keys --> subset-difference tree traversal --> processing_key --> media_key --> VUK
+```
+
+The most complex path. Each device key has an associated node number, UV value, and mask parameters that position it in the AACS subset-difference tree. The library:
+
+1. Finds the subset-difference entry in the MKB that applies to the device key's node.
+2. Traverses the tree using AACS-G3 key derivation: `aesg3(key, inc) = AES-DEC(key, seed) XOR seed`, where `seed[15]` is incremented by `inc`. Each tree node produces a left child (inc=0), a processing key (inc=1), and a right child (inc=2).
+3. At each level, selects left or right based on the UV bit at the current position.
+4. The resulting processing key is validated against the MKB cvalue to derive the media key.
+5. VUK is derived from the media key and Volume ID.
+
+
+## Content Decryption
+
+### Aligned Units
+
+AACS encrypts content in aligned units of 6144 bytes (3 sectors of 2048 bytes each). The encryption flag is signaled by the copy_permission_indicator bits in byte 0 of the unit (`unit[0] & 0xC0 != 0`).
+
+### Per-Unit Key Derivation
+
+Each aligned unit has its own decryption key derived from the CPS unit key:
+
+1. **Derive**: AES-128-ECB encrypt the first 16 bytes of the unit (plaintext TP_extra_header) with the unit key.
+2. **XOR**: XOR the encrypted result with the original 16 bytes to produce the per-unit decryption key.
+3. **Decrypt**: AES-128-CBC decrypt bytes 16 through 6143 using the per-unit key and the fixed AACS IV.
+4. **Clear flag**: Clear the encryption indicator bits (`unit[0] &= !0xC0`).
+
+### Fixed IV
+
+All AES-CBC operations in AACS use the same fixed initialization vector, defined in the AACS specification.
+
+### Verification
+
+After decryption, the library verifies correctness by checking for MPEG-TS sync bytes (0x47) at the expected 192-byte packet boundaries within the unit. Blu-ray transport stream packets are 192 bytes: 4-byte TP_extra_header followed by a 188-byte TS packet.
+
+
+## Bus Encryption
+
+### AACS 1.0
+
+Standard Blu-ray discs do not use bus encryption. Content is read directly from the disc and decrypted using the unit key.
+
+### AACS 2.0
+
+UHD 4K discs add a per-sector bus encryption layer. The drive encrypts data as it is read from the disc, and the host must decrypt it before applying AACS content decryption.
+
+Bus encryption uses a **read_data_key** obtained during the SCSI handshake. For each 2048-byte sector within an aligned unit, bytes 16 through 2047 are AES-128-CBC encrypted with the read_data_key and the fixed AACS IV. The first 16 bytes of each sector remain plaintext.
+
+The full decryption pipeline for AACS 2.0:
+
+1. **Bus decrypt**: For each sector, AES-128-CBC decrypt bytes 16..2047 with the read_data_key.
+2. **Content decrypt**: Standard per-unit key derivation and AES-128-CBC decryption as described above.
+
+
+## SCSI Handshake
+
+The AACS SCSI authentication handshake establishes a shared bus key between host and drive, then uses it to securely transfer the Volume ID and read data keys.
+
+### Protocol Flow
+
+1. **Invalidate AGIDs**: Send REPORT KEY with format 0x3F for AGIDs 0-3 to clear stale sessions.
+2. **Allocate AGID**: REPORT KEY format 0x00 returns a fresh Authentication Grant ID.
+3. **Send host credentials**: SEND KEY format 0x01 transmits the host nonce (20 random bytes) and host certificate (92 bytes).
+4. **Receive drive credentials**: REPORT KEY format 0x01 returns the drive nonce and drive certificate.
+5. **Receive drive key**: REPORT KEY format 0x02 returns the drive's ephemeral EC key point and ECDSA signature over `host_nonce || drive_key_point`.
+6. **Verify drive key**: The signature is verified against the drive's public key (extracted from its certificate). AACS 1.0 certificates are verified against the AACS LA public key.
+7. **Send host key**: The host generates an ephemeral key pair, signs `drive_nonce || host_key_point` with the host private key, and sends via SEND KEY format 0x02.
+8. **Compute bus key**: ECDH shared secret = `host_private_key * drive_key_point`. The bus key is the low 128 bits of the shared point's x-coordinate.
+
+### Post-Authentication Reads
+
+- **Volume ID**: REPORT DISC STRUCTURE format 0x80. Returns 16-byte VID encrypted with the bus key, plus an AES-CMAC MAC for integrity verification.
+- **Read Data Keys**: REPORT DISC STRUCTURE format 0x84. Returns the read_data_key and write_data_key, each AES-ECB encrypted with the bus key.
+
+### Elliptic Curve
+
+AACS 1.0 uses a custom 160-bit Weierstrass curve (`y^2 = x^3 + ax + b mod p`) with 20-byte field elements. The library implements full EC arithmetic: point addition, doubling, scalar multiplication, modular inverse, ECDSA sign/verify, and ECDH key agreement.
+
+
+## AACS 2.0 Status
+
+AACS 2.0 discs are detected via the Content Certificate file (`Content000.cer` or `Content001.cer`). A certificate type byte of 0x01 indicates AACS 2.0.
+
+AACS 2.0 drives are identified by their drive certificate type (0x11). These drives natively use P-256/SHA-256, but accept AACS 1.0 host certificates for backward compatibility.
+
+Current implementation status:
+
+- AACS 2.0 detection: **implemented** (Content Certificate parsing, drive cert type check)
+- AACS 1.0 handshake with AACS 2.0 drives: **implemented** (backward compatibility mode)
+- Full P-256 AACS 2.0 handshake: **not yet implemented** (prepared but rarely needed since drives accept AACS 1.0 host certs)
+- Bus decryption with read_data_key: **implemented**
+- Content decryption: **implemented** (same as AACS 1.0)
+
+In practice, AACS 2.0 UHD discs work through the backward-compatible AACS 1.0 handshake path, with the addition of read_data_key bus decryption.
+
+
+## API Usage
+
+AACS decryption is transparent to the application. The `Disc::scan()` method handles everything automatically:
+
+```rust
+use libfreemkv::{DriveSession, Disc};
+use libfreemkv::disc::ScanOptions;
+use std::path::Path;
+
+let mut session = DriveSession::open(Path::new("/dev/sr0")).unwrap();
+let disc = Disc::scan(&mut session, &ScanOptions::default()).unwrap();
+
+// Check encryption state
+if disc.encrypted {
+    if let Some(ref aacs) = disc.aacs {
+        println!("AACS {}.0", aacs.version);
+        println!("Key source: {}", aacs.key_source.name());
+        println!("Disc hash: {}", aacs.disc_hash);
+        if let Some(mkb_ver) = aacs.mkb_version {
+            println!("MKB version: {}", mkb_ver);
+        }
+    } else {
+        println!("Encrypted but keys not available");
+    }
+}
+
+// Read content -- decryption is automatic
+let mut reader = disc.open_title(&mut session, 0).unwrap();
+while let Some(unit) = reader.read_unit().unwrap() {
+    // unit is 6144 bytes of decrypted content
+}
+```
+
+The application never touches keys, never calls decryption functions, and never manages handshakes. All of that is internal to `Disc::scan()` and `ContentReader::read_unit()`.
+
+### KEYDB Location
+
+`ScanOptions` controls where the KEYDB is loaded from. If no explicit path is set, the library checks:
+
+1. `~/.config/aacs/KEYDB.cfg`
+2. `/etc/aacs/KEYDB.cfg`
+
+To specify an explicit path:
+
+```rust
+let opts = ScanOptions::with_keydb("/path/to/KEYDB.cfg");
+let disc = Disc::scan(&mut session, &opts).unwrap();
+```
+
+### AacsState
+
+After a successful scan, `disc.aacs` contains an `AacsState` with:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `version` | `u8` | AACS version (1 or 2) |
+| `bus_encryption` | `bool` | Whether bus encryption is active |
+| `mkb_version` | `Option<u32>` | MKB version from disc |
+| `disc_hash` | `String` | SHA-1 of Unit_Key_RO.inf (hex with 0x prefix) |
+| `key_source` | `KeySource` | How keys were resolved |
+| `vuk` | `[u8; 16]` | Volume Unique Key |
+| `unit_keys` | `Vec<(u32, [u8; 16])>` | Decrypted unit keys (CPS unit number, key) |
+| `read_data_key` | `Option<[u8; 16]>` | AACS 2.0 bus decryption key |
+| `volume_id` | `[u8; 16]` | Volume ID from SCSI handshake |
+
+### KeySource
+
+| Variant | Description |
+|---------|-------------|
+| `KeyDb` | VUK found directly in KEYDB by disc hash |
+| `KeyDbDerived` | Media key + Volume ID from KEYDB, VUK derived |
+| `ProcessingKey` | MKB + processing keys from KEYDB |
+| `DeviceKey` | MKB + device keys, subset-difference tree traversal |
+
+
+## KEYDB.cfg Format Reference
+
+The KEYDB.cfg file contains all cryptographic material needed for AACS decryption. Lines starting with `;` or `#` are comments.
+
+### Device Keys
+
+```
+| DK | DEVICE_KEY 0x<key> | DEVICE_NODE 0x<node> | KEY_UV 0x<uv> | KEY_U_MASK_SHIFT 0x<shift>
+```
+
+- `key`: 16-byte AES device key (hex)
+- `node`: Device node number in the subset-difference tree (hex)
+- `uv`: UV value for tree positioning (hex)
+- `shift`: U mask shift value (hex)
+
+### Processing Keys
+
+```
+| PK | 0x<key>
+```
+
+- `key`: 16-byte pre-computed processing key (hex)
+
+### Host Certificate
+
+```
+| HC | HOST_PRIV_KEY 0x<privkey> | HOST_CERT 0x<cert>
+```
+
+- `privkey`: 20-byte ECDSA private key (hex)
+- `cert`: 92-byte AACS host certificate (hex)
+
+The host certificate is used for SCSI authentication. It contains the host's public key and is signed by the AACS Licensing Administrator.
+
+### Disc Entries
+
+```
+0x<disc_hash> = <title> | D | <date> | M | 0x<media_key> | I | 0x<disc_id> | V | 0x<vuk> | U | <unit_keys>
+```
+
+- `disc_hash`: 20-byte SHA-1 of Unit_Key_RO.inf (hex)
+- `title`: Human-readable disc title
+- `D`: Date tag, followed by release/rip date
+- `M`: Media key tag, followed by 16-byte media key (hex)
+- `I`: Disc ID tag, followed by 16-byte Volume ID (hex)
+- `V`: VUK tag, followed by 16-byte Volume Unique Key (hex)
+- `U`: Unit keys tag, followed by space-separated `<unit_num>-0x<key>` pairs
+
+All fields after the title are optional. A minimal entry needs only the disc hash and VUK:
+
+```
+0x<disc_hash> = <title> | V | 0x<vuk>
+```
+
+Inline comments are supported with `;`:
+
+```
+0x<disc_hash> = <title> | V | 0x<vuk> ; MKBv77
+```

docs/architecture.md

@@ -0,0 +1,180 @@
+# libfreemkv Architecture
+
+Open source optical drive access library for 4K UHD Blu-ray, Blu-ray, and DVD.
+Rust library with no external dependencies at runtime -- profiles are bundled,
+AACS keys are derived internally, and all SCSI communication is handled in-process.
+
+**Repository:** <https://github.com/freemkv/libfreemkv>
+**License:** AGPL-3.0-only
+
+---
+
+## Design Principles
+
+1. **CLI is dumb.** All drive communication, disc parsing, AACS decryption, and
+   format handling live in the library. CLI binaries are thin wrappers that call
+   `DriveSession::open()` and `Disc::scan()`.
+
+2. **No external files.** 206 drive profiles are compiled into the binary via
+   `include_str!`. No configuration directory, no runtime file lookups for drive
+   support.
+
+3. **Transparent AACS.** The `ContentReader` decrypts on the fly when keys are
+   available. Callers read cleartext sectors without knowing whether the disc
+   was encrypted.
+
+4. **Structured errors, no English.** Every error has a numeric code (E1000-E7000).
+   The library never formats user-facing messages -- applications do that.
+
+5. **Library-agnostic.** No concept of "supported" vs "unsupported" drives at a
+   policy level. If a profile exists, the library uses it.
+
+---
+
+## Module Map
+
+```
+libfreemkv (lib.rs)
+│
+├── Drive Access
+│   ├── drive         DriveSession — open, identify, unlock, read
+│   ├── scsi          ScsiTransport trait + SG_IO implementation
+│   ├── platform/     Platform trait — per-chipset command handlers
+│   │   └── mt1959    MediaTek MT1959 driver (LG, ASUS, hp)
+│   ├── profile       DriveProfile loading, matching, bundled JSON
+│   ├── identity      DriveId from INQUIRY + GET_CONFIG 010C
+│   └── speed         DriveSpeed enum, SET CD SPEED CDB builder
+│
+├── Disc Scanning
+│   ├── disc          Disc::scan() — titles, streams, extents, AACS setup
+│   ├── udf           UDF 2.50 filesystem reader (metadata partitions)
+│   ├── mpls          MPLS playlist parser — clips, streams, STN table
+│   ├── clpi          CLPI clip info parser — EP map, sector extents
+│   └── jar           BD-J JAR label extraction (audio/subtitle names)
+│
+├── Encryption
+│   ├── aacs          KEYDB parsing, VUK lookup, MKB processing, unit decryption
+│   └── aacs_handshake  ECDH bus authentication, Volume ID, Read Data Key
+│
+└── error             Error enum with numeric codes E1000-E7000
+```
+
+---
+
+## Drive Access Flow
+
+```
+DriveSession::open("/dev/sr0")
+  │
+  ├─ scsi::open()           Open /dev/sr0 via SG_IO
+  ├─ DriveId::from_drive()  INQUIRY + GET_CONFIG 010C
+  ├─ profile::find_by_drive_id()  Match against 206 bundled profiles
+  ├─ Platform::new()        Instantiate chipset driver (Mt1959)
+  └─ Platform::unlock()     Activate raw disc access mode
+```
+
+After open, the session provides:
+- `read_sectors(lba, count, buf)` -- raw sector reads (through platform driver)
+- `read_disc(lba, count, buf)` -- standard READ(10) for filesystem data
+- `scsi_execute(cdb, dir, buf, timeout)` -- arbitrary SCSI commands
+- `status()`, `calibrate()`, `read_config()`, `read_register()`
+
+---
+
+## Disc Scanning Flow
+
+```
+Disc::scan(&mut session, &ScanOptions)
+  │
+  ├─ READ CAPACITY          Get disc size in sectors
+  ├─ udf::read_filesystem() Parse UDF 2.50 (AVDP → VDS → metadata → FSD → root)
+  ├─ For each BDMV/PLAYLIST/*.mpls:
+  │   ├─ mpls::parse()      Extract play items, STN streams
+  │   └─ For each clip:
+  │       └─ clpi::parse()  EP map → sector extents for the clip's time range
+  ├─ Detect AACS            Check for /AACS directory on disc
+  └─ Disc::setup_aacs()     Handshake + KEYDB → VUK → unit keys (if encrypted)
+```
+
+The result is a `Disc` with:
+- `titles: Vec<Title>` -- sorted by duration, each with streams and sector extents
+- `aacs: Option<AacsState>` -- decryption keys if available
+- `encrypted: bool` -- whether the disc uses AACS
+
+---
+
+## AACS Decryption
+
+Four key resolution paths, tried in order:
+
+| Path | Method | Speed |
+|------|--------|-------|
+| 1 | VUK lookup by disc hash in KEYDB.cfg | Instant |
+| 2 | Media Key + Volume ID from KEYDB → derive VUK | Fast |
+| 3 | Processing Keys + MKB → Media Key → VUK | Medium |
+| 4 | Device Keys + MKB subset-difference tree → VUK | Slow |
+
+The AACS handshake (`aacs_handshake`) performs ECDH key agreement over the
+AACS 1.0 160-bit elliptic curve to obtain:
+- **Volume ID** -- needed for VUK derivation (paths 2-4)
+- **Read Data Key** -- needed for AACS 2.0 (UHD) bus decryption
+
+Content decryption uses AES-128-CBC on 6144-byte aligned units. The
+`ContentReader` handles this transparently.
+
+---
+
+## Error Codes
+
+All errors carry a numeric code for programmatic handling. No user-facing text
+is baked into the library.
+
+| Range | Category | Examples |
+|-------|----------|----------|
+| E1xxx | Device errors | `DeviceNotFound`, `DevicePermission` |
+| E2xxx | Profile errors | `UnsupportedDrive`, `ProfileNotFound`, `ProfileParse` |
+| E3xxx | Unlock errors | `UnlockFailed`, `SignatureMismatch`, `NotUnlocked`, `NotCalibrated` |
+| E4xxx | SCSI errors | `ScsiError`, `ScsiTimeout` |
+| E5xxx | I/O errors | `IoError` (wraps `std::io::Error`) |
+| E6xxx | Disc format errors | `DiscError` (UDF, MPLS, CLPI parse failures) |
+| E7xxx | AACS errors | `AacsError` (key resolution, handshake, decryption) |
+
+---
+
+## Platform Support
+
+| Platform | Transport | Status |
+|----------|-----------|--------|
+| Linux | SG_IO ioctl on `/dev/sr*` | Implemented |
+| macOS | IOKit SCSI passthrough | Planned |
+| Windows | SPTI (`IOCTL_SCSI_PASS_THROUGH_DIRECT`) | Planned |
+
+The `ScsiTransport` trait abstracts the platform. Adding a new platform requires
+implementing `execute()` for that OS and wiring it into `scsi::open()`.
+
+---
+
+## Chipset Support
+
+| Chipset | Drives | Status |
+|---------|--------|--------|
+| MediaTek MT1959 | LG, ASUS, hp | Implemented (206 profiles) |
+| Renesas RS8xxx/RS9xxx | Pioneer, some HL-DT-ST | Planned |
+
+The `Platform` trait abstracts chipset-specific commands. Each chipset implements
+10 handlers (unlock, config, register, calibrate, keepalive, status, probe,
+read_sectors, timing). All handlers are accessed via SCSI READ BUFFER with
+chipset-specific mode and buffer ID bytes.
+
+---
+
+## Build
+
+```
+cargo build --release
+```
+
+Linux builds produce a static library and two binaries (`freemkv-info`,
+`freemkv-test`). The `libc` dependency is Linux-only. On non-Linux platforms,
+the library compiles but `scsi::open()` returns a platform-not-supported error
+until the IOKit/SPTI backends are implemented.

docs/clpi.md

@@ -0,0 +1,197 @@
+# CLPI Clip Information Format
+
+## What is CLPI?
+
+CLPI (Clip Information) files describe the structure of individual M2TS transport streams on a Blu-ray disc. Each `.clpi` file in `BDMV/CLIPINF/` corresponds to one `.m2ts` file in `BDMV/STREAM/` with the same numeric name (e.g. `00001.clpi` describes `00001.m2ts`).
+
+The most important data in a CLPI file is the **EP (Entry Point) map**, which provides timestamp-to-sector mapping. This is essential for seeking and for extracting the specific sector ranges that correspond to a playlist's in/out time window.
+
+## File Structure
+
+CLPI files use big-endian byte order. The header:
+
+```
+Offset  Size  Field
+------  ----  -----
+0       4     Magic: "HDMV"
+4       4     Version: "0200" (BD) or "0300" (UHD BD)
+8       4     SequenceInfo start offset
+12      4     ProgramInfo start offset
+16      4     CPI (Characteristic Point Information) start offset
+20      4     ClipMark start offset
+24      4     ExtensionData start offset
+```
+
+### ClipInfo Section (offset 40)
+
+Contains basic clip metadata. The source packet count (total number of 192-byte source packets in the M2TS file) is at offset 56:
+
+```
+Offset  Size  Field
+------  ----  -----
+40      4     ClipInfo length
+44      2     Reserved
+46      1     Stream type
+47      1     Application type
+48      4     Reserved
+52      4     TS recording rate
+56      4     Source packet count
+```
+
+The source packet count multiplied by 192 gives the total byte size of the M2TS file.
+
+## EP Map
+
+The EP map lives inside the CPI section and provides random access into the transport stream. It maps PTS timestamps to Source Packet Numbers (SPN), enabling precise seeking without scanning the stream.
+
+### CPI Section Layout
+
+```
+Offset  Size  Field
+------  ----  -----
+0       4     CPI length
+4       2     Reserved / CPI type
+6       ...   EP map
+```
+
+### EP Map Header
+
+```
+Offset  Size  Field
+------  ----  -----
+0       1     Reserved
+1       1     Number of stream PID entries
+2       ...   Stream PID entry headers (one per stream)
+```
+
+Each stream PID entry header (14 bytes):
+
+```
+Offset  Size  Field
+------  ----  -----
+0       2     Stream PID
+2       2     Reserved + EP stream type
+4       2     Number of coarse entries
+6       4     Number of fine entries (note: 32-bit, can be large)
+10      4     EP map start offset (relative to EP map start)
+```
+
+libfreemkv parses only the first stream (primary video), which is sufficient for sector-level seeking.
+
+### Two-Level Index
+
+The EP map uses a two-level structure to compress what would otherwise be a very large lookup table:
+
+- **Coarse entries**: low-resolution index covering large time/sector ranges
+- **Fine entries**: high-resolution entries within each coarse range
+
+Each coarse entry points to a range of fine entries via `ref_to_fine_id`.
+
+### Coarse Entries (8 bytes each)
+
+Located immediately after the fine table start offset (4 bytes) in the per-stream EP map:
+
+```
+Bits    Field
+------  -----
+[31:14] ref_to_fine_id (18 bits) -- index of first fine entry in this range
+[13:0]  pts_coarse (14 bits) -- upper bits of PTS
+```
+
+Second dword:
+
+```
+Bits    Field
+------  -----
+[31:0]  spn_coarse (32 bits) -- upper bits of SPN
+```
+
+### Fine Entries (4 bytes each)
+
+Located at the fine table start offset within the per-stream EP map:
+
+```
+Bits    Field
+------  -----
+[31]    is_angle_change_point (1 bit)
+[30:28] I_end_position_offset (3 bits)
+[27:17] pts_fine (11 bits) -- lower bits of PTS
+[16:0]  spn_fine (17 bits) -- lower bits of SPN
+```
+
+## Reconstructing Full PTS and SPN
+
+The full timestamp and packet number are assembled by combining the coarse and fine components:
+
+### Full PTS
+
+```
+full_pts = (pts_coarse << 19) + (pts_fine << 8)
+```
+
+The coarse component provides the upper bits, shifted left by 19. The fine component provides mid-range bits, shifted left by 8. The resulting PTS is in 45kHz ticks, matching the MPLS timestamp format.
+
+### Full SPN
+
+```
+full_spn = (spn_coarse & 0xFFFE0000) + spn_fine
+```
+
+The coarse SPN provides the upper 15 bits (masked to clear the lower 17). The fine SPN provides the lower 17 bits. The result is a Source Packet Number -- each source packet is 192 bytes in the M2TS file.
+
+### Resolved EP Map
+
+The `resolved_ep_map()` method iterates through all coarse entries and their associated fine entries to produce a flat list of `(PTS, SPN)` pairs. For each coarse entry at index `ci`:
+
+- Fine entries range from `coarse[ci].ref_to_fine_id` to `coarse[ci+1].ref_to_fine_id` (or end of fine table for the last coarse entry).
+- Each fine entry is combined with its parent coarse entry to produce one full `(PTS, SPN)` pair.
+
+## Deriving Sector Extents for Ripping
+
+Given a playlist's in_time and out_time (from MPLS), the CLPI EP map provides the sector ranges to read from disc. The `get_extents()` method does this in three steps:
+
+### Step 1: PTS to SPN
+
+Binary search the resolved EP map for the in_time and out_time:
+
+- **start_spn**: the SPN at or before in_time (seek backward to the nearest I-frame)
+- **end_spn**: the SPN at or after out_time (include the full GOP)
+
+### Step 2: SPN to Byte Offset
+
+Each Source Packet is 192 bytes (188 bytes MPEG-TS payload + 4 bytes M2TS header):
+
+```
+byte_offset = spn * 192
+```
+
+### Step 3: Byte Offset to Sector
+
+M2TS files are stored contiguously on disc. Sectors are 2048 bytes:
+
+```
+start_sector = start_byte / 2048
+end_sector   = (end_byte + 2047) / 2048
+sector_count = end_sector - start_sector
+```
+
+The resulting `Extent` contains `start_lba` (relative to the M2TS file's starting sector on disc) and `sector_count`. The caller adds the file's absolute starting LBA from UDF to get disc-absolute sector numbers.
+
+### Alignment Note
+
+The 192-byte source packet size and 2048-byte sector size share no common factor beyond 1. A single sector contains roughly 10.67 source packets. The conversion rounds start down and end up to ensure complete coverage.
+
+## Putting It Together
+
+The full ripping pipeline chains three parsers:
+
+1. **MPLS** provides clip IDs and in/out timestamps.
+2. **CLPI** converts those timestamps to SPN ranges, then to sector extents.
+3. **UDF** provides the file's starting LBA on disc for absolute sector addressing.
+
+The `Disc::scan()` method in `src/disc.rs` orchestrates this: for each play item in each playlist, it loads the corresponding CLPI, calls `get_extents()` with the play item's in/out times, and collects the resulting sector ranges into the title's extent list.
+
+## References
+
+- BD-ROM Part 3, Section 5.5: Clip Information file format
+- https://github.com/lw/BluRay/wiki/CLPI

docs/disc-to-rip.md

@@ -0,0 +1,114 @@
+# Disc to Rip: End-to-End Flow
+
+How libfreemkv goes from a disc in the drive to decrypted content ready for backup.
+This is the starting point for understanding the library.
+
+## The Pipeline
+
+```
+Insert disc
+    │
+    ▼
+1. Open drive (drive.rs)
+    │  INQUIRY → identify drive
+    │  Match bundled profile → chipset, unlock parameters
+    │
+    ▼
+2. AACS handshake (aacs_handshake.rs) — optional, separate transport
+    │  Allocate AGID
+    │  Exchange certificates + nonces (ECDH)
+    │  Derive bus key
+    │  Read Volume ID + read_data_key
+    │  (fails gracefully if drive doesn't support AACS for this disc)
+    │
+    ▼
+3. Unlock drive (drive.rs → platform/mt1959.rs)
+    │  Vendor-specific command activates raw read mode
+    │  Required — drive firmware blocks all reads without it
+    │
+    ▼
+4. Read UDF filesystem (udf.rs)
+    │  Sector 256: AVDP → find Volume Descriptor Sequence
+    │  VDS: Partition Descriptor (physical start) + Logical Volume (metadata start)
+    │  Metadata partition → File Set Descriptor → Root directory
+    │  Walk directory tree: BDMV/, AACS/, CERTIFICATE/
+    │  → docs/udf.md
+    │
+    ▼
+5. Read AACS files from disc (aacs.rs)
+    │  AACS/Unit_Key_RO.inf → SHA1 = disc hash
+    │  AACS/Content000.cer → AACS version (1.0 or 2.0), bus encryption flag
+    │  MKB via SCSI → for key derivation fallback
+    │
+    ▼
+6. Resolve AACS keys (aacs.rs → resolve_keys)
+    │  Path 1: disc hash → KEYDB.cfg → VUK (fast, 99% of discs)
+    │  Path 2: KEYDB media key + Volume ID → VUK
+    │  Path 3: MKB + processing keys → media key → VUK
+    │  Path 4: MKB + device keys → subset-difference tree → VUK
+    │  VUK → decrypt unit keys from Unit_Key_RO.inf
+    │  → docs/aacs.md
+    │
+    ▼
+7. Parse playlists (mpls.rs)
+    │  BDMV/PLAYLIST/*.mpls → titles with play items
+    │  Each play item: clip ID, in/out timestamps
+    │  STN table: video, audio, subtitle streams with codec + language
+    │  → docs/mpls.md
+    │
+    ▼
+8. Parse clip info (clpi.rs)
+    │  BDMV/CLIPINF/*.clpi → EP map (timestamp → sector mapping)
+    │  Coarse + fine entries → full PTS and SPN
+    │  SPN → byte offset → sector extents for reading
+    │  → docs/clpi.md
+    │
+    ▼
+9. Parse BD-J labels (jar.rs) — optional
+    │  BDMV/JAR/*.jar → Java class constant pool strings
+    │  Audio track labels: "English Descriptive Audio", "French 5.1", etc.
+    │
+    ▼
+10. Read + decrypt content (disc.rs → ContentReader)
+     │  For each aligned unit (6144 bytes = 3 sectors):
+     │    Read 3 sectors from disc
+     │    If AACS 2.0: bus decrypt (read_data_key, per-sector AES-CBC)
+     │    If encrypted: unit decrypt (per-unit key derivation + AES-CBC)
+     │    Output decrypted content
+     │
+     ▼
+  Decrypted m2ts stream → ready for muxing/backup
+```
+
+## API Summary
+
+```rust
+// Steps 1 + 3 (open + unlock)
+let mut session = DriveSession::open(Path::new("/dev/sr0"))?;
+
+// Steps 2 + 4-9 (AACS + scan)
+let disc = Disc::scan(&mut session, &ScanOptions::with_keydb("keydb.cfg"))?;
+
+// Step 10 (read + decrypt)
+let mut reader = disc.open_title(&mut session, 0)?;
+while let Some(unit) = reader.read_unit()? {
+    output.write_all(&unit)?;
+}
+```
+
+Three lines. Everything else is internal.
+
+## Module Reference
+
+| Module | Doc | Purpose |
+|--------|-----|---------|
+| drive.rs | [drive-access.md](drive-access.md) | Open, identify, unlock, read |
+| scsi.rs | [drive-access.md](drive-access.md) | Platform SCSI transport |
+| udf.rs | [udf.md](udf.md) | UDF 2.50 filesystem |
+| mpls.rs | [mpls.md](mpls.md) | MPLS playlists + STN streams |
+| clpi.rs | [clpi.md](clpi.md) | CLPI clip info + EP map |
+| aacs.rs | [aacs.md](aacs.md) | Key resolution + content decrypt |
+| aacs_handshake.rs | [aacs.md](aacs.md) | SCSI bus authentication |
+| disc.rs | -- | High-level scan + read API |
+| jar.rs | -- | BD-J audio track labels |
+| error.rs | -- | Error codes (E1xxx-E7xxx) |

docs/drive-access.md

@@ -0,0 +1,253 @@
+# Drive Access and Unlock
+
+Technical reference for how libfreemkv opens, identifies, unlocks, and reads
+optical drives.
+
+---
+
+## DriveSession
+
+`DriveSession` is the primary API. It owns the SCSI transport, the matched
+drive profile, and the chipset-specific platform driver.
+
+### Opening a Drive
+
+```rust
+// Full open: identify → match profile → unlock
+let mut session = DriveSession::open(Path::new("/dev/sr0"))?;
+
+// No-unlock open: identify → match profile only
+let mut session = DriveSession::open_no_unlock(Path::new("/dev/sr0"))?;
+
+// Explicit profile (skip auto-detection)
+let mut session = DriveSession::open_with_profile(Path::new("/dev/sr0"), profile)?;
+```
+
+**`open()`** performs the full sequence: open device, send INQUIRY, match
+profile, instantiate platform driver, and unlock. Unlock failures are silently
+ignored (unencrypted discs do not need it). After `open()`, both raw sector
+reads and standard READ(10) work immediately.
+
+**`open_no_unlock()`** skips the unlock step. This is required when AACS bus
+authentication must happen before unlock. The handshake uses standard SCSI
+commands that work without raw mode. After authentication completes, the caller
+can invoke `session.unlock()` manually.
+
+**`open_with_profile()`** bypasses profile auto-detection. Useful for testing
+or when a custom profile is loaded from an external source.
+
+### Session Operations
+
+| Method | Description |
+|--------|-------------|
+| `unlock()` | Activate raw disc access mode via platform driver |
+| `is_unlocked()` | Check if raw mode is active |
+| `calibrate()` | Build speed lookup table for the current disc |
+| `read_sectors(lba, count, buf)` | Raw sector read (requires unlock + calibrate) |
+| `read_disc(lba, count, buf)` | Standard READ(10) with 5s timeout |
+| `status()` | Query drive status and feature flags |
+| `read_config()` | Read drive configuration block (1888 bytes) |
+| `read_register(index)` | Read 16-byte hardware register |
+| `probe(sub_cmd, addr, len)` | Generic READ BUFFER with caller parameters |
+| `scsi_execute(cdb, dir, buf, timeout)` | Send an arbitrary SCSI CDB |
+
+---
+
+## SCSI Transport
+
+### Trait
+
+```rust
+pub trait ScsiTransport {
+    fn execute(
+        &mut self,
+        cdb: &[u8],
+        direction: DataDirection,
+        data: &mut [u8],
+        timeout_ms: u32,
+    ) -> Result<ScsiResult>;
+}
+```
+
+All drive communication goes through this trait. The library never opens file
+descriptors or calls ioctls outside of a `ScsiTransport` implementation.
+
+### Linux: SG_IO
+
+The `SgIoTransport` implementation:
+
+1. Opens the device path with `O_RDWR | O_NONBLOCK`.
+2. Constructs an `sg_io_hdr` struct with the CDB, data buffer, and timeout.
+3. Calls `ioctl(fd, SG_IO, &hdr)`.
+4. Returns `ScsiResult` with status, bytes transferred, and sense data.
+
+On non-zero SCSI status, the transport parses sense key, ASC, and ASCQ from the
+sense buffer and returns `Error::ScsiError`.
+
+### CDB Builders
+
+The `scsi` module provides platform-agnostic CDB constructors:
+
+| Function | CDB | Use |
+|----------|-----|-----|
+| `inquiry()` | INQUIRY (0x12) | Drive identification |
+| `get_config_010c()` | GET CONFIGURATION (0x46) | Feature 010C firmware date |
+| `build_read_buffer()` | READ BUFFER (0x3C) | All platform commands |
+| `build_set_cd_speed()` | SET CD SPEED (0xBB) | Speed control |
+| `build_read10_raw()` | READ(10) (0x28) with flag 0x08 | Raw sector reads |
+
+---
+
+## Drive Identification
+
+`DriveId::from_drive()` sends two standard SCSI commands and extracts identity
+fields:
+
+| Field | Source | SCSI Reference |
+|-------|--------|----------------|
+| `vendor_id` | INQUIRY bytes [8:16] | SPC-4 section 6.4.2 |
+| `product_id` | INQUIRY bytes [16:32] | SPC-4 section 6.4.2 |
+| `product_revision` | INQUIRY bytes [32:36] | SPC-4 section 6.4.2 |
+| `vendor_specific` | INQUIRY bytes [36:43] | SPC-4 section 6.4.2 |
+| `firmware_date` | GET CONFIGURATION Feature 010C | MMC-6 section 5.3.10 |
+
+The match key is `"VENDOR|PRODUCT|REVISION|VENDOR_SPECIFIC"`. Profile matching
+tries all four fields first, then falls back to matching without the firmware
+date for drives where Feature 010C is unavailable.
+
+---
+
+## Drive Profiles
+
+Profiles are JSON objects compiled into the binary (`profiles.json`,
+206 entries). Each profile contains:
+
+| Field | Purpose |
+|-------|---------|
+| `vendor_id`, `product_revision`, `vendor_specific`, `firmware_date` | Matching fields |
+| `chipset` | `"mediatek"` or `"renesas"` |
+| `unlock_mode`, `unlock_buf_id` | READ BUFFER CDB parameters |
+| `signature` | Expected 4-byte response signature |
+| `unlock_cdb` | Pre-built unlock CDB (hex-encoded) |
+| `register_offsets` | Offsets for hardware register reads |
+| `capabilities` | Feature flags: `bd_raw_read`, `dvd_all_regions`, etc. |
+
+Loading:
+
+```rust
+// Bundled (compiled-in) -- no file I/O
+let profiles = profile::load_bundled()?;
+
+// External file
+let profiles = profile::load_all(Path::new("/path/to/profiles.json"))?;
+```
+
+---
+
+## Chipsets
+
+### MediaTek MT1959
+
+Covers all LG, ASUS, and hp optical drives. Two sub-variants share identical
+logic with different SCSI parameters:
+
+| Variant | READ BUFFER mode | Buffer ID |
+|---------|------------------|-----------|
+| MT1959-A | 0x01 | 0x44 |
+| MT1959-B | 0x02 | 0x77 |
+
+The Platform trait maps to 10 command handlers:
+
+| Handler | Function | Description |
+|---------|----------|-------------|
+| 0 | `unlock()` | Send READ BUFFER, verify signature + verification bytes |
+| 1 | `read_config()` | Read 1888-byte configuration block + 4-byte status |
+| 2-3 | `read_register()` | Read hardware registers at profile-specified offsets |
+| 4 | `calibrate()` | Probe disc surface, build 64-entry speed table |
+| 5 | `keepalive()` | Periodic session maintenance |
+| 6 | `status()` | Query current mode and feature flags |
+| 7 | `probe()` | Generic READ BUFFER with dynamic parameters |
+| 8 | `read_sectors()` | Speed lookup + SET CD SPEED + READ(10) with flag 0x08 |
+| 9 | `timing()` | Timing calibration |
+
+### Renesas (Planned)
+
+RS8xxx/RS9xxx chipsets used in Pioneer and some HL-DT-ST drives.
+Currently returns `Error::UnsupportedDrive` when a Renesas profile is matched.
+
+---
+
+## Why Unlock Is Needed
+
+Optical drive firmware restricts what applications can read from disc. Without
+unlock:
+
+- **READ(10) works for unencrypted filesystem data.** UDF structures, MPLS
+  playlists, and CLPI clip info are readable without unlock. The `read_disc()`
+  method uses standard READ(10) and works on any drive.
+
+- **READ(10) fails for encrypted content sectors.** The drive firmware returns
+  SCSI errors (sense key 0x05, illegal request) when an application attempts to
+  read sectors containing encrypted m2ts content without prior AACS
+  authentication via the bus key.
+
+- **The kernel sr driver blocks block-device reads.** On Linux, the kernel's
+  SCSI CD-ROM driver (`sr`) refuses to expose encrypted disc content through
+  `/dev/sr0` as a block device. Even if you open the block device directly,
+  reads to encrypted regions fail.
+
+- **Raw mode bypasses firmware restrictions.** After unlock, the drive accepts
+  READ(10) with the raw read flag (CDB byte 1 = 0x08) for all sectors,
+  regardless of encryption status. This is how raw sector ripping works.
+
+### open() vs open_no_unlock()
+
+AACS bus authentication uses standard MMC REPORT KEY / SEND KEY commands.
+These must execute before unlock because:
+
+1. The AACS handshake establishes a bus key via ECDH.
+2. The bus key encrypts the Volume ID and Read Data Key responses.
+3. The Volume ID is needed to derive the Volume Unique Key (VUK).
+4. The VUK is needed to decrypt unit keys from `Unit_Key_RO.inf`.
+
+If `open()` unlocks first, some drives reject the subsequent AACS commands.
+The correct sequence for encrypted discs is:
+
+```rust
+// 1. Open without unlock
+let mut session = DriveSession::open_no_unlock(device)?;
+
+// 2. AACS handshake (uses standard SCSI, no unlock needed)
+let auth = aacs_handshake::aacs_authenticate(&mut session, &key, &cert)?;
+let vid = aacs_handshake::read_volume_id(&mut session, &mut auth)?;
+
+// 3. Now unlock for raw reads
+session.unlock()?;
+session.calibrate()?;
+
+// 4. Read and decrypt content
+session.read_sectors(lba, count, &mut buf)?;
+```
+
+In practice, `Disc::scan()` handles this internally. The default `open()` call
+unlocks immediately and is correct for most use cases -- the scan re-opens a
+second session with `open_no_unlock()` for the AACS handshake when needed.
+
+---
+
+## Speed Control
+
+After `calibrate()`, the platform driver maintains a 64-entry speed lookup table
+built by probing the disc surface. On each `read_sectors()` call, the driver:
+
+1. Looks up the optimal speed for the target LBA in the table.
+2. Issues SET CD SPEED (0xBB) if the speed differs from current.
+3. Performs the READ(10).
+
+Available speeds:
+
+| Format | Speeds |
+|--------|--------|
+| Blu-ray | 1x (4,500 KB/s) through 12x (54,000 KB/s) |
+| DVD | 1x (1,385 KB/s) through 16x (22,160 KB/s) |
+| Max | 0xFFFF (drive decides) |

docs/mpls.md

@@ -0,0 +1,217 @@
+# MPLS Playlist Format
+
+## What is MPLS?
+
+MPLS (Movie PlayList) files define playback titles on a Blu-ray disc. Each `.mpls` file in `BDMV/PLAYLIST/` describes one title -- a sequence of clips with precise in/out timestamps and stream information. The main movie, bonus features, trailers, and menus each have their own MPLS file.
+
+A disc may contain dozens of MPLS files. Most are short (menus, logos, transitions). The main movie is typically the longest playlist. libfreemkv filters out playlists shorter than 30 seconds.
+
+## File Structure
+
+MPLS files use big-endian byte order throughout. The file has three main sections:
+
+```
+Offset  Size  Field
+------  ----  -----
+0       4     Magic: "MPLS"
+4       4     Version: "0200" (BD) or "0300" (UHD BD)
+8       4     PlayList start offset (absolute from file start)
+12      4     PlayListMark start offset
+16      4     ExtensionData start offset
+```
+
+### PlayList Section
+
+Located at the PlayList start offset. Contains all play items and sub-path entries:
+
+```
+Offset  Size  Field
+------  ----  -----
+0       4     PlayList length
+4       2     Reserved
+6       2     Number of PlayItems
+8       2     Number of SubPaths
+10      ...   PlayItem entries (variable length)
+```
+
+### Play Items
+
+Each play item references one clip and specifies what portion to play:
+
+```
+Offset  Size  Field
+------  ----  -----
+0       2     PlayItem length (bytes after this field)
+2       5     Clip ID (ASCII, e.g. "00001")
+7       4     Codec ID ("M2TS")
+11      1     Connection condition (lower 4 bits)
+12      1     Ref to STC_id
+14      4     IN_time (45kHz PTS ticks)
+18      4     OUT_time (45kHz PTS ticks)
+22      8     UO_mask_table
+30      1     Misc flags
+31      1     still_mode
+32      ...   STN_table (first play item only is parsed)
+```
+
+**Connection condition** values:
+- `1` = seamless connection (no gap between clips)
+- `5`, `6` = non-seamless connection
+
+**Timestamps** use 45kHz PTS (Presentation Time Stamp) ticks, the same timebase as MPEG transport streams. Duration of a play item = `OUT_time - IN_time`. To convert to seconds: divide by 45000.
+
+A playlist's total duration is the sum of all play item durations.
+
+### Clip ID Mapping
+
+The Clip ID (e.g. "00001") maps to:
+- `BDMV/STREAM/00001.m2ts` -- the transport stream
+- `BDMV/CLIPINF/00001.clpi` -- the clip info (EP map, stream details)
+
+## STN Table
+
+The Stream Number Table describes all elementary streams available in the clip. It is parsed from the first play item (which defines the title's stream layout).
+
+```
+Offset  Size  Field
+------  ----  -----
+0       2     STN table length
+2       2     Reserved
+4       1     Number of primary video streams
+5       1     Number of primary audio streams
+6       1     Number of PG (subtitle) streams
+7       1     Number of IG (interactive graphics) streams
+8       ...   Stream entries
+```
+
+### Stream Entries
+
+Each stream entry has two parts: a stream reference and a stream attributes block.
+
+**Stream reference:**
+
+```
+Offset  Size  Field
+------  ----  -----
+0       1     Entry length
+1       1     Stream type (1=PlayItem, 2=SubPath, 3=InMux)
+2       2     PID (MPEG-TS packet ID, big-endian)
+```
+
+**Stream attributes** (immediately follows the reference):
+
+```
+Offset  Size  Field
+------  ----  -----
+0       1     Attributes length
+1       1     Coding type
+2+      ...   Type-specific fields
+```
+
+The layout of type-specific fields depends on the stream category:
+
+**Video streams:**
+
+| Offset | Size | Field |
+|--------|------|-------|
+| 1 | 1 | Coding type |
+| 2 | 1 | Format (upper 4 bits) + frame rate (lower 4 bits) |
+
+**Audio streams:**
+
+| Offset | Size | Field |
+|--------|------|-------|
+| 1 | 1 | Coding type |
+| 2 | 1 | Format (upper 4 bits) + sample rate (lower 4 bits) |
+| 3 | 3 | Language code (ISO 639-2, e.g. "eng") |
+
+**PG subtitle and IG streams:**
+
+| Offset | Size | Field |
+|--------|------|-------|
+| 1 | 1 | Coding type |
+| 2 | 3 | Language code |
+
+## Coding Types
+
+The coding type byte identifies the codec:
+
+| Value | Codec | Category |
+|-------|-------|----------|
+| `0x02` | MPEG-2 | Video |
+| `0x1B` | H.264 / AVC | Video |
+| `0x24` | HEVC / H.265 | Video |
+| `0xEA` | VC-1 | Video |
+| `0x80` | LPCM | Audio |
+| `0x81` | AC-3 (Dolby Digital) | Audio |
+| `0x82` | DTS | Audio |
+| `0x83` | TrueHD (Dolby TrueHD) | Audio |
+| `0x84` | AC-3 Plus (E-AC-3) | Audio |
+| `0x85` | DTS-HD HR | Audio |
+| `0x86` | DTS-HD MA | Audio |
+| `0xA1` | AC-3 Plus (secondary) | Audio |
+| `0xA2` | DTS-HD HR (secondary) | Audio |
+| `0x90` | PGS (Presentation Graphics) | Subtitle |
+| `0x91` | PGS (Interactive Graphics) | Subtitle |
+
+## Video Format Codes
+
+| Value | Resolution |
+|-------|-----------|
+| 1 | 480i |
+| 2 | 576i |
+| 3 | 480p |
+| 4 | 1080i |
+| 5 | 720p |
+| 6 | 1080p |
+| 7 | 576p |
+| 8 | 2160p |
+
+## Video Frame Rate Codes
+
+| Value | Frame Rate |
+|-------|-----------|
+| 1 | 23.976 fps |
+| 2 | 24 fps |
+| 3 | 25 fps |
+| 4 | 29.97 fps |
+| 6 | 50 fps |
+| 7 | 59.94 fps |
+
+## Audio Format Codes
+
+| Value | Channels |
+|-------|----------|
+| 1 | Mono |
+| 3 | Stereo |
+| 6 | 5.1 surround |
+| 12 | 7.1 surround |
+
+## Audio Sample Rate Codes
+
+| Value | Rate |
+|-------|------|
+| 1 | 48 kHz |
+| 4 | 96 kHz |
+| 5 | 192 kHz |
+| 12 | 48/192 kHz (combo) |
+| 14 | 48/96 kHz (combo) |
+
+## How Playlists Map to Titles
+
+libfreemkv's `Disc::scan()` reads every MPLS file from the disc and builds a `Title` for each:
+
+1. Read all `.mpls` files from `BDMV/PLAYLIST/` via UDF.
+2. Parse each with `mpls::parse()`.
+3. Calculate duration by summing `(OUT_time - IN_time)` across all play items.
+4. Discard playlists shorter than 30 seconds.
+5. For each play item, load the corresponding CLPI file to get EP map data and compute sector extents (see [clpi.md](clpi.md)).
+6. Extract stream info from the STN table of the first play item.
+7. Sort titles by duration, longest first.
+
+The resulting `Title` struct contains everything needed to rip: streams, duration, byte size, and the sector extents to read from disc.
+
+## References
+
+- BD-ROM Part 3, Section 5.3: PlayList file format
+- https://github.com/lw/BluRay/wiki/MPLS

docs/udf.md

@@ -0,0 +1,169 @@
+# UDF 2.50 Filesystem Parser
+
+## What is UDF?
+
+UDF (Universal Disc Format) is the filesystem standard for optical media. It is defined by ECMA-167 with extensions from the OSTA (Optical Storage Technology Association). BD-ROM discs use UDF revision 2.50, which introduces the **metadata partition** -- a critical feature that separates file metadata from file content on disc.
+
+## Why UDF 2.50 for Blu-ray?
+
+Older UDF revisions (1.02, 1.50) scatter ICBs (file metadata) and file data across the same partition. On a high-capacity Blu-ray disc (25-100 GB), this creates excessive seeking when the drive needs to read a directory listing or locate a file. UDF 2.50 solves this by placing all metadata into a contiguous region near the beginning of the disc. The drive reads metadata from one compact area and streams file data from another -- no interleaved seeks.
+
+BD-ROM Part 3 of the Blu-ray specification mandates UDF 2.50.
+
+## Metadata Partitions
+
+A UDF 2.50 BD-ROM has two logical partitions:
+
+- **Partition 0 (Type 1)** -- the physical partition. Contains actual file data (m2ts streams, playlist files, etc.). Mapped directly to disc sectors starting at the Partition Descriptor's `partitionStartingLocation`.
+
+- **Partition 1 (Type 2)** -- the metadata partition. Contains all ICBs (Inode-like structures), directory data, and the File Set Descriptor. The metadata partition is itself stored as a file within the physical partition. Its location is found by reading an Extended File Entry at LBA 0 of the physical partition.
+
+The key rule: **ICBs and directory data live in the metadata partition. File content lives in the physical partition.** When an ICB's allocation descriptor gives an LBA, the partition it refers to depends on what the LBA describes -- metadata-relative for directory entries, physical-partition-relative for file data extents.
+
+## Pointer Chain
+
+Reading a UDF 2.50 filesystem follows a fixed chain of pointers. Each step reads one or two 2048-byte sectors:
+
+```
+Sector 256: AVDP (Anchor Volume Descriptor Pointer, tag 2)
+  |
+  v
+Sectors 32-63: VDS (Volume Descriptor Sequence)
+  |-- Partition Descriptor (tag 5) --> partition_start (physical sector)
+  |-- Logical Volume Descriptor (tag 6) --> partition maps, FSD location
+  |
+  v
+Partition Maps in LVD (offset 440):
+  |-- Map 0: Type 1 (physical partition)
+  |-- Map 1: Type 2 (metadata partition, identified by "*UDF Metadata Partition")
+  |
+  v
+Metadata file ICB at partition_start + 0 (Extended File Entry, tag 266)
+  |-- Allocation descriptor --> metadata content location
+  |
+  v
+metadata_start = partition_start + allocation_position
+  |
+  v
+FSD at metadata_start + 0 (File Set Descriptor, tag 256)
+  |-- Root Directory ICB: long_ad at offset 400 --> root_lba (metadata-relative)
+  |
+  v
+Root Directory ICB at metadata_start + root_lba (Extended File Entry, tag 266)
+  |-- Allocation descriptor --> directory data location (metadata-relative)
+  |
+  v
+Directory data: File Identifier Descriptors (tag 257)
+  |-- Each FID names a file/subdirectory and points to its ICB
+  |-- Recurse into subdirectories to build the full file tree
+```
+
+### AVDP (Sector 256)
+
+The Anchor Volume Descriptor Pointer is always at sector 256 (ECMA-167 section 10.2). It points to the Main Volume Descriptor Sequence. Tag identifier = 2.
+
+### VDS (Sectors 32+)
+
+The Volume Descriptor Sequence contains:
+
+- **Partition Descriptor (tag 5)**: byte offset 188 holds `partitionStartingLocation` -- the absolute sector where the physical partition begins.
+- **Logical Volume Descriptor (tag 6)**: byte offset 268 holds the number of partition maps. The partition maps themselves start at offset 440. For BD-ROM, map 0 is Type 1 (physical) and map 1 is Type 2 (metadata).
+- **Terminating Descriptor (tag 8)**: signals the end of the VDS.
+
+### Metadata File
+
+When two partition maps exist and the second is Type 2, the metadata partition content is located by reading the Extended File Entry at the first sector of the physical partition (partition_start + 0). This ICB's allocation descriptor gives the offset and length of the metadata content within the physical partition.
+
+### File Set Descriptor
+
+The FSD (tag 256) sits at metadata-relative LBA 0 (the first sector of the metadata content). It contains a long allocation descriptor at offset 400 pointing to the root directory ICB. The LBA in this long_ad is at bytes 404-407.
+
+### Directory Traversal
+
+Each directory is an ICB (Extended File Entry, tag 266, or File Entry, tag 261) whose allocation extent points to directory data. The directory data is a sequence of File Identifier Descriptors (FIDs, tag 257):
+
+| FID Field | Offset | Size | Description |
+|-----------|--------|------|-------------|
+| Tag | 0 | 2 | Always 257 |
+| File characteristics | 18 | 1 | Bit 1 = directory, bit 3 = parent |
+| L_FI (name length) | 19 | 1 | Length of filename |
+| ICB (long_ad) | 20 | 16 | Points to the entry's ICB |
+| L_IU | 36 | 2 | Implementation use length |
+| Filename | 38 + L_IU | L_FI | UDF-encoded filename |
+
+FIDs are 4-byte aligned. The parser advances by `(38 + L_IU + L_FI + 3) & !3` bytes per entry.
+
+### ICB Layout
+
+Both File Entry (tag 261) and Extended File Entry (tag 266) share the same info_length field:
+
+| Field | Tag 261 Offset | Tag 266 Offset |
+|-------|---------------|---------------|
+| info_length (u64) | 56 | 56 |
+| L_EA (u32) | 168 | 208 |
+| L_AD (u32) | 172 | 212 |
+| Allocation descriptors | 176 + L_EA | 216 + L_EA |
+
+Allocation descriptors use the Short Allocation Descriptor format: 4 bytes extent length (upper 2 bits = type), 4 bytes extent position (LBA).
+
+## How read_filesystem() Works
+
+The `read_filesystem()` function in `src/udf.rs` follows the pointer chain above:
+
+1. Reads sector 256, validates AVDP (tag 2).
+2. Scans sectors 32-63 for the Partition Descriptor and Logical Volume Descriptor.
+3. If two partition maps exist and the second is Type 2, reads the metadata file ICB at partition_start to find metadata_start.
+4. Reads the FSD at metadata_start, extracts the root directory ICB LBA.
+5. Calls `read_directory()` recursively (max depth 3) to build the full file tree.
+
+Each directory read involves two sector reads: one for the ICB, then one or more for the directory data. File sizes are read from info_length in each file's ICB.
+
+`read_file()` reads a file by navigating the directory tree, reading the file's ICB to get its data extent, then reading the data sector by sector from the **physical partition** (partition_start + LBA, not metadata_start).
+
+### UDF Filename Encoding
+
+UDF filenames use a compression ID as the first byte:
+- `8` = 8-bit characters (ASCII)
+- `16` = 16-bit big-endian Unicode (UTF-16BE)
+
+The parser handles both encodings. All path lookups are case-insensitive.
+
+## BD-ROM Directory Structure
+
+A typical Blu-ray disc has this directory layout:
+
+```
+/
++-- BDMV/
+|   +-- index.bdmv          Disc index (title list, first play)
+|   +-- MovieObject.bdmv    Movie objects (navigation commands)
+|   +-- PLAYLIST/
+|   |   +-- 00000.mpls      Main movie playlist
+|   |   +-- 00001.mpls      Director's commentary
+|   |   +-- ...
+|   +-- CLIPINF/
+|   |   +-- 00001.clpi      Clip info for 00001.m2ts
+|   |   +-- 00002.clpi
+|   |   +-- ...
+|   +-- STREAM/
+|   |   +-- 00001.m2ts      Transport stream (video/audio/subtitle data)
+|   |   +-- 00002.m2ts
+|   |   +-- ...
+|   +-- BACKUP/              Duplicate of index, MovieObject, playlists, clip info
+|
++-- AACS/                    AACS encryption data (encrypted discs only)
+|   +-- Unit_Key_RO.inf      Unit key file (encrypted)
+|   +-- MKB_RW.inf           Media Key Block
+|   +-- Content000.cer       Content certificate
+|   +-- DUPLICATE/           Backup copies
+|
++-- CERTIFICATE/             BD+ certificate data (some discs)
+```
+
+The parser reads from `BDMV/PLAYLIST/` and `BDMV/CLIPINF/` to discover titles and their sector layouts. The `BDMV/STREAM/` directory contains the actual transport streams but is not parsed by the UDF layer -- stream data is read by LBA directly using extents computed from CLPI EP maps.
+
+## References
+
+- ECMA-167: Volume and File Structure of Write-Once and Rewritable Media
+- UDF 2.50 (OSTA): Universal Disk Format Specification
+- BD-ROM Part 3: Blu-ray Disc Read-Only Format, File System Specifications

src/aacs/handshake.rs

@@ -0,0 +1,789 @@
+//! AACS bus authentication handshake — ECDH key agreement + bus key derivation.
+//!
+//! Implements the AACS SCSI authentication protocol to obtain:
+//!   - Volume ID (VID) — needed for VUK derivation
+//!   - Read Data Key — needed for AACS 2.0 (UHD) bus decryption
+//!
+//! Flow:
+//!   1. Invalidate AGIDs → allocate fresh AGID
+//!   2. Send host certificate + nonce
+//!   3. Receive drive certificate + nonce
+//!   4. Receive drive key point + signature, verify
+//!   5. Sign host key point, send
+//!   6. ECDH: host_priv × drive_key_point → bus key (low 128 bits of x)
+//!   7. Read VID or Read Data Keys (encrypted with bus key)
+//!
+//! Supports:
+//!   - AACS 1.0: custom 160-bit curve, SHA-1, 20-byte keys
+//!   - AACS 2.0: drives accept AACS 1.0 host certs for backward compatibility
+//!     (full P-256/SHA-256 AACS 2.0 handshake prepared but rarely needed)
+
+use crate::error::{Error, Result};
+use crate::drive::DriveSession;
+use crate::scsi::DataDirection;
+use num_bigint::BigUint;
+use num_traits::{One, Zero};
+use sha1::{Sha1, Digest};
+
+/// Execute a SCSI command that reads data from the device.
+fn scsi_read(session: &mut DriveSession, cdb: &[u8], len: usize) -> Result<Vec<u8>> {
+    let mut buf = vec![0u8; len];
+    session.scsi_execute(cdb, DataDirection::FromDevice, &mut buf, 5_000)?;
+    Ok(buf)
+}
+
+/// Execute a SCSI command that writes data to the device.
+fn scsi_write(session: &mut DriveSession, cdb: &[u8], data: &[u8]) -> Result<()> {
+    let mut buf = data.to_vec();
+    session.scsi_execute(cdb, DataDirection::ToDevice, &mut buf, 5_000)?;
+    Ok(())
+}
+
+// ── AACS 1.0 elliptic curve parameters (160-bit) ───────────────────────────
+
+const EC_P: [u8; 20] = [
+    0x9D, 0xC9, 0xD8, 0x13, 0x55, 0xEC, 0xCE, 0xB5, 0x60, 0xBD,
+    0xB0, 0x9E, 0xF9, 0xEA, 0xE7, 0xC4, 0x79, 0xA7, 0xD7, 0xDF,
+];
+const EC_A: [u8; 20] = [
+    0x9D, 0xC9, 0xD8, 0x13, 0x55, 0xEC, 0xCE, 0xB5, 0x60, 0xBD,
+    0xB0, 0x9E, 0xF9, 0xEA, 0xE7, 0xC4, 0x79, 0xA7, 0xD7, 0xDC,
+];
+#[cfg(test)]
+const EC_B: [u8; 20] = [
+    0x40, 0x2D, 0xAD, 0x3E, 0xC1, 0xCB, 0xCD, 0x16, 0x52, 0x48,
+    0xD6, 0x8E, 0x12, 0x45, 0xE0, 0xC4, 0xDA, 0xAC, 0xB1, 0xD8,
+];
+const EC_N: [u8; 20] = [
+    0x9D, 0xC9, 0xD8, 0x13, 0x55, 0xEC, 0xCE, 0xB5, 0x60, 0xBD,
+    0xC4, 0x4F, 0x54, 0x81, 0x7B, 0x2C, 0x7F, 0x5A, 0xB0, 0x17,
+];
+const EC_GX: [u8; 20] = [
+    0x2E, 0x64, 0xFC, 0x22, 0x57, 0x83, 0x51, 0xE6, 0xF4, 0xCC,
+    0xA7, 0xEB, 0x81, 0xD0, 0xA4, 0xBD, 0xC5, 0x4C, 0xCE, 0xC6,
+];
+const EC_GY: [u8; 20] = [
+    0x09, 0x14, 0xA2, 0x5D, 0xD0, 0x54, 0x42, 0x88, 0x9D, 0xB4,
+    0x55, 0xC7, 0xF2, 0x3C, 0x9A, 0x07, 0x07, 0xF5, 0xCB, 0xB9,
+];
+
+// ── AACS LA (Licensing Administrator) public key for cert verification ──────
+
+const AACS_LA_PUB_X: [u8; 20] = [
+    0x01, 0xF3, 0x5D, 0xAB, 0xD8, 0xAE, 0x5F, 0x40, 0x56, 0x5E,
+    0x30, 0xC8, 0x8A, 0x60, 0x42, 0x82, 0x07, 0x61, 0xDF, 0x93,
+];
+const AACS_LA_PUB_Y: [u8; 20] = [
+    0x44, 0x87, 0xB5, 0xAC, 0x07, 0x10, 0x8D, 0x10, 0x5B, 0xA5,
+    0xB9, 0xE3, 0x2F, 0x3B, 0xBB, 0xFC, 0x0C, 0x2C, 0xBC, 0xD1,
+];
+
+// ── Elliptic curve arithmetic over GF(p) ───────────────────────────────────
+
+#[derive(Clone, Debug)]
+struct EcPoint {
+    x: BigUint,
+    y: BigUint,
+    infinity: bool,
+}
+
+impl EcPoint {
+    fn infinity() -> Self {
+        EcPoint { x: BigUint::zero(), y: BigUint::zero(), infinity: true }
+    }
+
+    fn new(x: BigUint, y: BigUint) -> Self {
+        EcPoint { x, y, infinity: false }
+    }
+
+    fn from_bytes(x_bytes: &[u8], y_bytes: &[u8]) -> Self {
+        EcPoint::new(BigUint::from_bytes_be(x_bytes), BigUint::from_bytes_be(y_bytes))
+    }
+}
+
+/// Modular inverse using extended Euclidean algorithm.
+fn mod_inv(a: &BigUint, m: &BigUint) -> Option<BigUint> {
+    use num_bigint::BigInt;
+    use num_traits::Signed;
+
+    let a = BigInt::from(a.clone());
+    let m = BigInt::from(m.clone());
+
+    let (mut old_r, mut r) = (a, m.clone());
+    let (mut old_s, mut s) = (BigInt::one(), BigInt::zero());
+
+    while !r.is_zero() {
+        let q = &old_r / &r;
+        let temp_r = r.clone();
+        r = old_r - &q * &r;
+        old_r = temp_r;
+        let temp_s = s.clone();
+        s = old_s - &q * &s;
+        old_s = temp_s;
+    }
+
+    if old_r != BigInt::one() {
+        return None;
+    }
+
+    if old_s.is_negative() {
+        old_s += &m;
+    }
+    Some(old_s.to_biguint().unwrap())
+}
+
+/// EC point addition on curve y² = x³ + ax + b (mod p).
+fn ec_add(p1: &EcPoint, p2: &EcPoint, a: &BigUint, p: &BigUint) -> EcPoint {
+    if p1.infinity { return p2.clone(); }
+    if p2.infinity { return p1.clone(); }
+
+    if p1.x == p2.x {
+        if p1.y == p2.y && !p1.y.is_zero() {
+            return ec_double(p1, a, p);
+        }
+        return EcPoint::infinity();
+    }
+
+    // λ = (y2 - y1) / (x2 - x1) mod p
+    let dy = if p2.y >= p1.y {
+        (&p2.y - &p1.y) % p
+    } else {
+        (p - (&p1.y - &p2.y) % p) % p
+    };
+    let dx = if p2.x >= p1.x {
+        (&p2.x - &p1.x) % p
+    } else {
+        (p - (&p1.x - &p2.x) % p) % p
+    };
+
+    let dx_inv = mod_inv(&dx, p).unwrap();
+    let lam = (&dy * &dx_inv) % p;
+
+    // x3 = λ² - x1 - x2 mod p
+    let x3 = {
+        let lam2 = (&lam * &lam) % p;
+        let sum = (&p1.x + &p2.x) % p;
+        if lam2 >= sum {
+            (lam2 - sum) % p
+        } else {
+            (p - (sum - lam2) % p) % p
+        }
+    };
+
+    // y3 = λ(x1 - x3) - y1 mod p
+    let y3 = {
+        let diff = if p1.x >= x3 {
+            (&p1.x - &x3) % p
+        } else {
+            (p - (&x3 - &p1.x) % p) % p
+        };
+        let prod = (&lam * &diff) % p;
+        if prod >= p1.y {
+            (prod - &p1.y) % p
+        } else {
+            (p - (&p1.y - prod) % p) % p
+        }
+    };
+
+    EcPoint::new(x3, y3)
+}
+
+/// EC point doubling.
+fn ec_double(pt: &EcPoint, a: &BigUint, p: &BigUint) -> EcPoint {
+    if pt.infinity || pt.y.is_zero() {
+        return EcPoint::infinity();
+    }
+
+    // λ = (3x² + a) / (2y) mod p
+    let three = BigUint::from(3u32);
+    let two = BigUint::from(2u32);
+
+    let numerator = (&three * &pt.x * &pt.x + a) % p;
+    let denominator = (&two * &pt.y) % p;
+    let denom_inv = mod_inv(&denominator, p).unwrap();
+    let lam = (&numerator * &denom_inv) % p;
+
+    // x3 = λ² - 2x mod p
+    let x3 = {
+        let lam2 = (&lam * &lam) % p;
+        let two_x = (&two * &pt.x) % p;
+        if lam2 >= two_x {
+            (lam2 - two_x) % p
+        } else {
+            (p - (two_x - lam2) % p) % p
+        }
+    };
+
+    // y3 = λ(x - x3) - y mod p
+    let y3 = {
+        let diff = if pt.x >= x3 {
+            (&pt.x - &x3) % p
+        } else {
+            (p - (&x3 - &pt.x) % p) % p
+        };
+        let prod = (&lam * &diff) % p;
+        if prod >= pt.y {
+            (prod - &pt.y) % p
+        } else {
+            (p - (&pt.y - prod) % p) % p
+        }
+    };
+
+    EcPoint::new(x3, y3)
+}
+
+/// Scalar multiplication using double-and-add.
+fn ec_mul(k: &BigUint, pt: &EcPoint, a: &BigUint, p: &BigUint) -> EcPoint {
+    if k.is_zero() {
+        return EcPoint::infinity();
+    }
+
+    let mut result = EcPoint::infinity();
+    let mut base = pt.clone();
+    let mut scalar = k.clone();
+
+    while !scalar.is_zero() {
+        if scalar.bit(0) {
+            result = ec_add(&result, &base, a, p);
+        }
+        base = ec_double(&base, a, p);
+        scalar >>= 1;
+    }
+
+    result
+}
+
+/// Convert BigUint to fixed-size big-endian bytes, zero-padded.
+fn to_bytes_be_padded(n: &BigUint, len: usize) -> Vec<u8> {
+    let bytes = n.to_bytes_be();
+    if bytes.len() >= len {
+        bytes[bytes.len() - len..].to_vec()
+    } else {
+        let mut padded = vec![0u8; len - bytes.len()];
+        padded.extend_from_slice(&bytes);
+        padded
+    }
+}
+
+// ── ECDSA ───────────────────────────────────────────────────────────────────
+
+/// ECDSA sign: sign SHA-1(data) with private key on AACS curve.
+/// Returns (r, s) each 20 bytes.
+fn ecdsa_sign(priv_key: &[u8; 20], data: &[u8]) -> ([u8; 20], [u8; 20]) {
+    let p = BigUint::from_bytes_be(&EC_P);
+    let a = BigUint::from_bytes_be(&EC_A);
+    let n = BigUint::from_bytes_be(&EC_N);
+    let g = EcPoint::from_bytes(&EC_GX, &EC_GY);
+    let d = BigUint::from_bytes_be(priv_key);
+
+    // Hash the data
+    let hash = Sha1::digest(data);
+    let z = BigUint::from_bytes_be(&hash);
+
+    loop {
+        // Generate random k
+        let mut k_bytes = [0u8; 20];
+        use rand::RngCore;
+        rand::thread_rng().fill_bytes(&mut k_bytes);
+        let k = BigUint::from_bytes_be(&k_bytes) % &n;
+        if k.is_zero() { continue; }
+
+        // R = k × G
+        let r_point = ec_mul(&k, &g, &a, &p);
+        let r = &r_point.x % &n;
+        if r.is_zero() { continue; }
+
+        // s = k⁻¹(z + r·d) mod n
+        let k_inv = match mod_inv(&k, &n) {
+            Some(v) => v,
+            None => continue,
+        };
+        let s = (&k_inv * ((&z + &r * &d) % &n)) % &n;
+        if s.is_zero() { continue; }
+
+        let r_bytes = to_bytes_be_padded(&r, 20);
+        let s_bytes = to_bytes_be_padded(&s, 20);
+
+        let mut r_out = [0u8; 20];
+        let mut s_out = [0u8; 20];
+        r_out.copy_from_slice(&r_bytes);
+        s_out.copy_from_slice(&s_bytes);
+
+        return (r_out, s_out);
+    }
+}
+
+/// ECDSA verify: verify signature (r, s) against SHA-1(data) using public key.
+fn ecdsa_verify(pub_x: &[u8; 20], pub_y: &[u8; 20], sig_r: &[u8; 20], sig_s: &[u8; 20], data: &[u8]) -> bool {
+    let p = BigUint::from_bytes_be(&EC_P);
+    let a = BigUint::from_bytes_be(&EC_A);
+    let n = BigUint::from_bytes_be(&EC_N);
+    let g = EcPoint::from_bytes(&EC_GX, &EC_GY);
+    let q = EcPoint::from_bytes(pub_x, pub_y);
+
+    let r = BigUint::from_bytes_be(sig_r);
+    let s = BigUint::from_bytes_be(sig_s);
+
+    if r.is_zero() || r >= n || s.is_zero() || s >= n {
+        return false;
+    }
+
+    let hash = Sha1::digest(data);
+    let z = BigUint::from_bytes_be(&hash);
+
+    let s_inv = match mod_inv(&s, &n) {
+        Some(v) => v,
+        None => return false,
+    };
+
+    let u1 = (&z * &s_inv) % &n;
+    let u2 = (&r * &s_inv) % &n;
+
+    let p1 = ec_mul(&u1, &g, &a, &p);
+    let p2 = ec_mul(&u2, &q, &a, &p);
+    let r_point = ec_add(&p1, &p2, &a, &p);
+
+    if r_point.infinity {
+        return false;
+    }
+
+    &r_point.x % &n == r
+}
+
+// ── AACS certificate handling ───────────────────────────────────────────────
+
+/// Verify an AACS certificate (92 bytes) against the AACS LA public key.
+fn verify_cert(cert: &[u8]) -> bool {
+    if cert.len() < 92 { return false; }
+    // Certificate format: type(1) + flags(1) + padding(2) + serial(6) + pub_x(20) + pub_y(20) + sig_r(20) + sig_s(20)
+    // Signature is over the first 52 bytes
+    let mut sig_r = [0u8; 20];
+    let mut sig_s = [0u8; 20];
+    sig_r.copy_from_slice(&cert[52..72]);
+    sig_s.copy_from_slice(&cert[72..92]);
+
+    ecdsa_verify(&AACS_LA_PUB_X, &AACS_LA_PUB_Y, &sig_r, &sig_s, &cert[..52])
+}
+
+/// Extract public key from certificate.
+fn cert_pub_key(cert: &[u8]) -> ([u8; 20], [u8; 20]) {
+    let mut x = [0u8; 20];
+    let mut y = [0u8; 20];
+    x.copy_from_slice(&cert[12..32]);
+    y.copy_from_slice(&cert[32..52]);
+    (x, y)
+}
+
+// ── Bus key derivation (ECDH) ───────────────────────────────────────────────
+
+/// Compute bus key via ECDH: bus_key = low 128 bits of (host_priv × drive_key_point).x
+fn compute_bus_key(host_priv: &[u8; 20], drive_key_point_x: &[u8; 20], drive_key_point_y: &[u8; 20]) -> [u8; 16] {
+    let p = BigUint::from_bytes_be(&EC_P);
+    let a = BigUint::from_bytes_be(&EC_A);
+
+    let d = BigUint::from_bytes_be(host_priv);
+    let dkp = EcPoint::from_bytes(drive_key_point_x, drive_key_point_y);
+
+    let shared = ec_mul(&d, &dkp, &a, &p);
+
+    // Bus key = lowest 128 bits (last 16 bytes) of x-coordinate
+    let x_bytes = to_bytes_be_padded(&shared.x, 20);
+    let mut bus_key = [0u8; 16];
+    bus_key.copy_from_slice(&x_bytes[4..20]); // last 16 of 20
+    bus_key
+}
+
+/// Generate ephemeral host key pair: (private_key, public_point_x, public_point_y).
+fn generate_host_key_pair() -> ([u8; 20], [u8; 20], [u8; 20]) {
+    let p_mod = BigUint::from_bytes_be(&EC_P);
+    let a = BigUint::from_bytes_be(&EC_A);
+    let g = EcPoint::from_bytes(&EC_GX, &EC_GY);
+
+    let mut priv_bytes = [0u8; 20];
+    use rand::RngCore;
+    rand::thread_rng().fill_bytes(&mut priv_bytes);
+    let d = BigUint::from_bytes_be(&priv_bytes);
+
+    let q = ec_mul(&d, &g, &a, &p_mod);
+
+    let qx = to_bytes_be_padded(&q.x, 20);
+    let qy = to_bytes_be_padded(&q.y, 20);
+
+    let mut pub_x = [0u8; 20];
+    let mut pub_y = [0u8; 20];
+    pub_x.copy_from_slice(&qx);
+    pub_y.copy_from_slice(&qy);
+
+    (priv_bytes, pub_x, pub_y)
+}
+
+// ── AES-CMAC (for MAC verification) ────────────────────────────────────────
+
+/// AES-128-CMAC over 16 bytes of data.
+fn aes_cmac_16(data: &[u8; 16], key: &[u8; 16]) -> [u8; 16] {
+    use aes::Aes128;
+    use aes::cipher::{BlockEncrypt, KeyInit, generic_array::GenericArray};
+
+    let cipher = Aes128::new(GenericArray::from_slice(key));
+
+    // For single-block CMAC:
+    // 1. Generate subkey K1
+    let mut l = GenericArray::clone_from_slice(&[0u8; 16]);
+    cipher.encrypt_block(&mut l);
+
+    let mut k1 = [0u8; 16];
+    let carry = (l[0] >> 7) & 1;
+    for i in 0..15 {
+        k1[i] = (l[i] << 1) | (l[i + 1] >> 7);
+    }
+    k1[15] = l[15] << 1;
+    if carry == 1 {
+        k1[15] ^= 0x87; // Rb for AES-128
+    }
+
+    // 2. XOR data with K1, encrypt
+    let mut block = [0u8; 16];
+    for i in 0..16 {
+        block[i] = data[i] ^ k1[i];
+    }
+    let mut ga = GenericArray::clone_from_slice(&block);
+    cipher.encrypt_block(&mut ga);
+
+    let mut mac = [0u8; 16];
+    mac.copy_from_slice(&ga);
+    mac
+}
+
+// ── SCSI command builders ───────────────────────────────────────────────────
+
+/// Build REPORT KEY CDB (0xA4).
+fn cdb_report_key(agid: u8, format: u8, len: u16) -> [u8; 12] {
+    let mut cdb = [0u8; 12];
+    cdb[0] = crate::scsi::SCSI_REPORT_KEY;
+    cdb[7] = crate::scsi::AACS_KEY_CLASS;
+    cdb[8] = (len >> 8) as u8;
+    cdb[9] = (len & 0xFF) as u8;
+    cdb[10] = (agid << 6) | (format & 0x3F);
+    cdb
+}
+
+/// Build SEND KEY CDB (0xA3).
+fn cdb_send_key(agid: u8, format: u8, len: u16) -> [u8; 12] {
+    let mut cdb = [0u8; 12];
+    cdb[0] = crate::scsi::SCSI_SEND_KEY;
+    cdb[7] = crate::scsi::AACS_KEY_CLASS;
+    cdb[8] = (len >> 8) as u8;
+    cdb[9] = (len & 0xFF) as u8;
+    cdb[10] = (agid << 6) | (format & 0x3F);
+    cdb
+}
+
+/// Build REPORT DISC STRUCTURE CDB (0xAD).
+fn cdb_report_disc_structure(agid: u8, format: u8, len: u16) -> [u8; 12] {
+    let mut cdb = [0u8; 12];
+    cdb[0] = crate::scsi::SCSI_READ_DISC_STRUCTURE;
+    cdb[1] = 0x01; // Blu-ray
+    cdb[7] = format;
+    cdb[8] = (len >> 8) as u8;
+    cdb[9] = (len & 0xFF) as u8;
+    cdb[10] = agid << 6;
+    cdb
+}
+
+// ── High-level handshake ────────────────────────────────────────────────────
+
+/// Result of a successful AACS authentication handshake.
+#[derive(Debug)]
+pub struct AacsAuth {
+    /// Bus key (16 bytes) — derived from ECDH
+    pub bus_key: [u8; 16],
+    /// AGID used for this session
+    pub agid: u8,
+    /// Volume ID (16 bytes) — read after auth
+    pub volume_id: Option<[u8; 16]>,
+    /// Read data key (16 bytes) — for AACS 2.0 bus decryption
+    pub read_data_key: Option<[u8; 16]>,
+    /// Drive certificate (92 bytes)
+    pub drive_cert: [u8; 92],
+}
+
+/// Perform the full AACS authentication handshake.
+///
+/// Requires a host private key (20 bytes) and host certificate (92 bytes)
+/// from the KEYDB.cfg HC entry.
+pub fn aacs_authenticate(
+    session: &mut DriveSession,
+    host_priv_key: &[u8; 20],
+    host_cert: &[u8],
+) -> Result<AacsAuth> {
+    if host_cert.len() < 92 {
+        return Err(Error::AacsError { detail: "host certificate too short".into() });
+    }
+
+    // Step 1: Invalidate all AGIDs
+    for agid in 0..4u8 {
+        let cdb = cdb_report_key(agid, 0x3F, 2);
+        let _ = scsi_read(session, &cdb, 2);
+    }
+
+    // Step 2: Allocate AGID
+    let cdb = cdb_report_key(0, 0x00, 8);
+    let response = scsi_read(session, &cdb, 8)
+        .map_err(|e| Error::AacsError { detail: format!("failed to allocate AGID: {}", e) })?;
+    let agid = (response[7] >> 6) & 0x03;
+
+    // Step 3: Generate host nonce and ephemeral key pair
+    let mut host_nonce = [0u8; 20];
+    use rand::RngCore;
+    rand::thread_rng().fill_bytes(&mut host_nonce);
+    let (host_key, host_key_point_x, host_key_point_y) = generate_host_key_pair();
+
+    // Step 4: Send host certificate + nonce (SEND KEY format 0x01)
+    let mut send_buf = [0u8; 116];
+    send_buf[1] = 0x72; // data length
+    send_buf[4..24].copy_from_slice(&host_nonce);
+    send_buf[24..116].copy_from_slice(&host_cert[..92]);
+
+    let cdb = cdb_send_key(agid, 0x01, 116);
+    scsi_write(session, &cdb, &send_buf)
+        .map_err(|_| Error::AacsError { detail: "drive rejected host certificate".into() })?;
+
+    // Step 5: Read drive certificate + nonce (REPORT KEY format 0x01)
+    let cdb = cdb_report_key(agid, 0x01, 116);
+    let response = scsi_read(session, &cdb, 116)
+        .map_err(|_| Error::AacsError { detail: "failed to read drive certificate".into() })?;
+
+    let mut drive_nonce = [0u8; 20];
+    let mut drive_cert = [0u8; 92];
+    drive_nonce.copy_from_slice(&response[4..24]);
+    drive_cert.copy_from_slice(&response[24..116]);
+
+    // Detect AACS 2.0 drive certificate (type 0x11)
+    // AACS 2.0 drives use P-256/SHA-256 natively but accept AACS 1.0 host certs
+    // for backward compatibility. We proceed with AACS 1.0 handshake.
+    if drive_cert[0] == 0x11 {
+        // AACS 2.0 drive detected — falling back to AACS 1.0 handshake
+        // (full P-256 AACS 2.0 handshake not yet implemented)
+        // The drive should still accept our AACS 1.0 host certificate.
+    }
+
+    // Verify drive certificate (AACS 1.0 LA signature)
+    if drive_cert[0] == 0x01 && !verify_cert(&drive_cert) {
+        return Err(Error::AacsError { detail: "drive certificate verification failed".into() });
+    }
+    // Skip verification for AACS 2.0 certs (different LA key, P-256 curve)
+
+    // Step 6: Read drive key point + signature (REPORT KEY format 0x02)
+    let cdb = cdb_report_key(agid, 0x02, 84);
+    let response = scsi_read(session, &cdb, 84)
+        .map_err(|_| Error::AacsError { detail: "failed to read drive key".into() })?;
+
+    let mut drive_key_point = [0u8; 40];   // x(20) + y(20)
+    let mut drive_key_sig = [0u8; 40];     // r(20) + s(20)
+    drive_key_point.copy_from_slice(&response[4..44]);
+    drive_key_sig.copy_from_slice(&response[44..84]);
+
+    // Verify drive key signature: sign(drive_nonce=host_nonce || drive_key_point)
+    let (drive_pub_x, drive_pub_y) = cert_pub_key(&drive_cert);
+    let mut verify_data = [0u8; 60];
+    verify_data[..20].copy_from_slice(&host_nonce);
+    verify_data[20..60].copy_from_slice(&drive_key_point);
+
+    let mut sig_r = [0u8; 20];
+    let mut sig_s = [0u8; 20];
+    sig_r.copy_from_slice(&drive_key_sig[..20]);
+    sig_s.copy_from_slice(&drive_key_sig[20..40]);
+
+    if !ecdsa_verify(&drive_pub_x, &drive_pub_y, &sig_r, &sig_s, &verify_data) {
+        return Err(Error::AacsError { detail: "drive key signature verification failed".into() });
+    }
+
+    // Step 7: Sign host key point (ECDSA over drive_nonce || host_key_point)
+    let mut sign_data = [0u8; 60];
+    sign_data[..20].copy_from_slice(&drive_nonce);
+    sign_data[20..40].copy_from_slice(&host_key_point_x);
+    sign_data[40..60].copy_from_slice(&host_key_point_y);
+
+    let (host_sig_r, host_sig_s) = ecdsa_sign(host_priv_key, &sign_data);
+
+    // Step 8: Send host key point + signature (SEND KEY format 0x02)
+    let mut send_buf = [0u8; 84];
+    send_buf[1] = 0x52;
+    send_buf[4..24].copy_from_slice(&host_key_point_x);
+    send_buf[24..44].copy_from_slice(&host_key_point_y);
+    send_buf[44..64].copy_from_slice(&host_sig_r);
+    send_buf[64..84].copy_from_slice(&host_sig_s);
+
+    let cdb = cdb_send_key(agid, 0x02, 84);
+    scsi_write(session, &cdb, &send_buf)
+        .map_err(|_| Error::AacsError { detail: "drive rejected host key".into() })?;
+
+    // Step 9: Compute bus key via ECDH
+    let mut dkp_x = [0u8; 20];
+    let mut dkp_y = [0u8; 20];
+    dkp_x.copy_from_slice(&drive_key_point[..20]);
+    dkp_y.copy_from_slice(&drive_key_point[20..40]);
+
+    let bus_key = compute_bus_key(&host_key, &dkp_x, &dkp_y);
+
+    Ok(AacsAuth {
+        bus_key,
+        agid,
+        volume_id: None,
+        read_data_key: None,
+        drive_cert,
+    })
+}
+
+/// Read Volume ID after successful authentication.
+pub fn read_volume_id(session: &mut DriveSession, auth: &mut AacsAuth) -> Result<[u8; 16]> {
+    // REPORT DISC STRUCTURE format 0x80
+    let cdb = cdb_report_disc_structure(auth.agid, 0x80, 36);
+    let response = scsi_read(session, &cdb, 36)
+        .map_err(|_| Error::AacsError { detail: "failed to read Volume ID".into() })?;
+
+    let mut vid = [0u8; 16];
+    let mut mac = [0u8; 16];
+    vid.copy_from_slice(&response[4..20]);
+    mac.copy_from_slice(&response[20..36]);
+
+    // Verify MAC: AES-CMAC(VID, bus_key) should equal mac
+    let calc_mac = aes_cmac_16(&vid, &auth.bus_key);
+    if calc_mac != mac {
+        return Err(Error::AacsError { detail: "VID MAC verification failed".into() });
+    }
+
+    auth.volume_id = Some(vid);
+    Ok(vid)
+}
+
+/// Read data keys after successful authentication (for AACS 2.0 bus encryption).
+pub fn read_data_keys(session: &mut DriveSession, auth: &mut AacsAuth) -> Result<([u8; 16], [u8; 16])> {
+    // REPORT DISC STRUCTURE format 0x84
+    let cdb = cdb_report_disc_structure(auth.agid, 0x84, 36);
+    let response = scsi_read(session, &cdb, 36)
+        .map_err(|_| Error::AacsError { detail: "failed to read data keys".into() })?;
+
+    let mut enc_rdk = [0u8; 16];
+    let mut enc_wdk = [0u8; 16];
+    enc_rdk.copy_from_slice(&response[4..20]);
+    enc_wdk.copy_from_slice(&response[20..36]);
+
+    // Decrypt with bus key (AES-ECB)
+    let read_data_key = super::aes_ecb_decrypt(&auth.bus_key, &enc_rdk);
+    let write_data_key = super::aes_ecb_decrypt(&auth.bus_key, &enc_wdk);
+
+    auth.read_data_key = Some(read_data_key);
+    Ok((read_data_key, write_data_key))
+}
+
+// ── Tests ───────────────────────────────────────────────────────────────────
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_ec_curve_generator_on_curve() {
+        // Verify G is on the curve: y² = x³ + ax + b (mod p)
+        let p = BigUint::from_bytes_be(&EC_P);
+        let a = BigUint::from_bytes_be(&EC_A);
+        let b = BigUint::from_bytes_be(&EC_B);
+        let gx = BigUint::from_bytes_be(&EC_GX);
+        let gy = BigUint::from_bytes_be(&EC_GY);
+
+        let lhs = (&gy * &gy) % &p;
+        let rhs = (&gx * &gx * &gx + &a * &gx + &b) % &p;
+        assert_eq!(lhs, rhs, "Generator point is not on the curve");
+    }
+
+    #[test]
+    fn test_ec_mul_identity() {
+        let p = BigUint::from_bytes_be(&EC_P);
+        let a = BigUint::from_bytes_be(&EC_A);
+        let g = EcPoint::from_bytes(&EC_GX, &EC_GY);
+
+        // 1 × G = G
+        let result = ec_mul(&BigUint::one(), &g, &a, &p);
+        assert_eq!(result.x, g.x);
+        assert_eq!(result.y, g.y);
+    }
+
+    #[test]
+    fn test_ec_mul_order() {
+        // n × G = O (point at infinity)
+        let p = BigUint::from_bytes_be(&EC_P);
+        let a = BigUint::from_bytes_be(&EC_A);
+        let n = BigUint::from_bytes_be(&EC_N);
+        let g = EcPoint::from_bytes(&EC_GX, &EC_GY);
+
+        let result = ec_mul(&n, &g, &a, &p);
+        assert!(result.infinity, "n × G should be point at infinity");
+    }
+
+    #[test]
+    fn test_ecdsa_sign_verify() {
+        // Generate a key pair and test sign/verify
+        let (priv_key, pub_x, pub_y) = generate_host_key_pair();
+        let data = b"test data for AACS ECDSA";
+
+        let (sig_r, sig_s) = ecdsa_sign(&priv_key, data);
+        assert!(ecdsa_verify(&pub_x, &pub_y, &sig_r, &sig_s, data),
+            "ECDSA signature should verify");
+
+        // Verify with wrong data fails
+        assert!(!ecdsa_verify(&pub_x, &pub_y, &sig_r, &sig_s, b"wrong data"),
+            "ECDSA should fail with wrong data");
+    }
+
+    #[test]
+    fn test_ecdh_shared_secret() {
+        // Two parties should derive the same shared point
+        let p = BigUint::from_bytes_be(&EC_P);
+        let a = BigUint::from_bytes_be(&EC_A);
+        let g = EcPoint::from_bytes(&EC_GX, &EC_GY);
+
+        let (priv_a, pub_ax, pub_ay) = generate_host_key_pair();
+        let (priv_b, pub_bx, pub_by) = generate_host_key_pair();
+
+        // A computes: priv_a × pub_B
+        let shared_a = compute_bus_key(&priv_a, &pub_bx, &pub_by);
+        // B computes: priv_b × pub_A
+        let shared_b = compute_bus_key(&priv_b, &pub_ax, &pub_ay);
+
+        assert_eq!(shared_a, shared_b, "ECDH shared secrets should match");
+    }
+
+    #[test]
+    fn test_aes_cmac() {
+        // Basic CMAC test — at minimum verify it produces consistent output
+        let key = [0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
+                   0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c];
+        let data = [0u8; 16];
+        let mac1 = aes_cmac_16(&data, &key);
+        let mac2 = aes_cmac_16(&data, &key);
+        assert_eq!(mac1, mac2);
+        assert_ne!(mac1, [0u8; 16]); // shouldn't be all zeros
+    }
+
+    #[test]
+    fn test_verify_host_cert_from_keydb() {
+        // Verify the host cert from our KEYDB
+        let keydb_path = match std::env::var("KEYDB_PATH").ok() {
+            Some(p) => std::path::PathBuf::from(p),
+            None => return, // skip if KEYDB_PATH not set
+        };
+        if !keydb_path.exists() { return; }
+
+        let db = crate::aacs::KeyDb::load(&keydb_path).unwrap();
+        if let Some(hc) = &db.host_cert {
+            let valid = verify_cert(&hc.certificate);
+            eprintln!("Host cert verification: {}", if valid { "PASS" } else { "FAIL" });
+            // Note: our cert is revoked but should still have valid LA signature
+            // If it doesn't verify, the LA public key might be wrong
+            if !valid {
+                eprintln!("  (cert may use different LA key or format)");
+            }
+        }
+    }
+}

src/bin/freemkv_info.rs

@@ -1,159 +0,0 @@
-//! freemkv-info — Drive identification and compatibility checker.
-//!
-//! Sends standard SCSI INQUIRY and GET CONFIGURATION commands to an optical drive,
-//! displays drive identity and compatibility status, and optionally outputs raw
-//! response data for profile contribution.
-//!
-//! Usage:
-//!   freemkv-info /dev/sr0
-//!   freemkv-info /dev/sr0 --raw
-//!   freemkv-info /dev/sr0 --json
-
-use std::env;
-use std::path::Path;
-use std::process;
-
-fn main() {
-    let args: Vec<String> = env::args().collect();
-
-    if args.len() < 2 {
-        eprintln!("freemkv-info — Drive identification and compatibility checker");
-        eprintln!();
-        eprintln!("Usage: freemkv-info <device> [options]");
-        eprintln!();
-        eprintln!("  <device>    Optical drive device (e.g. /dev/sr0)");
-        eprintln!("  --raw       Output raw SCSI response hex (for profile contribution)");
-        eprintln!("  --json      Output machine-readable JSON");
-        eprintln!("  --profiles  Path to profiles directory (default: ./profiles)");
-        eprintln!();
-        eprintln!("Examples:");
-        eprintln!("  freemkv-info /dev/sr0");
-        eprintln!("  freemkv-info /dev/sr0 --raw > my_drive.txt");
-        process::exit(1);
-    }
-
-    let device = Path::new(&args[1]);
-    let raw_mode = args.iter().any(|a| a == "--raw");
-    let json_mode = args.iter().any(|a| a == "--json");
-    let profiles_dir = args.iter()
-        .position(|a| a == "--profiles")
-        .and_then(|i| args.get(i + 1))
-        .map(|s| s.as_str())
-        .unwrap_or("profiles");
-
-    // Open SCSI transport
-    let mut transport = match libfreemkv::scsi::open(device) {
-        Ok(t) => t,
-        Err(e) => {
-            eprintln!("Error: Cannot open {}: {}", device.display(), e);
-            process::exit(1);
-        }
-    };
-
-    // INQUIRY
-    let inquiry = match libfreemkv::scsi::inquiry(transport.as_mut()) {
-        Ok(i) => i,
-        Err(e) => {
-            eprintln!("Error: INQUIRY failed: {}", e);
-            process::exit(1);
-        }
-    };
-
-    // GET CONFIGURATION feature 0x010C
-    let gc_010c = libfreemkv::scsi::get_config_010c(transport.as_mut()).ok();
-
-    if json_mode {
-        print_json(&inquiry, &gc_010c);
-    } else if raw_mode {
-        print_raw(&inquiry, &gc_010c);
-    } else {
-        print_human(&inquiry, &gc_010c, profiles_dir);
-    }
-}
-
-fn print_human(
-    inquiry: &libfreemkv::scsi::InquiryResult,
-    gc_010c: &Option<Vec<u8>>,
-    profiles_dir: &str,
-) {
-    println!("freemkv-info v{}", env!("CARGO_PKG_VERSION"));
-    println!();
-    println!("Drive:    {} {} {}", inquiry.vendor_id, inquiry.model, inquiry.firmware);
-    println!("INQUIRY:  additional_length=0x{:02X} ({})",
-        inquiry.raw.get(4).unwrap_or(&0),
-        inquiry.raw.get(4).unwrap_or(&0));
-
-    if let Some(gc) = gc_010c {
-        let data_hex: String = gc.iter().map(|b| format!("{:02x}", b)).collect();
-        println!("Feature 0x010C: {}", data_hex);
-    } else {
-        println!("Feature 0x010C: not available");
-    }
-
-    // Try to match profile
-    if let Ok(profiles) = libfreemkv::profile::load_all(Path::new(profiles_dir)) {
-        let matched = profiles.iter().find(|p| {
-            p.drive_id.contains(&inquiry.vendor_id)
-                && p.drive_id.contains(&inquiry.model)
-        });
-
-        println!();
-        match matched {
-            Some(p) => {
-                println!("Profile:  FOUND ({})", p.chipset.name());
-                println!("Raw Read: Supported");
-            }
-            None => {
-                println!("Profile:  NOT FOUND");
-                println!("Raw Read: Unknown — run with --raw and submit a profile request");
-            }
-        }
-    } else {
-        println!();
-        println!("Profile:  No profiles directory found at '{}'", profiles_dir);
-    }
-}
-
-fn print_raw(
-    inquiry: &libfreemkv::scsi::InquiryResult,
-    gc_010c: &Option<Vec<u8>>,
-) {
-    println!("# freemkv-info raw output");
-    println!("# Submit this file to https://github.com/freemkv/libfreemkv/issues");
-    println!();
-    println!("vendor: {}", inquiry.vendor_id);
-    println!("model: {}", inquiry.model);
-    println!("firmware: {}", inquiry.firmware);
-    println!();
-
-    // Full INQUIRY hex
-    println!("inquiry_hex: {}", hex_encode(&inquiry.raw));
-    println!("inquiry_length: {}", inquiry.raw.len());
-
-    // GET CONFIG 0x010C
-    if let Some(gc) = gc_010c {
-        println!("get_config_010c_hex: {}", hex_encode(gc));
-        println!("get_config_010c_length: {}", gc.len());
-    } else {
-        println!("get_config_010c_hex: ERROR");
-    }
-}
-
-fn print_json(
-    inquiry: &libfreemkv::scsi::InquiryResult,
-    gc_010c: &Option<Vec<u8>>,
-) {
-    let json = serde_json::json!({
-        "vendor": inquiry.vendor_id,
-        "model": inquiry.model,
-        "firmware": inquiry.firmware,
-        "inquiry_hex": hex_encode(&inquiry.raw),
-        "inquiry_length": inquiry.raw.len(),
-        "get_config_010c_hex": gc_010c.as_ref().map(|g| hex_encode(g)),
-    });
-    println!("{}", serde_json::to_string_pretty(&json).unwrap());
-}
-
-fn hex_encode(data: &[u8]) -> String {
-    data.iter().map(|b| format!("{:02x}", b)).collect()
-}

src/bin/freemkv_test.rs

@@ -1,99 +0,0 @@
-//! freemkv-test — Quick verification that raw disc access works.
-//!
-//! Enables raw read mode, calibrates speed, reads a few test sectors.
-//! Use this to verify your drive and profile are working correctly.
-//!
-//! Usage:
-//!   freemkv-test /dev/sr0
-//!   freemkv-test /dev/sr0 --profiles ./profiles
-
-use std::env;
-use std::path::Path;
-use std::process;
-
-fn main() {
-    let args: Vec<String> = env::args().collect();
-
-    if args.len() < 2 {
-        eprintln!("freemkv-test — Verify raw disc access works");
-        eprintln!();
-        eprintln!("Usage: freemkv-test <device> [--profiles <dir>]");
-        process::exit(1);
-    }
-
-    let device = Path::new(&args[1]);
-
-    println!("freemkv-test v{}", env!("CARGO_PKG_VERSION"));
-    println!();
-
-    // Open drive session (uses bundled profiles)
-    print!("Opening {}... ", device.display());
-    let mut session = match libfreemkv::DriveSession::open(device) {
-        Ok(s) => { println!("OK"); s }
-        Err(e) => { println!("FAILED: {}", e); process::exit(1); }
-    };
-
-    println!("  Drive ID: {}", session.profile.drive_id);
-    println!("  Chipset:  {}", session.profile.chipset.name());
-    println!();
-
-    // Enable raw read mode
-    print!("Unlocking drive... ");
-    match session.unlock() {
-        Ok(()) => println!("OK"),
-        Err(e) => { println!("FAILED: {}", e); process::exit(1); }
-    }
-
-    // Check status
-    print!("Checking status... ");
-    match session.status() {
-        Ok(status) => {
-            if status.unlocked {
-                println!("OK (active)");
-            } else {
-                println!("WARNING: drive reported as locked");
-            }
-        }
-        Err(e) => println!("SKIP ({})", e),
-    }
-
-    // Calibrate speed
-    print!("Calibrating speed... ");
-    match session.calibrate() {
-        Ok(()) => println!("OK"),
-        Err(e) => println!("SKIP ({})", e),
-    }
-
-    // Read test sectors
-    let test_lbas: &[u32] = &[0, 100, 1000, 10000];
-    let mut buf = vec![0u8; 2048];
-    let mut pass = 0;
-    let mut fail = 0;
-
-    for &lba in test_lbas {
-        print!("Reading sector {}... ", lba);
-        match session.read_sectors(lba, 1, &mut buf) {
-            Ok(n) if n == 2048 => {
-                let nonzero = buf.iter().filter(|&&b| b != 0).count();
-                println!("OK ({} bytes, {} non-zero)", n, nonzero);
-                pass += 1;
-            }
-            Ok(n) => {
-                println!("PARTIAL ({} bytes)", n);
-                fail += 1;
-            }
-            Err(e) => {
-                println!("FAILED: {}", e);
-                fail += 1;
-            }
-        }
-    }
-
-    println!();
-    if fail == 0 {
-        println!("All {} checks passed. Drive is fully functional.", pass);
-    } else {
-        println!("{} passed, {} failed.", pass, fail);
-        process::exit(1);
-    }
-}

src/clpi.rs

@@ -0,0 +1,249 @@
+//! CLPI clip info parser — maps clips to sector ranges on disc.
+//!
+//! Each .clpi file in BDMV/CLIPINF/ describes one M2TS clip.
+//! The EP (Entry Point) map provides timestamp → SPN mapping.
+//! SPN × 192 = byte offset in the m2ts file.
+//!
+//! Reference: https://github.com/lw/BluRay/wiki/CLPI
+
+use crate::error::{Error, Result};
+use crate::disc::Extent;
+
+/// Parsed CLPI clip info.
+#[derive(Debug)]
+pub struct ClipInfo {
+    pub version: String,
+    /// Total source packets in the m2ts (each 192 bytes)
+    pub source_packet_count: u32,
+    /// Coarse EP entries for the primary video stream
+    pub ep_coarse: Vec<EpCoarse>,
+    /// Fine EP entries for the primary video stream
+    pub ep_fine: Vec<EpFine>,
+}
+
+#[derive(Debug, Clone)]
+pub struct EpCoarse {
+    pub ref_to_fine_id: u32,
+    pub pts_coarse: u32,
+    pub spn_coarse: u32,
+}
+
+#[derive(Debug, Clone)]
+pub struct EpFine {
+    pub pts_fine: u32,
+    pub spn_fine: u32,
+}
+
+impl ClipInfo {
+    /// Reconstruct full PTS from coarse + fine entry.
+    pub fn full_pts(coarse: &EpCoarse, fine: &EpFine) -> u32 {
+        (coarse.pts_coarse << 19) + (fine.pts_fine << 8)
+    }
+
+    /// Reconstruct full SPN from coarse + fine entry.
+    pub fn full_spn(coarse: &EpCoarse, fine: &EpFine) -> u32 {
+        (coarse.spn_coarse & 0xFFFE0000) + fine.spn_fine
+    }
+
+    /// Get all EP entries as (PTS, SPN) pairs, fully resolved.
+    pub fn resolved_ep_map(&self) -> Vec<(u32, u32)> {
+        let mut entries = Vec::new();
+
+        for (ci, coarse) in self.ep_coarse.iter().enumerate() {
+            let fine_start = coarse.ref_to_fine_id as usize;
+            let fine_end = if ci + 1 < self.ep_coarse.len() {
+                self.ep_coarse[ci + 1].ref_to_fine_id as usize
+            } else {
+                self.ep_fine.len()
+            };
+
+            for fi in fine_start..fine_end.min(self.ep_fine.len()) {
+                let fine = &self.ep_fine[fi];
+                let pts = Self::full_pts(coarse, fine);
+                let spn = Self::full_spn(coarse, fine);
+                entries.push((pts, spn));
+            }
+        }
+
+        entries
+    }
+
+    /// Get sector extents for a given in/out time range.
+    ///
+    /// Converts PTS timestamps to SPN ranges, then SPN to LBA
+    /// using the file's starting LBA on disc.
+    pub fn get_extents(&self, in_time: u32, out_time: u32) -> Vec<Extent> {
+        let ep_map = self.resolved_ep_map();
+        if ep_map.is_empty() {
+            return Vec::new();
+        }
+
+        // Find SPN at or before in_time
+        let start_spn = match ep_map.binary_search_by_key(&in_time, |(pts, _)| *pts) {
+            Ok(i) => ep_map[i].1,
+            Err(0) => ep_map[0].1,
+            Err(i) => ep_map[i - 1].1,
+        };
+
+        // Find SPN at or after out_time
+        let end_spn = match ep_map.binary_search_by_key(&out_time, |(pts, _)| *pts) {
+            Ok(i) => ep_map[i].1,
+            Err(i) if i < ep_map.len() => ep_map[i].1,
+            _ => ep_map.last().unwrap().1 + 1,
+        };
+
+        if end_spn <= start_spn {
+            return Vec::new();
+        }
+
+        // SPN → byte offset: spn × 192
+        // Byte offset → sectors: offset / 2048
+        // Note: the caller needs to add the file's starting LBA from UDF
+        let start_byte = start_spn as u64 * 192;
+        let end_byte = end_spn as u64 * 192;
+        let start_sector = (start_byte / 2048) as u32;
+        let end_sector = ((end_byte + 2047) / 2048) as u32;
+
+        vec![Extent {
+            start_lba: start_sector, // relative to m2ts file start
+            sector_count: end_sector - start_sector,
+        }]
+    }
+}
+
+/// Parse a CLPI file from raw bytes.
+pub fn parse(data: &[u8]) -> Result<ClipInfo> {
+    if data.len() < 40 {
+        return Err(Error::DiscError { detail: "CLPI too short".into() });
+    }
+
+    if &data[0..4] != b"HDMV" {
+        return Err(Error::DiscError { detail: "not a CLPI file".into() });
+    }
+    let version = String::from_utf8_lossy(&data[4..8]).to_string();
+
+    // Header offsets
+    let _seq_info_start = u32::from_be_bytes([data[8], data[9], data[10], data[11]]) as usize;
+    let _prog_info_start = u32::from_be_bytes([data[12], data[13], data[14], data[15]]) as usize;
+    let cpi_start = u32::from_be_bytes([data[16], data[17], data[18], data[19]]) as usize;
+
+    // ClipInfo section at offset 40
+    // source_packet_count at offset 40 + 4(len) + 2(reserved) + 1(stream_type) + 1(app_type) + 4(reserved) + 4(ts_rate)
+    let source_packet_count = if data.len() > 56 {
+        u32::from_be_bytes([data[56], data[57], data[58], data[59]])
+    } else {
+        0
+    };
+
+    // Parse CPI / EP Map
+    let (ep_coarse, ep_fine) = if cpi_start > 0 && cpi_start + 8 < data.len() {
+        parse_cpi(&data[cpi_start..])?
+    } else {
+        (Vec::new(), Vec::new())
+    };
+
+    Ok(ClipInfo {
+        version,
+        source_packet_count,
+        ep_coarse,
+        ep_fine,
+    })
+}
+
+/// Parse the CPI section containing the EP map.
+fn parse_cpi(data: &[u8]) -> Result<(Vec<EpCoarse>, Vec<EpFine>)> {
+    if data.len() < 8 {
+        return Ok((Vec::new(), Vec::new()));
+    }
+
+    let cpi_length = u32::from_be_bytes([data[0], data[1], data[2], data[3]]) as usize;
+    if cpi_length < 4 {
+        return Ok((Vec::new(), Vec::new()));
+    }
+
+    // CPI type at bits 44-47 (byte 5, lower 4 bits)
+    // Skip to EP map: offset 4 (after length) + 2 (reserved/type)
+    let ep_map = &data[6..];
+    if ep_map.len() < 4 {
+        return Ok((Vec::new(), Vec::new()));
+    }
+
+    // EP map header
+    // [0] reserved
+    // [1] number of stream PID entries
+    let num_streams = ep_map[1] as usize;
+    if num_streams == 0 {
+        return Ok((Vec::new(), Vec::new()));
+    }
+
+    // Stream PID entry headers start at offset 2
+    // Each: 2(PID) + 2(reserved+type) + 2(num_coarse) + 4(num_fine) + 4(ep_map_start) = 14 bytes
+    // We only care about the first stream (primary video)
+    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;
+
+    // EP map for this stream starts at ep_map_offset relative to ep_map start
+    if ep_map_offset + 4 > ep_map.len() {
+        return Ok((Vec::new(), Vec::new()));
+    }
+
+    let stream_ep = &ep_map[ep_map_offset..];
+    if stream_ep.len() < 4 {
+        return Ok((Vec::new(), Vec::new()));
+    }
+
+    // Fine table start address (relative to this stream EP map)
+    let fine_start = u32::from_be_bytes([stream_ep[0], stream_ep[1], stream_ep[2], stream_ep[3]]) as usize;
+
+    // Coarse entries start at offset 4, 8 bytes each
+    let coarse_data = &stream_ep[4..];
+    let mut ep_coarse = Vec::with_capacity(num_coarse);
+    for i in 0..num_coarse {
+        let off = i * 8;
+        if off + 8 > coarse_data.len() {
+            break;
+        }
+
+        let dword0 = u32::from_be_bytes([coarse_data[off], coarse_data[off + 1],
+                                          coarse_data[off + 2], coarse_data[off + 3]]);
+        let ref_to_fine_id = dword0 >> 14;
+        let pts_coarse = dword0 & 0x3FFF;
+        let spn_coarse = u32::from_be_bytes([coarse_data[off + 4], coarse_data[off + 5],
+                                              coarse_data[off + 6], coarse_data[off + 7]]);
+
+        ep_coarse.push(EpCoarse {
+            ref_to_fine_id,
+            pts_coarse,
+            spn_coarse,
+        });
+    }
+
+    // Fine entries at fine_start, 4 bytes each
+    let mut ep_fine = Vec::with_capacity(num_fine);
+    if fine_start < stream_ep.len() {
+        let fine_data = &stream_ep[fine_start..];
+        for i in 0..num_fine {
+            let off = i * 4;
+            if off + 4 > fine_data.len() {
+                break;
+            }
+
+            let dword = u32::from_be_bytes([fine_data[off], fine_data[off + 1],
+                                            fine_data[off + 2], fine_data[off + 3]]);
+            // Bits: is_angle(1) + i_end_offset(3) + pts_fine(11) + spn_fine(17)
+            let pts_fine = (dword >> 17) & 0x7FF;
+            let spn_fine = dword & 0x1FFFF;
+
+            ep_fine.push(EpFine { pts_fine, spn_fine });
+        }
+    }
+
+    Ok((ep_coarse, ep_fine))
+}

src/disc.rs

@@ -0,0 +1,750 @@
+//! Disc structure — scan titles, streams, and sector ranges from a Blu-ray disc.
+//!
+//! This is the high-level API for disc content. The CLI calls this,
+//! never parses MPLS/CLPI/UDF directly.
+//!
+//! Usage:
+//!   let disc = Disc::scan(&mut session)?;
+//!   for title in disc.titles() { ... }
+//!   for stream in title.streams() { ... }
+
+use crate::error::{Error, Result};
+use crate::drive::DriveSession;
+use crate::udf;
+use crate::mpls;
+use crate::clpi;
+
+// ─── Public types ───────────────────────────────────────────────────────────
+
+/// A scanned Blu-ray disc.
+#[derive(Debug)]
+pub struct Disc {
+    /// Disc capacity in sectors
+    pub capacity_sectors: u32,
+    /// Titles sorted by duration (longest first), then playlist name
+    pub titles: Vec<Title>,
+    /// AACS state — None if disc is unencrypted or keys unavailable
+    pub aacs: Option<AacsState>,
+    /// Whether this disc requires AACS decryption
+    pub encrypted: bool,
+}
+
+/// A title (one MPLS playlist).
+#[derive(Debug, Clone)]
+pub struct Title {
+    /// Playlist filename (e.g. "00800.mpls")
+    pub playlist: String,
+    /// Playlist number (e.g. 800)
+    pub playlist_id: u16,
+    /// Duration in seconds
+    pub duration_secs: f64,
+    /// Total size in bytes
+    pub size_bytes: u64,
+    /// Number of clips
+    pub clip_count: usize,
+    /// All streams (video, audio, subtitle, etc.)
+    pub streams: Vec<Stream>,
+    /// Sector extents for ripping (clip LBA ranges)
+    pub extents: Vec<Extent>,
+}
+
+/// A stream within a title.
+#[derive(Debug, Clone)]
+pub struct Stream {
+    /// Stream type
+    pub kind: StreamKind,
+    /// MPEG-TS packet ID
+    pub pid: u16,
+    /// Codec
+    pub codec: Codec,
+    /// ISO 639-2 language code (e.g. "eng", "fra")
+    pub language: String,
+    /// Video resolution (e.g. "2160p", "1080p")
+    pub resolution: String,
+    /// Frame rate (e.g. "23.976")
+    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
+    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,
+}
+
+/// Video/audio codec.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Codec {
+    // Video
+    Hevc,
+    H264,
+    Vc1,
+    Mpeg2,
+    // Audio
+    TrueHd,
+    DtsHdMa,
+    DtsHdHr,
+    Dts,
+    Ac3,
+    Ac3Plus,
+    Lpcm,
+    // Subtitle
+    Pgs,
+    // Unknown
+    Unknown(u8),
+}
+
+/// HDR format.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum HdrFormat {
+    Sdr,
+    Hdr10,
+    DolbyVision,
+}
+
+/// Color space.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum ColorSpace {
+    Bt709,
+    Bt2020,
+    Unknown,
+}
+
+/// A contiguous range of sectors on disc.
+#[derive(Debug, Clone, Copy)]
+pub struct Extent {
+    pub start_lba: u32,
+    pub sector_count: u32,
+}
+
+// ─── Display helpers ────────────────────────────────────────────────────────
+
+impl Codec {
+    pub fn name(&self) -> &'static str {
+        match self {
+            Codec::Hevc => "HEVC",
+            Codec::H264 => "H.264",
+            Codec::Vc1 => "VC-1",
+            Codec::Mpeg2 => "MPEG-2",
+            Codec::TrueHd => "TrueHD",
+            Codec::DtsHdMa => "DTS-HD MA",
+            Codec::DtsHdHr => "DTS-HD HR",
+            Codec::Dts => "DTS",
+            Codec::Ac3 => "AC-3",
+            Codec::Ac3Plus => "AC-3+",
+            Codec::Lpcm => "LPCM",
+            Codec::Pgs => "PGS",
+            Codec::Unknown(_) => "Unknown",
+        }
+    }
+
+    fn from_coding_type(ct: u8) -> Self {
+        match ct {
+            0x24 => Codec::Hevc,
+            0x1B => Codec::H264,
+            0xEA => Codec::Vc1,
+            0x02 => Codec::Mpeg2,
+            0x83 => Codec::TrueHd,
+            0x86 => Codec::DtsHdMa,
+            0x85 => Codec::DtsHdHr,
+            0x82 => Codec::Dts,
+            0x81 => Codec::Ac3,
+            0x84 | 0xA1 => Codec::Ac3Plus,
+            0x80 => Codec::Lpcm,
+            0xA2 => Codec::DtsHdHr,
+            0x90 | 0x91 => Codec::Pgs,
+            ct => Codec::Unknown(ct),
+        }
+    }
+}
+
+impl HdrFormat {
+    pub fn name(&self) -> &'static str {
+        match self {
+            HdrFormat::Sdr => "SDR",
+            HdrFormat::Hdr10 => "HDR10",
+            HdrFormat::DolbyVision => "Dolby Vision",
+        }
+    }
+}
+
+impl ColorSpace {
+    pub fn name(&self) -> &'static str {
+        match self {
+            ColorSpace::Bt709 => "BT.709",
+            ColorSpace::Bt2020 => "BT.2020",
+            ColorSpace::Unknown => "",
+        }
+    }
+}
+
+impl Title {
+    /// Duration formatted as "Xh Ym"
+    pub fn duration_display(&self) -> String {
+        let hrs = (self.duration_secs / 3600.0) as u32;
+        let mins = ((self.duration_secs % 3600.0) / 60.0) as u32;
+        format!("{}h {:02}m", hrs, mins)
+    }
+
+    /// Size in GB
+    pub fn size_gb(&self) -> f64 {
+        self.size_bytes as f64 / (1024.0 * 1024.0 * 1024.0)
+    }
+
+    /// Total sectors across all extents
+    pub fn total_sectors(&self) -> u64 {
+        self.extents.iter().map(|e| e.sector_count as u64).sum()
+    }
+}
+
+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 ─────────────────────────────────────────────────────────────
+
+/// AACS decryption state for a disc.
+#[derive(Debug)]
+pub struct AacsState {
+    /// AACS version (1 or 2)
+    pub version: u8,
+    /// Whether bus encryption is enabled (always true for AACS 2.0 / UHD)
+    pub bus_encryption: bool,
+    /// MKB version from disc (e.g. 68, 77)
+    pub mkb_version: Option<u32>,
+    /// Disc hash (SHA1 of Unit_Key_RO.inf) — hex string with 0x prefix
+    pub disc_hash: String,
+    /// How keys were resolved
+    pub key_source: KeySource,
+    /// Volume Unique Key (16 bytes)
+    pub vuk: [u8; 16],
+    /// Decrypted unit keys (CPS unit number, key)
+    pub unit_keys: Vec<(u32, [u8; 16])>,
+    /// Read data key for AACS 2.0 bus decryption — None for AACS 1.0
+    pub read_data_key: Option<[u8; 16]>,
+    /// Volume ID (16 bytes) — from SCSI handshake
+    pub volume_id: [u8; 16],
+}
+
+/// How AACS keys were resolved.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum KeySource {
+    /// VUK found directly in KEYDB by disc hash
+    KeyDb,
+    /// Media key + Volume ID from KEYDB → derived VUK
+    KeyDbDerived,
+    /// MKB + processing keys → media key → VUK
+    ProcessingKey,
+    /// MKB + device keys → subset-difference tree → VUK
+    DeviceKey,
+}
+
+impl KeySource {
+    pub fn name(&self) -> &'static str {
+        match self {
+            KeySource::KeyDb => "KEYDB",
+            KeySource::KeyDbDerived => "KEYDB (derived)",
+            KeySource::ProcessingKey => "MKB + processing key",
+            KeySource::DeviceKey => "MKB + device key",
+        }
+    }
+}
+
+// ─── Disc scanning ──────────────────────────────────────────────────────────
+
+/// Standard KEYDB.cfg search locations (compatible with libaacs).
+const KEYDB_SEARCH_PATHS: &[&str] = &[
+    ".config/aacs/KEYDB.cfg",  // relative to $HOME
+];
+const KEYDB_SYSTEM_PATH: &str = "/etc/aacs/KEYDB.cfg";
+
+/// Options for disc scanning.
+pub struct ScanOptions {
+    /// Path to KEYDB.cfg for AACS key lookup.
+    /// If None, searches standard locations ($HOME/.config/aacs/ and /etc/aacs/).
+    pub keydb_path: Option<std::path::PathBuf>,
+}
+
+impl Default for ScanOptions {
+    fn default() -> Self {
+        ScanOptions { keydb_path: None }
+    }
+}
+
+impl ScanOptions {
+    /// Create options with a specific KEYDB path.
+    pub fn with_keydb(path: impl Into<std::path::PathBuf>) -> Self {
+        ScanOptions { keydb_path: Some(path.into()) }
+    }
+
+    /// Resolve KEYDB path: explicit path first, then standard locations.
+    fn resolve_keydb(&self) -> Option<std::path::PathBuf> {
+        if let Some(p) = &self.keydb_path {
+            if p.exists() { return Some(p.clone()); }
+        }
+        if let Some(home) = std::env::var_os("HOME") {
+            for relative in KEYDB_SEARCH_PATHS {
+                let p = std::path::PathBuf::from(&home).join(relative);
+                if p.exists() { return Some(p); }
+            }
+        }
+        let p = std::path::PathBuf::from(KEYDB_SYSTEM_PATH);
+        if p.exists() { return Some(p); }
+        None
+    }
+}
+
+impl Disc {
+    /// Disc capacity in GB
+    pub fn capacity_gb(&self) -> f64 {
+        self.capacity_sectors as f64 * 2048.0 / (1024.0 * 1024.0 * 1024.0)
+    }
+
+    /// Scan a disc — parse filesystem, playlists, streams, and set up AACS decryption.
+    ///
+    /// This is the main entry point. After scan(), the Disc is ready:
+    ///   - titles are populated with streams
+    ///   - AACS keys are derived (if KEYDB available)
+    ///   - content can be read and decrypted transparently
+    ///
+    /// ```no_run
+    /// use libfreemkv::{DriveSession, Disc};
+    /// use libfreemkv::disc::ScanOptions;
+    /// use std::path::Path;
+    ///
+    /// let mut session = DriveSession::open(Path::new("/dev/sr0")).unwrap();
+    /// let disc = Disc::scan(&mut session, &ScanOptions::default()).unwrap();
+    /// for title in &disc.titles {
+    ///     println!("{} — {} streams", title.duration_display(), title.streams.len());
+    /// }
+    /// ```
+    pub fn scan(session: &mut DriveSession, opts: &ScanOptions) -> Result<Self> {
+        // Step 1: Read capacity
+        let capacity = Self::read_capacity(session)?;
+
+        // Step 2: Parse UDF filesystem
+        let udf_fs = udf::read_filesystem(session)?;
+
+        // Step 3: Find and parse MPLS playlists
+        let mut titles = Vec::new();
+        if let Some(playlist_dir) = udf_fs.find_dir("/BDMV/PLAYLIST") {
+            for entry in &playlist_dir.entries {
+                if !entry.is_dir && entry.name.to_lowercase().ends_with(".mpls") {
+                    let path = format!("/BDMV/PLAYLIST/{}", entry.name);
+                    if let Ok(mpls_data) = udf_fs.read_file(session, &path) {
+                        if let Some(title) = Self::parse_playlist(session, &udf_fs, &entry.name, &mpls_data) {
+                            titles.push(title);
+                        }
+                    }
+                }
+            }
+        }
+
+        // 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
+        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
+        let aacs = if encrypted {
+            if let Some(keydb_path) = opts.resolve_keydb() {
+                match Self::setup_aacs(session, &keydb_path) {
+                    Ok(state) => Some(state),
+                    Err(_) => None, // keys not found, continue without decryption
+                }
+            } else {
+                None
+            }
+        } else {
+            None
+        };
+
+        Ok(Disc {
+            capacity_sectors: capacity,
+            titles,
+            aacs,
+            encrypted,
+        })
+    }
+
+    /// Set up AACS decryption for this disc.
+    /// Call after scan() to enable transparent content decryption.
+    pub fn setup_aacs(
+        session: &mut DriveSession,
+        keydb_path: &std::path::Path,
+    ) -> Result<AacsState> {
+        use crate::aacs::{self, KeyDb};
+        use crate::aacs::handshake;
+
+        // Load KEYDB
+        let keydb = KeyDb::load(keydb_path).map_err(|e| Error::AacsError {
+            detail: format!("failed to load KEYDB: {}", e),
+        })?;
+
+        // Step 1: Try SCSI handshake for Volume ID + read_data_key
+        // Open a separate transport (AACS auth must happen before raw mode).
+        // If handshake fails (drive doesn't support AACS layer, e.g. raw-mode drives),
+        // fall back to disc-hash-only KEYDB lookup.
+        let device_path = session.device_path().to_string();
+        let mut vid: Option<[u8; 16]> = None;
+        let mut read_data_key: Option<[u8; 16]> = None;
+
+        if !device_path.is_empty() {
+            if let Ok(mut aacs_session) = DriveSession::open_no_unlock(std::path::Path::new(&device_path)) {
+                if let Ok(hc) = keydb.host_cert.as_ref().ok_or(()) {
+                    if let Ok(mut auth) = handshake::aacs_authenticate(
+                        &mut aacs_session, &hc.private_key, &hc.certificate,
+                    ) {
+                        vid = handshake::read_volume_id(&mut aacs_session, &mut auth).ok();
+                        read_data_key = handshake::read_data_keys(&mut aacs_session, &mut auth)
+                            .ok().map(|(rdk, _)| rdk);
+                    }
+                }
+            }
+            // Handshake failure is not fatal — we can still resolve via disc hash
+        }
+
+        // Step 2: Read Unit_Key_RO.inf from disc via UDF (uses the unlocked main session)
+        let udf_fs = udf::read_filesystem(session)?;
+        let uk_ro_data = udf_fs.read_file(session, "/AACS/Unit_Key_RO.inf")
+            .or_else(|_| udf_fs.read_file(session, "/AACS/DUPLICATE/Unit_Key_RO.inf"))
+            .map_err(|_| Error::AacsError {
+                detail: "failed to read Unit_Key_RO.inf from disc".into(),
+            })?;
+
+        // Step 3: Read Content Certificate (optional — for AACS version detection)
+        let cc_data = udf_fs.read_file(session, "/AACS/Content000.cer")
+            .or_else(|_| udf_fs.read_file(session, "/AACS/Content001.cer"))
+            .ok();
+
+        // Step 4: Resolve keys
+        // If we have VID from handshake, use full 4-path chain.
+        // If no VID (handshake failed), use disc-hash-only KEYDB lookup.
+        let mkb_data = aacs::read_mkb_from_drive(session).ok();
+        let mkb_ver = mkb_data.as_deref().and_then(aacs::mkb_version);
+
+        // Use a zero VID placeholder if handshake failed — resolve_keys
+        // will still work via disc hash (path 1)
+        let vid_for_resolve = vid.unwrap_or([0u8; 16]);
+
+        let resolved = aacs::resolve_keys(
+            &uk_ro_data,
+            cc_data.as_deref(),
+            &vid_for_resolve,
+            &keydb,
+            mkb_data.as_deref(),
+        ).ok_or_else(|| Error::AacsError {
+            detail: "failed to resolve AACS keys — disc not in KEYDB".into(),
+        })?;
+
+        let key_source = match resolved.key_source {
+            1 => KeySource::KeyDb,
+            2 => KeySource::KeyDbDerived,
+            3 => KeySource::ProcessingKey,
+            4 => KeySource::DeviceKey,
+            _ => KeySource::KeyDb,
+        };
+
+        Ok(AacsState {
+            version: if resolved.aacs2 { 2 } else { 1 },
+            bus_encryption: resolved.bus_encryption,
+            mkb_version: mkb_ver,
+            disc_hash: aacs::disc_hash_hex(&resolved.disc_hash),
+            key_source,
+            vuk: resolved.vuk,
+            unit_keys: resolved.unit_keys,
+            read_data_key,
+            volume_id: vid.unwrap_or([0u8; 16]),
+        })
+    }
+
+    // ── Internal helpers ────────────────────────────────────────────────────
+
+    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];
+        session.scsi_execute(&cdb, crate::scsi::DataDirection::FromDevice, &mut buf, 5_000)?;
+        let lba = u32::from_be_bytes([buf[0], buf[1], buf[2], buf[3]]);
+        Ok(lba + 1)
+    }
+
+    fn parse_playlist(
+        session: &mut DriveSession,
+        udf_fs: &udf::UdfFs,
+        filename: &str,
+        data: &[u8],
+    ) -> Option<Title> {
+        let parsed = mpls::parse(data).ok()?;
+
+        // Calculate duration from play items
+        let duration_ticks: u64 = parsed.play_items.iter()
+            .map(|pi| (pi.out_time.saturating_sub(pi.in_time)) as u64)
+            .sum();
+        let duration_secs = duration_ticks as f64 / 45000.0;
+
+        // Skip very short playlists (< 30 seconds)
+        if duration_secs < 30.0 {
+            return None;
+        }
+
+        // Parse each clip for EP map → sector extents
+        let mut extents = Vec::new();
+        let mut total_size: u64 = 0;
+        let clip_count = parsed.play_items.len();
+
+        for play_item in &parsed.play_items {
+            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
+                    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);
+                }
+            }
+        }
+
+        // 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(),
+            }
+        }).collect();
+
+        let playlist_num = filename.trim_end_matches(".mpls").trim_end_matches(".MPLS");
+        let playlist_id = playlist_num.parse::<u16>().unwrap_or(0);
+
+        Some(Title {
+            playlist: filename.to_string(),
+            playlist_id,
+            duration_secs,
+            size_bytes: total_size,
+            clip_count,
+            streams,
+            extents,
+        })
+    }
+}
+
+// ─── Decrypted reader ──────────────────────────────────────────────────────
+
+/// A reader that reads m2ts content, decrypting transparently if needed.
+pub struct ContentReader<'a> {
+    session: &'a mut DriveSession,
+    aacs: Option<&'a AacsState>,
+    extents: Vec<Extent>,
+    current_extent: usize,
+    current_offset: u32, // sectors into current extent
+    unit_key_idx: usize,
+}
+
+impl Disc {
+    /// Open a title for reading. Decryption is automatic — if the disc
+    /// is encrypted and keys were found during scan(), content is decrypted
+    /// on the fly. Unencrypted discs pass through unchanged.
+    ///
+    /// ```no_run
+    /// # use libfreemkv::{DriveSession, Disc};
+    /// # use libfreemkv::disc::ScanOptions;
+    /// # use std::path::Path;
+    /// # let mut session = DriveSession::open(Path::new("/dev/sr0")).unwrap();
+    /// let disc = Disc::scan(&mut session, &ScanOptions::default()).unwrap();
+    /// let mut reader = disc.open_title(&mut session, 0).unwrap();
+    /// while let Some(unit) = reader.read_unit().unwrap() {
+    ///     // unit is 6144 bytes of decrypted content
+    /// }
+    /// ```
+    pub fn open_title<'a>(&'a self, session: &'a mut DriveSession, title_idx: usize) -> Result<ContentReader<'a>> {
+        let title = self.titles.get(title_idx).ok_or_else(|| Error::DiscError {
+            detail: format!("title index {} out of range (have {})", title_idx, self.titles.len()),
+        })?;
+
+        Ok(ContentReader {
+            session,
+            aacs: self.aacs.as_ref(),
+            extents: title.extents.clone(),
+            current_extent: 0,
+            current_offset: 0,
+            unit_key_idx: 0,
+        })
+    }
+}
+
+impl<'a> ContentReader<'a> {
+    /// Read the next aligned unit (6144 bytes).
+    /// Automatically decrypted if AACS keys are available.
+    /// Returns None when all extents are exhausted.
+    pub fn read_unit(&mut self) -> Result<Option<Vec<u8>>> {
+        if self.current_extent >= self.extents.len() {
+            return Ok(None);
+        }
+
+        let extent = &self.extents[self.current_extent];
+        let lba = extent.start_lba + self.current_offset;
+
+        // Read 3 sectors (one aligned unit)
+        let mut unit = vec![0u8; crate::aacs::ALIGNED_UNIT_LEN];
+        for i in 0..3u32 {
+            let offset = (i as usize) * 2048;
+            let mut sector = [0u8; 2048];
+            session_read_sector(self.session, lba + i, &mut sector)?;
+            unit[offset..offset + 2048].copy_from_slice(&sector);
+        }
+
+        // Decrypt if needed
+        if let Some(aacs) = &self.aacs {
+            if crate::aacs::is_unit_encrypted(&unit) {
+                let uk = aacs.unit_keys.get(self.unit_key_idx)
+                    .map(|(_, k)| *k)
+                    .unwrap_or([0u8; 16]);
+
+                crate::aacs::decrypt_unit_full(
+                    &mut unit,
+                    &uk,
+                    aacs.read_data_key.as_ref(),
+                );
+            }
+        }
+
+        // Advance position
+        self.current_offset += 3;
+        if self.current_offset >= extent.sector_count {
+            self.current_extent += 1;
+            self.current_offset = 0;
+        }
+
+        Ok(Some(unit))
+    }
+}
+
+fn session_read_sector(session: &mut DriveSession, lba: u32, buf: &mut [u8; 2048]) -> Result<()> {
+    let cdb = [
+        crate::scsi::SCSI_READ_10, 0x00,
+        (lba >> 24) as u8, (lba >> 16) as u8, (lba >> 8) as u8, lba as u8,
+        0x00, 0x00, 0x01, 0x00,
+    ];
+    session.scsi_execute(&cdb, crate::scsi::DataDirection::FromDevice, buf, 10_000)?;
+    Ok(())
+}
+
+// ─── Format helpers ────────────────────────────────────────────────────────
+
+fn format_resolution(video_format: u8, _video_rate: u8) -> String {
+    match video_format {
+        1 => "480i".into(),
+        2 => "576i".into(),
+        3 => "480p".into(),
+        4 => "1080i".into(),
+        5 => "720p".into(),
+        6 => "1080p".into(),
+        7 => "576p".into(),
+        8 => "2160p".into(),
+        _ => String::new(),
+    }
+}
+
+fn format_framerate(video_rate: u8) -> String {
+    match video_rate {
+        1 => "23.976".into(),
+        2 => "24".into(),
+        3 => "25".into(),
+        4 => "29.97".into(),
+        6 => "50".into(),
+        7 => "59.94".into(),
+        _ => String::new(),
+    }
+}
+
+fn format_channels(audio_format: u8) -> String {
+    match audio_format {
+        1 => "mono".into(),
+        3 => "stereo".into(),
+        6 => "5.1".into(),
+        12 => "7.1".into(),
+        _ if audio_format > 0 => format!("{}ch", audio_format),
+        _ => String::new(),
+    }
+}
+
+fn format_samplerate(audio_rate: u8) -> String {
+    match audio_rate {
+        1 => "48kHz".into(),
+        4 => "96kHz".into(),
+        5 => "192kHz".into(),
+        12 => "48/192kHz".into(),
+        14 => "48/96kHz".into(),
+        _ => String::new(),
+    }
+}

src/drive.rs

@@ -1,8 +1,13 @@
-//! High-level drive session — the main API for consumers.
+//! Drive session — open, identify, unlock, and read from optical drives.
 //!
-//! Opens a drive, identifies it via standard SCSI commands,
-//! matches it against the profile database, and provides
-//! raw disc access methods.
+//! `DriveSession` is the entry point for all drive interaction. It handles
+//! device identification, profile matching, platform-specific unlock, and
+//! provides both raw sector reads and standard SCSI command execution.
+//!
+//! Two open modes:
+//!   - `open()` — identify + unlock. Ready for reading immediately.
+//!   - `open_no_unlock()` — identify only. Used for AACS authentication
+//!     which must happen before the drive enters raw mode.
 
 use std::path::Path;
 use crate::error::{Error, Result};
@@ -12,28 +17,40 @@ use crate::profile::{self, DriveProfile, Chipset};
 use crate::platform::{Platform, DriveStatus};
 use crate::platform::mt1959::Mt1959;
 
-/// A complete drive session.
+/// A drive session with identification, platform, and SCSI transport.
 ///
-/// Handles: identify → match profile → create platform → execute commands.
+/// Created via `DriveSession::open()` or `DriveSession::open_no_unlock()`.
+/// All disc reading goes through this struct.
 pub struct DriveSession {
     scsi: Box<dyn ScsiTransport>,
     platform: Box<dyn Platform>,
     pub profile: DriveProfile,
     pub drive_id: DriveId,
+    device_path: String,
 }
 
 impl DriveSession {
-    /// Open a drive, identify it, and find the matching profile.
-    /// Uses the bundled profile database — no external files needed.
+    /// Open a drive, identify it, match a profile, and unlock for raw reads.
+    ///
+    /// This is the standard entry point. After `open()`, the drive is ready
+    /// for sector reads, disc scanning, and content extraction.
     pub fn open(device: &Path) -> Result<Self> {
+        let mut session = Self::open_no_unlock(device)?;
+        let _ = session.unlock(); // silently ignore — unencrypted discs don't need it
+        Ok(session)
+    }
+
+    /// Open a drive WITHOUT unlocking.
+    ///
+    /// Used when AACS authentication must happen before raw mode.
+    /// The AACS SCSI handshake requires the drive's standard firmware
+    /// state — unlocking puts the drive in vendor-specific raw mode
+    /// which disables the AACS layer.
+    pub fn open_no_unlock(device: &Path) -> Result<Self> {
         let mut transport = crate::scsi::open(device)?;
         let profiles = profile::load_bundled()?;
-
-        // Identify drive via standard SCSI commands
-        // SPC-4 §6.4 (INQUIRY) + MMC-6 §5.3.10 (Feature 010Ch)
         let drive_id = DriveId::from_drive(transport.as_mut())?;
 
-        // Match drive to a profile by INQUIRY fields
         let profile = profile::find_by_drive_id(&profiles, &drive_id)
             .cloned()
             .ok_or_else(|| Error::UnsupportedDrive {
@@ -42,59 +59,43 @@ impl DriveSession {
                 product_revision: drive_id.product_revision.trim().to_string(),
             })?;
 
-        let platform: Box<dyn Platform> = match profile.chipset {
-            Chipset::MediaTek => {
-                Box::new(Mt1959::new(profile.clone()))
-            }
-            Chipset::Renesas => {
-                return Err(Error::UnsupportedDrive {
-                    vendor_id: drive_id.vendor_id.trim().to_string(),
-                    product_id: drive_id.product_id.trim().to_string(),
-                    product_revision: "Renesas not yet implemented".to_string(),
-                });
-            }
-        };
+        let platform = create_platform(&profile, &drive_id)?;
 
         Ok(DriveSession {
             scsi: transport,
             platform,
             profile,
             drive_id,
+            device_path: device.to_string_lossy().to_string(),
         })
     }
 
-    /// Open with an explicit profile (skip auto-detection).
+    /// Open with an explicit profile, skipping auto-detection.
     pub fn open_with_profile(device: &Path, profile: DriveProfile) -> Result<Self> {
         let mut transport = crate::scsi::open(device)?;
         let drive_id = DriveId::from_drive(transport.as_mut())?;
-
-        let platform: Box<dyn Platform> = match profile.chipset {
-            Chipset::MediaTek => {
-                Box::new(Mt1959::new(profile.clone()))
-            }
-            Chipset::Renesas => {
-                return Err(Error::UnsupportedDrive {
-                    vendor_id: drive_id.vendor_id.trim().to_string(),
-                    product_id: drive_id.product_id.trim().to_string(),
-                    product_revision: "Renesas not yet implemented".to_string(),
-                });
-            }
-        };
+        let platform = create_platform(&profile, &drive_id)?;
 
         Ok(DriveSession {
             scsi: transport,
             platform,
             profile,
             drive_id,
+            device_path: device.to_string_lossy().to_string(),
         })
     }
 
-    /// Activate raw disc access mode.
+    /// Device path this session was opened on.
+    pub fn device_path(&self) -> &str {
+        &self.device_path
+    }
+
+    /// Activate raw disc access mode (vendor-specific unlock).
     pub fn unlock(&mut self) -> Result<()> {
         self.platform.unlock(self.scsi.as_mut())
     }
 
-    /// Check if raw disc access mode is enabled.
+    /// Check if raw disc access mode is active.
     pub fn is_unlocked(&self) -> bool {
         self.platform.is_unlocked()
     }
@@ -119,13 +120,50 @@ impl DriveSession {
         self.platform.calibrate(self.scsi.as_mut())
     }
 
-    /// Read raw disc sectors.
+    /// Read raw disc sectors via platform-specific command.
     pub fn read_sectors(&mut self, lba: u32, count: u16, buf: &mut [u8]) -> Result<usize> {
         self.platform.read_sectors(self.scsi.as_mut(), lba, count, buf)
     }
 
-    /// Generic probe command.
+    /// Platform-specific probe command.
     pub fn probe(&mut self, sub_cmd: u8, address: u32, length: u32) -> Result<Vec<u8>> {
         self.platform.probe(self.scsi.as_mut(), sub_cmd, address, length)
     }
+
+    /// Standard SCSI READ(10) for disc filesystem data (UDF, MPLS, CLPI).
+    pub fn read_disc(&mut self, lba: u32, count: u16, buf: &mut [u8]) -> Result<usize> {
+        let cdb = [
+            crate::scsi::SCSI_READ_10, 0x00,
+            (lba >> 24) as u8, (lba >> 16) as u8, (lba >> 8) as u8, lba as u8,
+            0x00,
+            (count >> 8) as u8, count as u8,
+            0x00,
+        ];
+        let result = self.scsi.as_mut().execute(
+            &cdb, crate::scsi::DataDirection::FromDevice, buf, 5_000)?;
+        Ok(result.bytes_transferred)
+    }
+
+    /// Execute a raw SCSI CDB. Used by parsers and AACS handshake.
+    pub fn scsi_execute(
+        &mut self,
+        cdb: &[u8],
+        direction: crate::scsi::DataDirection,
+        buf: &mut [u8],
+        timeout_ms: u32,
+    ) -> Result<crate::scsi::ScsiResult> {
+        self.scsi.as_mut().execute(cdb, direction, buf, timeout_ms)
+    }
+}
+
+/// Create the platform-specific driver for a given chipset.
+fn create_platform(profile: &DriveProfile, drive_id: &DriveId) -> Result<Box<dyn Platform>> {
+    match profile.chipset {
+        Chipset::MediaTek => Ok(Box::new(Mt1959::new(profile.clone()))),
+        Chipset::Renesas => Err(Error::UnsupportedDrive {
+            vendor_id: drive_id.vendor_id.trim().to_string(),
+            product_id: drive_id.product_id.trim().to_string(),
+            product_revision: "Renesas not yet implemented".to_string(),
+        }),
+    }
 }

src/error.rs

@@ -1,92 +1,120 @@
-/// libfreemkv error codes.
-///
-/// The library returns structured error codes with context data.
-/// Applications are responsible for formatting user-facing messages.
-/// This keeps the library locale-independent and testable.
+//! Error types for libfreemkv.
+//!
+//! Every error carries a numeric code for programmatic handling.
+//! No user-facing English text — applications format their own messages.
+//! This keeps the library locale-independent and testable.
+//!
+//! # Error Code Ranges
+//!
+//! | Range | Category |
+//! |-------|----------|
+//! | E1xxx | Device errors |
+//! | E2xxx | Profile errors |
+//! | E3xxx | Unlock errors |
+//! | E4xxx | SCSI errors |
+//! | E5xxx | I/O errors |
+//! | E6xxx | Disc format errors |
+//! | E7xxx | AACS errors |
 
-/// Error code table.
-///
-/// | Code | Name | Meaning |
-/// |------|------|---------|
-/// | 1000 | DeviceNotFound | Device path doesn't exist or can't be opened |
-/// | 1001 | DevicePermission | Device exists but permission denied |
-/// | 2000 | UnsupportedDrive | Drive not in profile database |
-/// | 2001 | ProfileNotFound | Specific firmware version not in database |
-/// | 2002 | ProfileParse | Profile database is malformed |
-/// | 3000 | UnlockFailed | Drive rejected unlock command |
-/// | 3001 | SignatureMismatch | Wrong signature returned by drive |
-/// | 3002 | NotUnlocked | Raw read attempted before unlock |
-/// | 3003 | NotCalibrated | Raw read attempted before calibrate |
-/// | 4000 | ScsiError | SCSI command failed |
-/// | 4001 | ScsiTimeout | SCSI command timed out |
-/// | 5000 | IoError | OS-level I/O error |
+// ── Error codes (single source of truth) ────────────────────────────────────
+
+pub const E_DEVICE_NOT_FOUND: u16     = 1000;
+pub const E_DEVICE_PERMISSION: u16    = 1001;
+pub const E_UNSUPPORTED_DRIVE: u16    = 2000;
+pub const E_PROFILE_NOT_FOUND: u16    = 2001;
+pub const E_PROFILE_PARSE: u16        = 2002;
+pub const E_UNLOCK_FAILED: u16        = 3000;
+pub const E_SIGNATURE_MISMATCH: u16   = 3001;
+pub const E_NOT_UNLOCKED: u16         = 3002;
+pub const E_NOT_CALIBRATED: u16       = 3003;
+pub const E_SCSI_ERROR: u16           = 4000;
+pub const E_SCSI_TIMEOUT: u16         = 4001;
+pub const E_IO_ERROR: u16             = 5000;
+pub const E_DISC_ERROR: u16           = 6000;
+pub const E_AACS_ERROR: u16           = 7000;
+
+// ── Error enum ──────────────────────────────────────────────────────────────
+
+/// Structured error with numeric code and context data.
 #[derive(Debug)]
 pub enum Error {
-    // 1xxx — Device errors
     DeviceNotFound { path: String },
     DevicePermission { path: String },
-
-    // 2xxx — Profile errors
     UnsupportedDrive { vendor_id: String, product_id: String, product_revision: String },
     ProfileNotFound { vendor_id: String, product_revision: String, vendor_specific: String },
     ProfileParse { detail: String },
-
-    // 3xxx — Unlock errors
     UnlockFailed { detail: String },
     SignatureMismatch { expected: [u8; 4], got: [u8; 4] },
     NotUnlocked,
     NotCalibrated,
-
-    // 4xxx — SCSI errors
     ScsiError { opcode: u8, status: u8, sense_key: u8 },
     ScsiTimeout { opcode: u8 },
-
-    // 5xxx — I/O errors
     IoError { source: std::io::Error },
+    DiscError { detail: String },
+    AacsError { detail: String },
 }
 
 impl Error {
-    /// Numeric error code for programmatic handling.
+    /// Numeric error code.
     pub fn code(&self) -> u16 {
         match self {
-            Error::DeviceNotFound { .. }    => 1000,
-            Error::DevicePermission { .. }  => 1001,
-            Error::UnsupportedDrive { .. }  => 2000,
-            Error::ProfileNotFound { .. }   => 2001,
-            Error::ProfileParse { .. }      => 2002,
-            Error::UnlockFailed { .. }      => 3000,
-            Error::SignatureMismatch { .. } => 3001,
-            Error::NotUnlocked              => 3002,
-            Error::NotCalibrated            => 3003,
-            Error::ScsiError { .. }         => 4000,
-            Error::ScsiTimeout { .. }       => 4001,
-            Error::IoError { .. }           => 5000,
+            Error::DeviceNotFound { .. }    => E_DEVICE_NOT_FOUND,
+            Error::DevicePermission { .. }  => E_DEVICE_PERMISSION,
+            Error::UnsupportedDrive { .. }  => E_UNSUPPORTED_DRIVE,
+            Error::ProfileNotFound { .. }   => E_PROFILE_NOT_FOUND,
+            Error::ProfileParse { .. }      => E_PROFILE_PARSE,
+            Error::UnlockFailed { .. }      => E_UNLOCK_FAILED,
+            Error::SignatureMismatch { .. } => E_SIGNATURE_MISMATCH,
+            Error::NotUnlocked              => E_NOT_UNLOCKED,
+            Error::NotCalibrated            => E_NOT_CALIBRATED,
+            Error::ScsiError { .. }         => E_SCSI_ERROR,
+            Error::ScsiTimeout { .. }       => E_SCSI_TIMEOUT,
+            Error::IoError { .. }           => E_IO_ERROR,
+            Error::DiscError { .. }         => E_DISC_ERROR,
+            Error::AacsError { .. }         => E_AACS_ERROR,
         }
     }
 }
 
-/// Default Display — terse, for logs. Applications should format their own messages.
+/// Display format: "E{code}: {context}" — terse, for logs.
+/// Applications should format their own user-facing messages using code() and fields.
 impl std::fmt::Display for Error {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Error::DeviceNotFound { path } => write!(f, "E1000: device not found: {path}"),
-            Error::DevicePermission { path } => write!(f, "E1001: permission denied: {path}"),
+            Error::DeviceNotFound { path } =>
+                write!(f, "E{}: {}", E_DEVICE_NOT_FOUND, path),
+            Error::DevicePermission { path } =>
+                write!(f, "E{}: {}", E_DEVICE_PERMISSION, path),
             Error::UnsupportedDrive { vendor_id, product_id, product_revision } =>
-                write!(f, "E2000: unsupported drive: {} {} {}", vendor_id.trim(), product_id.trim(), product_revision.trim()),
+                write!(f, "E{}: {} {} {}", E_UNSUPPORTED_DRIVE,
+                    vendor_id.trim(), product_id.trim(), product_revision.trim()),
             Error::ProfileNotFound { vendor_id, product_revision, vendor_specific } =>
-                write!(f, "E2001: no profile: {} {} {}", vendor_id.trim(), product_revision.trim(), vendor_specific.trim()),
-            Error::ProfileParse { detail } => write!(f, "E2002: profile parse: {detail}"),
-            Error::UnlockFailed { detail } => write!(f, "E3000: unlock failed: {detail}"),
+                write!(f, "E{}: {} {} {}", E_PROFILE_NOT_FOUND,
+                    vendor_id.trim(), product_revision.trim(), vendor_specific.trim()),
+            Error::ProfileParse { detail } =>
+                write!(f, "E{}: {}", E_PROFILE_PARSE, detail),
+            Error::UnlockFailed { detail } =>
+                write!(f, "E{}: {}", E_UNLOCK_FAILED, detail),
             Error::SignatureMismatch { expected, got } =>
-                write!(f, "E3001: signature mismatch: expected {:02x}{:02x}{:02x}{:02x} got {:02x}{:02x}{:02x}{:02x}",
+                write!(f, "E{}: expected {:02x}{:02x}{:02x}{:02x} got {:02x}{:02x}{:02x}{:02x}",
+                    E_SIGNATURE_MISMATCH,
                     expected[0], expected[1], expected[2], expected[3],
                     got[0], got[1], got[2], got[3]),
-            Error::NotUnlocked => write!(f, "E3002: not unlocked"),
-            Error::NotCalibrated => write!(f, "E3003: not calibrated"),
+            Error::NotUnlocked =>
+                write!(f, "E{}", E_NOT_UNLOCKED),
+            Error::NotCalibrated =>
+                write!(f, "E{}", E_NOT_CALIBRATED),
             Error::ScsiError { opcode, status, sense_key } =>
-                write!(f, "E4000: SCSI 0x{opcode:02x} failed: status=0x{status:02x} sense=0x{sense_key:02x}"),
-            Error::ScsiTimeout { opcode } => write!(f, "E4001: SCSI 0x{opcode:02x} timeout"),
-            Error::IoError { source } => write!(f, "E5000: {source}"),
+                write!(f, "E{}: opcode=0x{:02x} status=0x{:02x} sense=0x{:02x}",
+                    E_SCSI_ERROR, opcode, status, sense_key),
+            Error::ScsiTimeout { opcode } =>
+                write!(f, "E{}: opcode=0x{:02x}", E_SCSI_TIMEOUT, opcode),
+            Error::IoError { source } =>
+                write!(f, "E{}: {}", E_IO_ERROR, source),
+            Error::DiscError { detail } =>
+                write!(f, "E{}: {}", E_DISC_ERROR, detail),
+            Error::AacsError { detail } =>
+                write!(f, "E{}: {}", E_AACS_ERROR, detail),
         }
     }
 }

src/jar.rs

@@ -0,0 +1,263 @@
+//! BD-J JAR parser — extract audio/subtitle track labels from disc menus.
+//!
+//! 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).
+//!
+//! with no way to tell them apart (e.g. 3x "AC-3 5.1 English").
+//!
+//! 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.
+
+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)
+    pub audio: Vec<TrackLabel>,
+    /// Subtitle track labels: (language, stream_index, raw_label)
+    pub subtitle: Vec<TrackLabel>,
+    /// Playlist purpose labels (MAIN_FEATURE, FORCED_TRAILER, etc.)
+    pub playlists: Vec<String>,
+}
+
+/// 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
+    pub description: 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;
+        }
+
+        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;
+        }
+
+        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(),
+        })
+    }
+
+    /// 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")
+    }
+
+    /// Is this a subtitle track label?
+    fn is_subtitle(&self) -> bool {
+        self.hint.starts_with("PGStream")
+    }
+}
+
+/// 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> {
+    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();
+
+    for i in 0..archive.len() {
+        let mut file = archive.by_index(i).ok()?;
+        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());
+                }
+            }
+        }
+    }
+
+    if all_audio.is_empty() && all_subtitle.is_empty() {
+        return None;
+    }
+
+    Some(JarLabels {
+        audio: all_audio,
+        subtitle: all_subtitle,
+        playlists: all_playlists,
+    })
+}
+
+/// 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
+    if data.len() < 10 || &data[0..4] != &[0xCA, 0xFE, 0xBA, 0xBE] {
+        return strings;
+    }
+
+    let cp_count = ((data[8] as u16) << 8 | data[9] as u16) as usize;
+    let mut pos = 10;
+
+    // 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;
+
+        match tag {
+            // CONSTANT_Utf8
+            1 => {
+                if pos + 2 > data.len() { break; }
+                let len = ((data[pos] as usize) << 8) | data[pos + 1] as usize;
+                pos += 2;
+                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());
+                    }
+                }
+                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)]
+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());
+    }
+
+    #[test]
+    fn test_parse_subtitle_labels() {
+        let l = TrackLabel::parse("dan_PGStream4").unwrap();
+        assert_eq!(l.language, "dan");
+        assert!(l.is_subtitle());
+    }
+
+    #[test]
+    fn test_reject_non_labels() {
+        assert!(TrackLabel::parse("substring").is_none());
+        assert!(TrackLabel::parse("equals").is_none());
+        assert!(TrackLabel::parse("Code").is_none());
+    }
+}

src/lib.rs

@@ -1,38 +1,70 @@
-//! libfreemkv — Open source raw disc access for optical drives.
+//! libfreemkv — Open source optical drive library for 4K UHD / Blu-ray / DVD.
 //!
-//! Provides SCSI/MMC commands to enable raw reading mode on compatible
-//! Blu-ray drives, allowing direct sector access for disc archival
-//! and backup purposes.
-//!
-//! # Architecture
-//!
-//! The library is data-driven. Drive-specific SCSI command sequences
-//! are stored in profile files, not in code. Adding support for a new
-//! drive requires only a profile contribution — no rebuild needed.
-//!
-//! ```text
-//! DriveSession (high-level API)
-//!   ├── Platform trait (per-chipset unlock logic)
-//!   ├── DriveProfile (per-drive data from JSON profiles)
-//!   └── ScsiTransport (SG_IO on Linux, IOKit on macOS)
-//! ```
+//! Handles drive access, disc structure parsing, AACS decryption, and raw
+//! sector reading. 206 bundled drive profiles. No external files needed.
 //!
 //! # Quick Start
 //!
 //! ```no_run
-//! use libfreemkv::DriveSession;
+//! use libfreemkv::{DriveSession, Disc, ScanOptions};
 //! use std::path::Path;
 //!
-//! let mut session = DriveSession::open(
-//!     Path::new("/dev/sr0"),
-//! ).unwrap();
+//! let mut session = DriveSession::open(Path::new("/dev/sr0")).unwrap();
+//! let disc = Disc::scan(&mut session, &ScanOptions::default()).unwrap();
 //!
-//! session.unlock().unwrap();
-//! session.calibrate().unwrap();
+//! for title in &disc.titles {
+//!     println!("{} — {} streams", title.duration_display(), title.streams.len());
+//! }
 //!
-//! let mut buf = vec![0u8; 2048];
-//! let n = session.read_sectors(0, 1, &mut buf).unwrap();
+//! // Read content (decrypted automatically if AACS keys available)
+//! let mut reader = disc.open_title(&mut session, 0).unwrap();
+//! while let Some(unit) = reader.read_unit().unwrap() {
+//!     // 6144 bytes of decrypted content per unit
+//! }
 //! ```
+//!
+//! # Architecture
+//!
+//! ```text
+//! DriveSession           — open, identify, unlock, read sectors
+//!   ├── ScsiTransport    — SG_IO (Linux), IOKit (macOS)
+//!   ├── DriveProfile     — per-drive unlock parameters (206 bundled)
+//!   ├── DriveId          — INQUIRY + GET_CONFIG identification
+//!   └── Platform
+//!       └── Mt1959       — MediaTek unlock/read (Renesas planned)
+//!
+//! Disc                   — scan titles, streams, AACS state
+//!   ├── UDF reader       — Blu-ray UDF 2.50 with metadata partitions
+//!   ├── MPLS parser      — playlists → titles + clips + STN streams
+//!   ├── CLPI parser      — clip info → EP map → sector extents
+//!   ├── JAR parser       — BD-J audio track labels
+//!   └── AACS             — encryption: key resolution + content decrypt
+//!       ├── aacs         — KEYDB, VUK, MKB, unit decrypt
+//!       └── handshake    — SCSI auth, ECDH, bus key
+//! ```
+//!
+//! # AACS Encryption
+//!
+//! Disc scanning automatically detects and handles AACS encryption.
+//! If a KEYDB.cfg is available (via `ScanOptions` or standard paths),
+//! the library resolves keys and decrypts content transparently.
+//!
+//! Supports AACS 1.0 (Blu-ray) and AACS 2.0 (UHD, with fallback).
+//!
+//! # Error Codes
+//!
+//! All errors are structured with numeric codes. No user-facing English
+//! text — applications format their own messages.
+//!
+//! | Range | Category |
+//! |-------|----------|
+//! | E1xxx | Device errors (not found, permission) |
+//! | E2xxx | Profile errors (unsupported drive) |
+//! | E3xxx | Unlock errors (failed, signature) |
+//! | E4xxx | SCSI errors (command failed, timeout) |
+//! | E5xxx | I/O errors |
+//! | E6xxx | Disc format errors |
+//! | E7xxx | AACS errors |
 
 pub mod error;
 pub mod scsi;
@@ -41,6 +73,12 @@ pub mod platform;
 pub mod drive;
 pub mod identity;
 pub mod speed;
+pub mod udf;
+pub mod mpls;
+pub mod clpi;
+pub mod disc;
+pub mod jar;
+pub mod aacs;
 
 pub use error::{Error, Result};
 pub use drive::DriveSession;
@@ -49,3 +87,5 @@ 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,
+               Extent, ContentReader, AacsState, KeySource, ScanOptions};

src/mpls.rs

@@ -0,0 +1,291 @@
+//! MPLS playlist parser — Blu-ray movie playlists.
+//!
+//! Each .mpls file in BDMV/PLAYLIST/ defines a title.
+//! Contains play items (clips) with in/out timestamps,
+//! stream info (video, audio, subtitle tracks).
+//!
+//! Reference: https://github.com/lw/BluRay/wiki/MPLS
+
+use crate::error::{Error, Result};
+
+/// Parsed MPLS playlist.
+#[derive(Debug)]
+pub struct Playlist {
+    /// MPLS version (e.g. "0200" or "0300")
+    pub version: String,
+    /// Play items in playback order
+    pub play_items: Vec<PlayItem>,
+    /// Streams from the first play item's STN table
+    pub streams: Vec<StreamEntry>,
+}
+
+/// A play item — one clip reference with in/out times.
+#[derive(Debug)]
+pub struct PlayItem {
+    /// 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,
+    /// Connection condition (1=seamless, 5/6=non-seamless)
+    pub connection_condition: u8,
+}
+
+/// 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
+    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.)
+    pub video_format: u8,
+    /// Video frame rate (1=23.976, 3=25, 4=29.97, etc.)
+    pub video_rate: u8,
+    /// Audio format (3=stereo, 6=5.1, 12=7.1, etc.)
+    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,
+}
+
+/// Parse an MPLS file from raw bytes.
+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 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
+
+    for item_idx in 0..num_play_items {
+        if playlist_start + pos + 2 > data.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;
+        }
+
+        let item = &pl[pos + 2..pos + 2 + item_length];
+        if item.len() < 20 { break; }
+
+        let clip_id = String::from_utf8_lossy(&item[0..5]).to_string();
+        let connection_condition = item[9] & 0x0F;
+        let in_time = u32::from_be_bytes([item[12], item[13], item[14], item[15]]);
+        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.
+
+            // 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 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;
+                        }
+                    }
+                }
+            }
+        }
+
+        play_items.push(PlayItem {
+            clip_id,
+            in_time,
+            out_time,
+            connection_condition,
+        });
+
+        pos += 2 + item_length;
+    }
+
+    Ok(Playlist {
+        version,
+        play_items,
+        streams,
+    })
+}
+
+/// 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; }
+
+    // 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
+
+    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]])
+    } 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; }
+
+    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 mut video_format = 0u8;
+    let mut video_rate = 0u8;
+    let mut audio_format = 0u8;
+    let mut audio_rate = 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;
+            }
+        }
+        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;
+            }
+            if attr.len() >= 5 {
+                language = String::from_utf8_lossy(&attr[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();
+            }
+        }
+        _ => {}
+    }
+
+    let total_consumed = 1 + entry_len + 1 + attr_len;
+
+    Some((StreamEntry {
+        stream_type,
+        pid,
+        coding_type,
+        video_format,
+        video_rate,
+        audio_format,
+        audio_rate,
+        language,
+    }, total_consumed))
+}

src/scsi.rs

@@ -1,248 +0,0 @@
-//! SCSI/MMC command interface.
-//!
-//! Platform backends:
-//!   - Linux: SG_IO ioctl
-//!   - macOS: IOKit SCSI passthrough (planned)
-//!   - Windows: SPTI (planned)
-
-use crate::error::{Error, Result};
-use std::path::Path;
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum DataDirection {
-    None,
-    FromDevice,
-    ToDevice,
-}
-
-#[derive(Debug)]
-pub struct ScsiResult {
-    pub status: u8,
-    pub bytes_transferred: usize,
-    pub sense: [u8; 32],
-}
-
-/// Low-level SCSI transport — implemented per platform.
-pub trait ScsiTransport {
-    fn execute(
-        &mut self,
-        cdb: &[u8],
-        direction: DataDirection,
-        data: &mut [u8],
-        timeout_ms: u32,
-    ) -> Result<ScsiResult>;
-}
-
-// ─── Linux: SG_IO ───────────────────────────────────────────────────────────
-
-#[cfg(target_os = "linux")]
-const SG_IO: libc::c_ulong = 0x2285;
-#[cfg(target_os = "linux")]
-const SG_DXFER_NONE: i32 = -1;
-#[cfg(target_os = "linux")]
-const SG_DXFER_TO_DEV: i32 = -2;
-#[cfg(target_os = "linux")]
-const SG_DXFER_FROM_DEV: i32 = -3;
-
-#[cfg(target_os = "linux")]
-#[repr(C)]
-#[allow(non_camel_case_types)]
-struct sg_io_hdr {
-    interface_id: i32,
-    dxfer_direction: i32,
-    cmd_len: u8,
-    mx_sb_len: u8,
-    iovec_count: u16,
-    dxfer_len: u32,
-    dxferp: *mut u8,
-    cmdp: *const u8,
-    sbp: *mut u8,
-    timeout: u32,
-    flags: u32,
-    pack_id: i32,
-    usr_ptr: *mut libc::c_void,
-    status: u8,
-    masked_status: u8,
-    msg_status: u8,
-    sb_len_wr: u8,
-    host_status: u16,
-    driver_status: u16,
-    resid: i32,
-    duration: u32,
-    info: u32,
-}
-
-#[cfg(target_os = "linux")]
-pub struct SgIoTransport {
-    fd: i32,
-}
-
-#[cfg(target_os = "linux")]
-impl SgIoTransport {
-    pub fn open(device: &Path) -> Result<Self> {
-        use std::os::unix::ffi::OsStrExt;
-        let path_bytes = device.as_os_str().as_bytes();
-        let mut c_path = Vec::with_capacity(path_bytes.len() + 1);
-        c_path.extend_from_slice(path_bytes);
-        c_path.push(0);
-
-        let fd = unsafe { libc::open(c_path.as_ptr() as *const libc::c_char, libc::O_RDWR | libc::O_NONBLOCK) };
-        if fd < 0 {
-            return Err(Error::DeviceNotFound { path: device.display().to_string() });
-        }
-        Ok(SgIoTransport { fd })
-    }
-}
-
-#[cfg(target_os = "linux")]
-impl Drop for SgIoTransport {
-    fn drop(&mut self) {
-        unsafe { libc::close(self.fd); }
-    }
-}
-
-#[cfg(target_os = "linux")]
-impl ScsiTransport for SgIoTransport {
-    fn execute(
-        &mut self,
-        cdb: &[u8],
-        direction: DataDirection,
-        data: &mut [u8],
-        timeout_ms: u32,
-    ) -> Result<ScsiResult> {
-        let mut sense = [0u8; 32];
-
-        let dxfer_direction = match direction {
-            DataDirection::None => SG_DXFER_NONE,
-            DataDirection::FromDevice => SG_DXFER_FROM_DEV,
-            DataDirection::ToDevice => SG_DXFER_TO_DEV,
-        };
-
-        let mut hdr: sg_io_hdr = unsafe { std::mem::zeroed() };
-        hdr.interface_id = b'S' as i32;
-        hdr.dxfer_direction = dxfer_direction;
-        hdr.cmd_len = cdb.len() as u8;
-        hdr.mx_sb_len = sense.len() as u8;
-        hdr.dxfer_len = data.len() as u32;
-        hdr.dxferp = data.as_mut_ptr();
-        hdr.cmdp = cdb.as_ptr();
-        hdr.sbp = sense.as_mut_ptr();
-        hdr.timeout = timeout_ms;
-
-        let ret = unsafe {
-            libc::ioctl(self.fd, SG_IO, &mut hdr as *mut sg_io_hdr)
-        };
-
-        if ret < 0 {
-            return Err(Error::IoError { source: std::io::Error::last_os_error() });
-        }
-
-        let bytes_transferred = (data.len() as i32 - hdr.resid) as usize;
-
-        if hdr.status != 0 {
-            let sense_key = if hdr.sb_len_wr > 2 { sense[2] & 0x0F } else { 0 };
-            return Err(Error::ScsiError {
-                opcode: cdb[0],
-                status: hdr.status,
-                sense_key,
-            });
-        }
-
-        Ok(ScsiResult {
-            status: hdr.status,
-            bytes_transferred,
-            sense,
-        })
-    }
-}
-
-// ─── macOS: IOKit (planned) ─────────────────────────────────────────────────
-
-// TODO: IOKit MMC SCSI passthrough
-// Use IOSCSIPeripheralDeviceType05 (MMC device nub)
-// Send SCSITaskInterface commands via IOKit user client
-
-// ─── Windows: SPTI (planned) ────────────────────────────────────────────────
-
-// TODO: SCSI Pass Through Interface
-// Use CreateFile on \\.\CdRomN
-// Send IOCTL_SCSI_PASS_THROUGH_DIRECT
-
-// ─── Platform-agnostic open ─────────────────────────────────────────────────
-
-/// Open a SCSI transport for the given device path.
-pub fn open(device: &Path) -> Result<Box<dyn ScsiTransport>> {
-    #[cfg(target_os = "linux")]
-    { Ok(Box::new(SgIoTransport::open(device)?)) }
-
-    #[cfg(not(target_os = "linux"))]
-    { Err(Error::DeviceNotFound { path: format!("{}: platform not yet supported (Linux only)", device.display()) }) }
-}
-
-// ─── CDB builders (platform-agnostic) ───────────────────────────────────────
-
-/// SCSI INQUIRY response.
-#[derive(Debug, Clone)]
-pub struct InquiryResult {
-    pub vendor_id: String,
-    pub model: String,
-    pub firmware: String,
-    pub raw: Vec<u8>,
-}
-
-/// Send INQUIRY command and parse the standard response fields.
-pub fn inquiry(scsi: &mut dyn ScsiTransport) -> Result<InquiryResult> {
-    let cdb = [0x12, 0x00, 0x00, 0x00, 0x60, 0x00];
-    let mut buf = [0u8; 96];
-    scsi.execute(&cdb, DataDirection::FromDevice, &mut buf, 5_000)?;
-
-    let vendor = String::from_utf8_lossy(&buf[8..16]).trim().to_string();
-    let model = String::from_utf8_lossy(&buf[16..32]).trim().to_string();
-    let firmware = String::from_utf8_lossy(&buf[32..36]).trim().to_string();
-
-    Ok(InquiryResult {
-        vendor_id: vendor,
-        model,
-        firmware,
-        raw: buf.to_vec(),
-    })
-}
-
-/// Send GET CONFIGURATION for feature 0x010C (Firmware Information).
-pub fn get_config_010c(scsi: &mut dyn ScsiTransport) -> Result<Vec<u8>> {
-    let cdb = [0x46, 0x02, 0x01, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00];
-    let mut buf = [0u8; 16];
-    scsi.execute(&cdb, DataDirection::FromDevice, &mut buf, 5_000)?;
-    Ok(buf.to_vec())
-}
-
-/// Build a READ BUFFER (0x3C) CDB.
-pub fn build_read_buffer(mode: u8, buffer_id: u8, offset: u32, length: u32) -> [u8; 10] {
-    [
-        0x3C, mode, buffer_id,
-        (offset >> 16) as u8, (offset >> 8) as u8, offset as u8,
-        (length >> 16) as u8, (length >> 8) as u8, length as u8,
-        0x00,
-    ]
-}
-
-/// Build a SET CD SPEED (0xBB) CDB.
-pub fn build_set_cd_speed(read_speed: u16) -> [u8; 12] {
-    [
-        0xBB, 0x00,
-        (read_speed >> 8) as u8, read_speed as u8,
-        0xFF, 0xFF,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    ]
-}
-
-/// Build a READ(10) CDB with the raw read flag (0x08).
-pub fn build_read10_raw(lba: u32, count: u16) -> [u8; 10] {
-    [
-        0x28, 0x08,
-        (lba >> 24) as u8, (lba >> 16) as u8, (lba >> 8) as u8, lba as u8,
-        0x00,
-        (count >> 8) as u8, count as u8,
-        0x00,
-    ]
-}

src/scsi/linux.rs

@@ -0,0 +1,119 @@
+//! Linux SCSI transport via SG_IO ioctl.
+
+use crate::error::{Error, Result};
+use super::{ScsiTransport, ScsiResult, DataDirection};
+use std::path::Path;
+
+const SG_IO: u32 = 0x2285;
+const SG_DXFER_NONE: i32 = -1;
+const SG_DXFER_TO_DEV: i32 = -2;
+const SG_DXFER_FROM_DEV: i32 = -3;
+
+#[repr(C)]
+#[allow(non_camel_case_types)]
+struct sg_io_hdr {
+    interface_id: i32,
+    dxfer_direction: i32,
+    cmd_len: u8,
+    mx_sb_len: u8,
+    iovec_count: u16,
+    dxfer_len: u32,
+    dxferp: *mut u8,
+    cmdp: *const u8,
+    sbp: *mut u8,
+    timeout: u32,
+    flags: u32,
+    pack_id: i32,
+    usr_ptr: *mut libc::c_void,
+    status: u8,
+    masked_status: u8,
+    msg_status: u8,
+    sb_len_wr: u8,
+    host_status: u16,
+    driver_status: u16,
+    resid: i32,
+    duration: u32,
+    info: u32,
+}
+
+pub struct SgIoTransport {
+    fd: i32,
+}
+
+impl SgIoTransport {
+    pub fn open(device: &Path) -> Result<Self> {
+        use std::os::unix::ffi::OsStrExt;
+        let path_bytes = device.as_os_str().as_bytes();
+        let mut c_path = Vec::with_capacity(path_bytes.len() + 1);
+        c_path.extend_from_slice(path_bytes);
+        c_path.push(0);
+
+        let fd = unsafe {
+            libc::open(c_path.as_ptr() as *const libc::c_char, libc::O_RDWR | libc::O_NONBLOCK)
+        };
+        if fd < 0 {
+            return Err(Error::DeviceNotFound { path: device.display().to_string() });
+        }
+        Ok(SgIoTransport { fd })
+    }
+}
+
+impl Drop for SgIoTransport {
+    fn drop(&mut self) {
+        unsafe { libc::close(self.fd); }
+    }
+}
+
+impl ScsiTransport for SgIoTransport {
+    fn execute(
+        &mut self,
+        cdb: &[u8],
+        direction: DataDirection,
+        data: &mut [u8],
+        timeout_ms: u32,
+    ) -> Result<ScsiResult> {
+        let mut sense = [0u8; 32];
+
+        let dxfer_direction = match direction {
+            DataDirection::None => SG_DXFER_NONE,
+            DataDirection::FromDevice => SG_DXFER_FROM_DEV,
+            DataDirection::ToDevice => SG_DXFER_TO_DEV,
+        };
+
+        let mut hdr: sg_io_hdr = unsafe { std::mem::zeroed() };
+        hdr.interface_id = b'S' as i32;
+        hdr.dxfer_direction = dxfer_direction;
+        hdr.cmd_len = cdb.len() as u8;
+        hdr.mx_sb_len = sense.len() as u8;
+        hdr.dxfer_len = data.len() as u32;
+        hdr.dxferp = data.as_mut_ptr();
+        hdr.cmdp = cdb.as_ptr();
+        hdr.sbp = sense.as_mut_ptr();
+        hdr.timeout = timeout_ms;
+
+        let ret = unsafe {
+            libc::ioctl(self.fd, SG_IO as _, &mut hdr as *mut sg_io_hdr)
+        };
+
+        if ret < 0 {
+            return Err(Error::IoError { source: std::io::Error::last_os_error() });
+        }
+
+        let bytes_transferred = (data.len() as i32 - hdr.resid) as usize;
+
+        if hdr.status != 0 {
+            let sense_key = if hdr.sb_len_wr > 2 { sense[2] & 0x0F } else { 0 };
+            return Err(Error::ScsiError {
+                opcode: cdb[0],
+                status: hdr.status,
+                sense_key,
+            });
+        }
+
+        Ok(ScsiResult {
+            status: hdr.status,
+            bytes_transferred,
+            sense,
+        })
+    }
+}

src/scsi/macos.rs

@@ -0,0 +1,464 @@
+//! macOS SCSI transport via IOKit SCSITaskDeviceInterface.
+//!
+//! Sends SCSI commands to optical drives through IOKit's SCSI Architecture
+//! Model family. Accepts BSD device paths like `/dev/disk2` or `/dev/rdisk2`.
+//!
+//! Requires exclusive access to the device — unmount the disc first:
+//! `diskutil unmountDisk /dev/disk2`
+
+use crate::error::{Error, Result};
+use super::{DataDirection, ScsiResult, ScsiTransport};
+use std::path::Path;
+
+// ── IOKit / CoreFoundation type aliases ─────────────────────────────────────
+
+type CFMutableDictionaryRef = *mut std::ffi::c_void;
+type IOObject = u32;
+type IOReturn = i32;
+type MachPort = u32;
+
+/// Opaque COM interface pointer — `*mut *mut VTable` (double-indirect).
+/// IOKit plugins use COM-style vtables: the pointer points to a pointer
+/// to the function table.
+type ComRef = *mut *mut std::ffi::c_void;
+
+const K_IO_RETURN_SUCCESS: IOReturn = 0;
+
+// SCSI data transfer directions (SCSITaskLib.h)
+const K_SCSI_DATA_TRANSFER_NO_DATA: u8 = 0;
+const K_SCSI_DATA_TRANSFER_FROM_TARGET: u8 = 1;
+const K_SCSI_DATA_TRANSFER_TO_TARGET: u8 = 2;
+
+// SCSI task status values
+const K_SCSI_TASK_STATUS_GOOD: u8 = 0x00;
+
+const K_MAX_CDB_SIZE: usize = 16;
+const K_SENSE_DATA_SIZE: usize = 32;
+
+// ── IOKit plugin UUIDs ──────────────────────────────────────────────────────
+// From IOKit/scsi/SCSITaskLib.h
+
+/// kIOMMCDeviceUserClientTypeID — plugin type for MMC (optical) devices.
+const K_IO_MMC_DEVICE_USER_CLIENT_TYPE_ID: [u8; 16] = [
+    0x97, 0xAB, 0xCF, 0x5C, 0x45, 0x71, 0x11, 0xD6,
+    0xB6, 0xA0, 0x00, 0x30, 0x65, 0xA4, 0x7A, 0xEE,
+];
+
+/// kIOCFPlugInInterfaceID — base IOCFPlugin interface.
+const K_IO_CFPLUGIN_INTERFACE_ID: [u8; 16] = [
+    0xC2, 0x44, 0xE8, 0x58, 0x10, 0x9C, 0x11, 0xD4,
+    0x91, 0xD4, 0x00, 0x50, 0xE4, 0xC6, 0x42, 0x6F,
+];
+
+/// kIOSCSITaskDeviceInterfaceID — the interface we QueryInterface for.
+const K_IO_SCSI_TASK_DEVICE_INTERFACE_ID: [u8; 16] = [
+    0x61, 0x3E, 0x48, 0xB0, 0x30, 0x01, 0x11, 0xD6,
+    0xA4, 0xC0, 0x00, 0x0A, 0x27, 0x05, 0x28, 0x61,
+];
+
+// ── Scatter/gather element ──────────────────────────────────────────────────
+
+#[repr(C)]
+struct SCSITaskSGElement {
+    address: u64,
+    length: u64,
+}
+
+// ── External IOKit / CoreFoundation functions ───────────────────────────────
+
+extern "C" {
+    fn IOMasterPort(bootstrap: u32, master: *mut MachPort) -> IOReturn;
+    fn IOBSDNameMatching(
+        master: MachPort,
+        options: u32,
+        bsd_name: *const u8,
+    ) -> CFMutableDictionaryRef;
+    fn IOServiceGetMatchingService(
+        master: MachPort,
+        matching: CFMutableDictionaryRef,
+    ) -> IOObject;
+    fn IOObjectRelease(object: IOObject) -> IOReturn;
+    fn IORegistryEntryGetParentEntry(
+        entry: IOObject,
+        plane: *const u8,
+        parent: *mut IOObject,
+    ) -> IOReturn;
+    fn IOObjectConformsTo(object: IOObject, class_name: *const u8) -> u8;
+    fn IOCreatePlugInInterfaceForService(
+        service: IOObject,
+        plugin_type: *const [u8; 16],
+        interface_type: *const [u8; 16],
+        the_interface: *mut ComRef,
+        the_score: *mut i32,
+    ) -> IOReturn;
+}
+
+// ── COM vtable helpers ──────────────────────────────────────────────────────
+//
+// IOKit plugin interfaces use COM-style vtables. A ComRef is **vtable —
+// dereferencing once gives the vtable pointer, then index into it for
+// individual function pointers.
+//
+// All vtable indices verified against Apple open source:
+// IOSCSIArchitectureModelFamily/UserClientLib/SCSITaskLib.h
+
+/// Read a function pointer from a COM vtable at the given index.
+unsafe fn vtable_fn<T>(iface: ComRef, index: usize) -> T {
+    let vtable = *iface as *const *const std::ffi::c_void;
+    let fn_ptr = *vtable.add(index);
+    std::mem::transmute_copy(&fn_ptr)
+}
+
+/// Call Release (vtable index 3) on any COM interface.
+fn com_release(iface: ComRef) {
+    type Fn = unsafe extern "C" fn(ComRef) -> u32;
+    unsafe {
+        let f: Fn = vtable_fn(iface, 3);
+        f(iface);
+    }
+}
+
+// ── SCSITaskDeviceInterface vtable ──────────────────────────────────────────
+//
+// Index  Method
+//   0    _reserved
+//   1    QueryInterface
+//   2    AddRef
+//   3    Release
+//   4    IsExclusiveAccessAvailable
+//   5    AddCallbackDispatcherToRunLoop
+//   6    RemoveCallbackDispatcherFromRunLoop
+//   7    ObtainExclusiveAccess
+//   8    ReleaseExclusiveAccess
+//   9    CreateSCSITask
+
+const VTIDX_OBTAIN_EXCLUSIVE: usize = 7;
+const VTIDX_RELEASE_EXCLUSIVE: usize = 8;
+const VTIDX_CREATE_TASK: usize = 9;
+
+// ── SCSITaskInterface vtable ────────────────────────────────────────────────
+//
+// Index  Method
+//   0    _reserved
+//   1    QueryInterface
+//   2    AddRef
+//   3    Release
+//   4    IsTaskActive
+//   5    SetTaskAttribute
+//   6    GetTaskAttribute
+//   7    GetTaskState
+//   8    SetCommandDescriptorBlock
+//   9    GetCommandDescriptorBlockSize
+//  10    GetCommandDescriptorBlock
+//  11    SetScatterGatherEntries
+//  12    SetTimeoutDuration
+//  13    GetTimeoutDuration
+//  14    SetTaskCompletionCallback
+//  15    ExecuteTaskSync
+//  16    ExecuteTaskAsync
+//  17    AbortTask
+//  18    GetSCSIServiceResponse
+//  19    GetTaskStatus
+//  20    GetRealizedDataTransferCount
+//  21    GetAutoSenseData
+
+const VTIDX_SET_CDB: usize = 8;
+const VTIDX_SET_SG: usize = 11;
+const VTIDX_SET_TIMEOUT: usize = 12;
+const VTIDX_EXECUTE_SYNC: usize = 15;
+
+// ── Transport implementation ────────────────────────────────────────────────
+
+pub struct MacScsiTransport {
+    device_iface: ComRef,
+    exclusive: bool,
+}
+
+impl MacScsiTransport {
+    pub fn open(device: &Path) -> Result<Self> {
+        let dev_str = device.to_str().ok_or_else(|| Error::DeviceNotFound {
+            path: device.display().to_string(),
+        })?;
+
+        // Strip /dev/ prefix to get BSD name (e.g. "disk2")
+        let bsd_name = if let Some(rest) = dev_str.strip_prefix("/dev/r") {
+            rest
+        } else if let Some(rest) = dev_str.strip_prefix("/dev/") {
+            rest
+        } else {
+            dev_str
+        };
+
+        let service = find_scsi_service(bsd_name)?;
+
+        // Create IOKit plugin for the MMC device
+        let mut plugin: ComRef = std::ptr::null_mut();
+        let mut score: i32 = 0;
+        let kr = unsafe {
+            IOCreatePlugInInterfaceForService(
+                service,
+                &K_IO_MMC_DEVICE_USER_CLIENT_TYPE_ID,
+                &K_IO_CFPLUGIN_INTERFACE_ID,
+                &mut plugin,
+                &mut score,
+            )
+        };
+        unsafe { IOObjectRelease(service) };
+
+        if kr != K_IO_RETURN_SUCCESS || plugin.is_null() {
+            return Err(Error::DeviceNotFound {
+                path: format!("{}: IOKit plugin creation failed (0x{:08x})", dev_str, kr),
+            });
+        }
+
+        // QueryInterface for SCSITaskDeviceInterface
+        let mut device_iface: ComRef = std::ptr::null_mut();
+        let hr = unsafe {
+            type QiFn = unsafe extern "C" fn(ComRef, *const [u8; 16], *mut ComRef) -> i32;
+            let qi: QiFn = vtable_fn(plugin, 1);
+            qi(plugin, &K_IO_SCSI_TASK_DEVICE_INTERFACE_ID, &mut device_iface)
+        };
+        com_release(plugin);
+
+        if hr != 0 || device_iface.is_null() {
+            return Err(Error::DeviceNotFound {
+                path: format!("{}: SCSITaskDeviceInterface not available", dev_str),
+            });
+        }
+
+        // Obtain exclusive access
+        let kr = unsafe {
+            type Fn = unsafe extern "C" fn(ComRef) -> IOReturn;
+            let f: Fn = vtable_fn(device_iface, VTIDX_OBTAIN_EXCLUSIVE);
+            f(device_iface)
+        };
+        if kr != K_IO_RETURN_SUCCESS {
+            com_release(device_iface);
+            return Err(Error::DevicePermission {
+                path: format!(
+                    "{}: exclusive access denied (0x{:08x}). Try: diskutil unmountDisk {}",
+                    dev_str, kr, dev_str
+                ),
+            });
+        }
+
+        Ok(MacScsiTransport {
+            device_iface,
+            exclusive: true,
+        })
+    }
+}
+
+impl Drop for MacScsiTransport {
+    fn drop(&mut self) {
+        if self.exclusive {
+            unsafe {
+                type Fn = unsafe extern "C" fn(ComRef) -> IOReturn;
+                let f: Fn = vtable_fn(self.device_iface, VTIDX_RELEASE_EXCLUSIVE);
+                f(self.device_iface);
+            }
+        }
+        com_release(self.device_iface);
+    }
+}
+
+impl ScsiTransport for MacScsiTransport {
+    fn execute(
+        &mut self,
+        cdb: &[u8],
+        direction: DataDirection,
+        data: &mut [u8],
+        timeout_ms: u32,
+    ) -> Result<ScsiResult> {
+        // Create a SCSI task
+        let task: ComRef = unsafe {
+            type Fn = unsafe extern "C" fn(ComRef) -> ComRef;
+            let f: Fn = vtable_fn(self.device_iface, VTIDX_CREATE_TASK);
+            f(self.device_iface)
+        };
+        if task.is_null() {
+            return Err(Error::ScsiError {
+                opcode: cdb[0],
+                status: 0xFF,
+                sense_key: 0,
+            });
+        }
+
+        // Set CDB
+        let mut cdb_padded = [0u8; K_MAX_CDB_SIZE];
+        let cdb_len = cdb.len().min(K_MAX_CDB_SIZE);
+        cdb_padded[..cdb_len].copy_from_slice(&cdb[..cdb_len]);
+        unsafe {
+            type Fn = unsafe extern "C" fn(ComRef, *const u8, u8) -> IOReturn;
+            let f: Fn = vtable_fn(task, VTIDX_SET_CDB);
+            f(task, cdb_padded.as_ptr(), cdb_len as u8);
+        }
+
+        // Set scatter/gather and transfer direction
+        let iokit_dir = match direction {
+            DataDirection::None => K_SCSI_DATA_TRANSFER_NO_DATA,
+            DataDirection::FromDevice => K_SCSI_DATA_TRANSFER_FROM_TARGET,
+            DataDirection::ToDevice => K_SCSI_DATA_TRANSFER_TO_TARGET,
+        };
+
+        if direction != DataDirection::None && !data.is_empty() {
+            let sg = SCSITaskSGElement {
+                address: data.as_mut_ptr() as u64,
+                length: data.len() as u64,
+            };
+            unsafe {
+                type Fn = unsafe extern "C" fn(
+                    ComRef, *const SCSITaskSGElement, u8, u64, u8,
+                ) -> IOReturn;
+                let f: Fn = vtable_fn(task, VTIDX_SET_SG);
+                f(task, &sg, 1, data.len() as u64, iokit_dir);
+            }
+        } else {
+            unsafe {
+                type Fn = unsafe extern "C" fn(
+                    ComRef, *const SCSITaskSGElement, u8, u64, u8,
+                ) -> IOReturn;
+                let f: Fn = vtable_fn(task, VTIDX_SET_SG);
+                f(task, std::ptr::null(), 0, 0, K_SCSI_DATA_TRANSFER_NO_DATA);
+            }
+        }
+
+        // Set timeout (IOKit SCSITask takes milliseconds)
+        unsafe {
+            type Fn = unsafe extern "C" fn(ComRef, u32);
+            let f: Fn = vtable_fn(task, VTIDX_SET_TIMEOUT);
+            f(task, timeout_ms);
+        }
+
+        // Execute synchronously
+        let mut sense = [0u8; K_SENSE_DATA_SIZE];
+        let mut task_status: u8 = 0;
+        let mut realized_count: u64 = 0;
+
+        let kr = unsafe {
+            type Fn = unsafe extern "C" fn(
+                ComRef, *mut u8, *mut u8, *mut u64,
+            ) -> IOReturn;
+            let f: Fn = vtable_fn(task, VTIDX_EXECUTE_SYNC);
+            f(task, sense.as_mut_ptr(), &mut task_status, &mut realized_count)
+        };
+
+        com_release(task);
+
+        if kr != K_IO_RETURN_SUCCESS {
+            return Err(Error::ScsiError {
+                opcode: cdb[0],
+                status: 0xFF,
+                sense_key: 0,
+            });
+        }
+
+        if task_status != K_SCSI_TASK_STATUS_GOOD {
+            let sense_key = if sense[2] != 0 { sense[2] & 0x0F } else { 0 };
+            return Err(Error::ScsiError {
+                opcode: cdb[0],
+                status: task_status,
+                sense_key,
+            });
+        }
+
+        Ok(ScsiResult {
+            status: task_status,
+            bytes_transferred: realized_count as usize,
+            sense,
+        })
+    }
+}
+
+// ── IOKit service discovery ─────────────────────────────────────────────────
+
+/// BSD name → IOKit service for the SCSI device.
+///
+/// Walk: IOMedia (BSD name match) → parent chain → SCSIPeripheralDeviceNub.
+fn find_scsi_service(bsd_name: &str) -> Result<IOObject> {
+    let mut master: MachPort = 0;
+    let kr = unsafe { IOMasterPort(0, &mut master) };
+    if kr != K_IO_RETURN_SUCCESS {
+        return Err(Error::DeviceNotFound {
+            path: format!("{}: IOMasterPort failed", bsd_name),
+        });
+    }
+
+    // IOBSDNameMatching creates a dictionary matching { "BSD Name" = bsd_name }
+    let mut bsd_c = bsd_name.as_bytes().to_vec();
+    bsd_c.push(0);
+    let matching = unsafe { IOBSDNameMatching(master, 0, bsd_c.as_ptr()) };
+    if matching.is_null() {
+        return Err(Error::DeviceNotFound {
+            path: format!("{}: IOBSDNameMatching failed", bsd_name),
+        });
+    }
+
+    // Find the single IOMedia service (consumes the matching dict)
+    let media = unsafe { IOServiceGetMatchingService(master, matching) };
+    if media == 0 {
+        return Err(Error::DeviceNotFound {
+            path: format!("{}: no IOMedia found", bsd_name),
+        });
+    }
+
+    // Walk up the IOService plane to find the authoring device.
+    // The chain is typically:
+    //   IOMedia → IOPartitionScheme → IOMedia → IOBlockStorageDriver
+    //   → IOSCSIPeripheralDeviceNub (this is what we want)
+    //
+    // We walk up until we find a service that IOCreatePlugInInterfaceForService
+    // accepts with kIOMMCDeviceUserClientTypeID, or until we hit the root.
+    let service = walk_to_authoring_device(media);
+    unsafe { IOObjectRelease(media) };
+
+    service.ok_or_else(|| Error::DeviceNotFound {
+        path: format!("{}: no SCSI authoring device in IORegistry", bsd_name),
+    })
+}
+
+/// Walk up the IOService plane from an IOMedia to the SCSI authoring device.
+fn walk_to_authoring_device(start: IOObject) -> Option<IOObject> {
+    let mut current = start;
+    // Retain start so we can release uniformly in the loop
+    // (IORegistryEntryGetParentEntry retains the parent for us)
+
+    // Target class names for authoring devices
+    let target_classes: &[&[u8]] = &[
+        b"IOSCSIPeripheralDeviceNub\0",
+        b"IOBDBlockStorageDevice\0",
+        b"IODVDBlockStorageDevice\0",
+        b"IOCDBlockStorageDevice\0",
+        b"IOBlockStorageDevice\0",
+    ];
+
+    // Walk up to 10 levels (more than enough)
+    for _ in 0..10 {
+        let mut parent: IOObject = 0;
+        let kr = unsafe {
+            IORegistryEntryGetParentEntry(current, b"IOService\0".as_ptr(), &mut parent)
+        };
+
+        if current != start {
+            unsafe { IOObjectRelease(current) };
+        }
+
+        if kr != K_IO_RETURN_SUCCESS || parent == 0 {
+            return None;
+        }
+
+        // Check if this parent matches any of our target classes
+        for class in target_classes {
+            if unsafe { IOObjectConformsTo(parent, class.as_ptr()) } != 0 {
+                return Some(parent);
+            }
+        }
+
+        current = parent;
+    }
+
+    if current != start {
+        unsafe { IOObjectRelease(current) };
+    }
+    None
+}

src/scsi/mod.rs

@@ -0,0 +1,141 @@
+//! SCSI/MMC command interface.
+//!
+//! Platform backends are in separate files:
+//!   - `linux.rs` — SG_IO ioctl
+//!   - `macos.rs` — IOKit SCSITaskDeviceInterface
+//!   - `windows.rs` — SPTI (planned)
+
+#[cfg(target_os = "linux")]
+mod linux;
+#[cfg(target_os = "macos")]
+mod macos;
+
+#[allow(unused_imports)]
+use crate::error::{Error, Result};
+use std::path::Path;
+
+// ── SCSI opcodes (SPC-4, MMC-6) ────────────────────────────────────────────
+
+pub const SCSI_INQUIRY: u8             = 0x12;
+pub const SCSI_READ_CAPACITY: u8       = 0x25;
+pub const SCSI_READ_10: u8             = 0x28;
+pub const SCSI_READ_BUFFER: u8         = 0x3C;
+pub const SCSI_READ_TOC: u8            = 0x43;
+pub const SCSI_GET_CONFIGURATION: u8   = 0x46;
+pub const SCSI_SET_CD_SPEED: u8        = 0xBB;
+pub const SCSI_SEND_KEY: u8            = 0xA3;
+pub const SCSI_REPORT_KEY: u8          = 0xA4;
+pub const SCSI_READ_12: u8             = 0xA8;
+pub const SCSI_READ_DISC_STRUCTURE: u8 = 0xAD;
+
+/// AACS key class for REPORT KEY / SEND KEY commands.
+pub const AACS_KEY_CLASS: u8 = 0x02;
+
+// ── Types ───────────────────────────────────────────────────────────────────
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum DataDirection {
+    None,
+    FromDevice,
+    ToDevice,
+}
+
+#[derive(Debug)]
+pub struct ScsiResult {
+    pub status: u8,
+    pub bytes_transferred: usize,
+    pub sense: [u8; 32],
+}
+
+/// Low-level SCSI transport — one implementation per platform.
+pub trait ScsiTransport {
+    fn execute(
+        &mut self,
+        cdb: &[u8],
+        direction: DataDirection,
+        data: &mut [u8],
+        timeout_ms: u32,
+    ) -> Result<ScsiResult>;
+}
+
+// ── Platform-agnostic open ──────────────────────────────────────────────────
+
+/// Open a SCSI transport for the given device path.
+/// Selects the right backend for the current platform.
+pub fn open(device: &Path) -> Result<Box<dyn ScsiTransport>> {
+    #[cfg(target_os = "linux")]
+    { Ok(Box::new(linux::SgIoTransport::open(device)?)) }
+
+    #[cfg(target_os = "macos")]
+    { Ok(Box::new(macos::MacScsiTransport::open(device)?)) }
+
+    #[cfg(target_os = "windows")]
+    { Err(Error::DeviceNotFound { path: format!("{}: Windows not yet supported", device.display()) }) }
+
+    #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
+    { Err(Error::DeviceNotFound { path: format!("{}: unsupported platform", device.display()) }) }
+}
+
+// ── CDB builders (platform-agnostic) ────────────────────────────────────────
+
+/// SCSI INQUIRY response.
+#[derive(Debug, Clone)]
+pub struct InquiryResult {
+    pub vendor_id: String,
+    pub model: String,
+    pub firmware: String,
+    pub raw: Vec<u8>,
+}
+
+/// Send INQUIRY and parse standard response fields.
+pub fn inquiry(scsi: &mut dyn ScsiTransport) -> Result<InquiryResult> {
+    let cdb = [SCSI_INQUIRY, 0x00, 0x00, 0x00, 0x60, 0x00];
+    let mut buf = [0u8; 96];
+    scsi.execute(&cdb, DataDirection::FromDevice, &mut buf, 5_000)?;
+
+    Ok(InquiryResult {
+        vendor_id: String::from_utf8_lossy(&buf[8..16]).trim().to_string(),
+        model: String::from_utf8_lossy(&buf[16..32]).trim().to_string(),
+        firmware: String::from_utf8_lossy(&buf[32..36]).trim().to_string(),
+        raw: buf.to_vec(),
+    })
+}
+
+/// Send GET CONFIGURATION for feature 0x010C (Firmware Information).
+pub fn get_config_010c(scsi: &mut dyn ScsiTransport) -> Result<Vec<u8>> {
+    let cdb = [SCSI_GET_CONFIGURATION, 0x02, 0x01, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00];
+    let mut buf = [0u8; 16];
+    scsi.execute(&cdb, DataDirection::FromDevice, &mut buf, 5_000)?;
+    Ok(buf.to_vec())
+}
+
+/// Build a READ BUFFER CDB.
+pub fn build_read_buffer(mode: u8, buffer_id: u8, offset: u32, length: u32) -> [u8; 10] {
+    [
+        SCSI_READ_BUFFER, mode, buffer_id,
+        (offset >> 16) as u8, (offset >> 8) as u8, offset as u8,
+        (length >> 16) as u8, (length >> 8) as u8, length as u8,
+        0x00,
+    ]
+}
+
+/// Build a SET CD SPEED CDB.
+pub fn build_set_cd_speed(read_speed: u16) -> [u8; 12] {
+    [
+        SCSI_SET_CD_SPEED, 0x00,
+        (read_speed >> 8) as u8, read_speed as u8,
+        0xFF, 0xFF,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    ]
+}
+
+/// Build a READ(10) CDB with the raw read flag.
+pub fn build_read10_raw(lba: u32, count: u16) -> [u8; 10] {
+    [
+        SCSI_READ_10, 0x08,
+        (lba >> 24) as u8, (lba >> 16) as u8, (lba >> 8) as u8, lba as u8,
+        0x00,
+        (count >> 8) as u8, count as u8,
+        0x00,
+    ]
+}

src/speed.rs

@@ -65,9 +65,7 @@ impl DriveSpeed {
             22_001..=31_000   => DriveSpeed::BD6x,
             31_001..=40_000   => DriveSpeed::BD8x,
             40_001..=49_000   => DriveSpeed::BD10x,
-            49_001..=0xFFFE   => DriveSpeed::BD12x,
-            0xFFFF            => DriveSpeed::Max,
-            _                 => DriveSpeed::Max,
+            49_001..=u16::MAX => DriveSpeed::BD12x,
         }
     }
 

src/udf.rs

@@ -0,0 +1,464 @@
+//! UDF filesystem reader — read files from Blu-ray discs.
+//!
+//! Blu-ray discs use UDF 2.50 with metadata partitions.
+//! The read sequence follows pointers through the disc structure:
+//!
+//!   Sector 256 (AVDP)
+//!     → VDS (Partition Descriptor + Logical Volume Descriptor)
+//!       → Metadata Partition (virtual partition stored as a file)
+//!         → File Set Descriptor (FSD)
+//!           → Root Directory ICB
+//!             → Directory data (File Identifier Descriptors)
+//!               → BDMV/PLAYLIST/*.mpls, BDMV/CLIPINF/*.clpi
+//!
+//! Each step reads one or two sectors. No bulk reads needed.
+//!
+//! References:
+//!   ECMA-167 (UDF base)
+//!   UDF 2.50 (OSTA) — metadata partition extension
+//!   BD-ROM Part 3 — Blu-ray filesystem profile
+
+use crate::error::{Error, Result};
+use crate::drive::DriveSession;
+
+/// A UDF filesystem parsed from disc.
+#[derive(Debug)]
+pub struct UdfFs {
+    /// Root directory with full tree
+    pub root: DirEntry,
+    /// 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,
+}
+
+/// A directory or file entry.
+#[derive(Debug, Clone)]
+pub struct DirEntry {
+    pub name: String,
+    pub is_dir: bool,
+    /// LBA within the metadata partition (add metadata_start for absolute)
+    pub meta_lba: u32,
+    /// File size in bytes (from ICB info_length)
+    pub size: u64,
+    /// Child entries (if directory)
+    pub entries: Vec<DirEntry>,
+}
+
+impl UdfFs {
+    /// Find a directory by path (e.g. "/BDMV/PLAYLIST").
+    /// Path matching is case-insensitive.
+    pub fn find_dir(&self, path: &str) -> Option<&DirEntry> {
+        let parts: Vec<&str> = path.trim_matches('/').split('/').collect();
+        let mut current = &self.root;
+        for part in &parts {
+            current = current.entries.iter().find(|e| {
+                e.is_dir && e.name.eq_ignore_ascii_case(part)
+            })?;
+        }
+        Some(current)
+    }
+
+    /// Read a file by path, returning its raw bytes.
+    /// Reads sector by sector from disc — no buffering.
+    pub fn read_file(&self, session: &mut DriveSession, path: &str) -> Result<Vec<u8>> {
+        let parts: Vec<&str> = path.trim_matches('/').split('/').collect();
+        let mut current = &self.root;
+
+        // Navigate to parent directory
+        for part in &parts[..parts.len() - 1] {
+            current = current.entries.iter().find(|e| {
+                e.is_dir && e.name.eq_ignore_ascii_case(part)
+            }).ok_or_else(|| Error::DiscError {
+                detail: format!("directory not found: {}", part),
+            })?;
+        }
+
+        // Find the file
+        let filename = parts.last().unwrap();
+        let entry = current.entries.iter().find(|e| {
+            !e.is_dir && e.name.eq_ignore_ascii_case(filename)
+        }).ok_or_else(|| Error::DiscError {
+            detail: format!("file not found: {}", path),
+        })?;
+
+        // Read the file's ICB to get its data extent
+        let (data_lba, data_len) = self.read_icb_extent(session, entry.meta_lba)?;
+
+        // Read file data sector by sector
+        // File DATA is in the physical partition (partition_start + lba),
+        // NOT the metadata partition. ICBs are in metadata, data is in physical.
+        let sector_count = ((data_len as u64 + 2047) / 2048) as u32;
+        let mut data = vec![0u8; (sector_count as usize) * 2048];
+        let abs_start = self.partition_start + data_lba;
+
+        for i in 0..sector_count {
+            let offset = (i as usize) * 2048;
+            read_sector(session, abs_start + i, &mut data[offset..offset + 2048])?;
+        }
+
+        data.truncate(entry.size as usize);
+        Ok(data)
+    }
+
+    /// 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
+    }
+
+    /// Read an Extended File Entry (tag 266) or File Entry (tag 261)
+    /// and return its first allocation extent: (data_lba, data_length).
+    /// The data_lba is metadata-relative.
+    fn read_icb_extent(&self, session: &mut DriveSession, meta_lba: u32) -> Result<(u32, u32)> {
+        let mut icb = [0u8; 2048];
+        read_sector(session, self.meta_to_abs(meta_lba), &mut icb)?;
+
+        let tag = u16::from_le_bytes([icb[0], icb[1]]);
+
+        // Get allocation descriptor offset based on ICB type
+        let ad_offset = match tag {
+            // Extended File Entry (UDF 2.50, used by BD-ROM)
+            // Layout: ... L_EA at [208:212], L_AD at [212:216], alloc descs at 216 + L_EA
+            266 => {
+                let l_ea = u32::from_le_bytes([icb[208], icb[209], icb[210], icb[211]]) as usize;
+                216 + l_ea
+            }
+            // Standard File Entry
+            // Layout: ... L_EA at [168:172], L_AD at [172:176], alloc descs at 176 + L_EA
+            261 => {
+                let l_ea = u32::from_le_bytes([icb[168], icb[169], icb[170], icb[171]]) as usize;
+                176 + l_ea
+            }
+            _ => return Err(Error::DiscError {
+                detail: format!("unexpected ICB tag {} at meta_lba {}", tag, meta_lba),
+            }),
+        };
+
+        if ad_offset + 8 > 2048 {
+            return Err(Error::DiscError { detail: "ICB alloc desc out of range".into() });
+        }
+
+        // Short Allocation Descriptor: extent_length(4) + extent_position(4)
+        // extent_length upper 2 bits = type (0=recorded, 1=allocated not recorded, 3=next extent)
+        let raw_len = u32::from_le_bytes([icb[ad_offset], icb[ad_offset + 1],
+                                          icb[ad_offset + 2], icb[ad_offset + 3]]);
+        let data_len = raw_len & 0x3FFFFFFF;
+        let data_lba = u32::from_le_bytes([icb[ad_offset + 4], icb[ad_offset + 5],
+                                           icb[ad_offset + 6], icb[ad_offset + 7]]);
+
+        Ok((data_lba, data_len))
+    }
+}
+
+/// Read the UDF filesystem from a Blu-ray disc.
+///
+/// Follows the UDF pointer chain:
+/// 1. AVDP (sector 256) → VDS location
+/// 2. VDS → Partition Descriptor (physical partition start)
+///        → Logical Volume Descriptor (FSD location + partition maps)
+/// 3. Metadata partition file → metadata content location
+/// 4. FSD → root directory ICB
+/// 5. Root directory → file tree
+pub fn read_filesystem(session: &mut DriveSession) -> Result<UdfFs> {
+    // Step 1: Anchor Volume Descriptor Pointer at sector 256
+    // ECMA-167 §10.2 — always at sector 256
+    let mut avdp = [0u8; 2048];
+    read_sector(session, 256, &mut avdp)?;
+
+    let tag_id = u16::from_le_bytes([avdp[0], avdp[1]]);
+    if tag_id != 2 {
+        return Err(Error::DiscError {
+            detail: format!("AVDP: expected tag 2, got {} at sector 256", tag_id),
+        });
+    }
+
+    // Main VDS extent location: bytes [16:20] = LBA, [20:24] = length
+    // (We use the VDS at sectors 32+, not the reserve copy at sector 32768+)
+
+    // Step 2: Read Volume Descriptor Sequence (sectors 32-37 typically)
+    // Find Partition Descriptor (tag 5) and Logical Volume Descriptor (tag 6)
+    let mut partition_start: u32 = 0;
+    let mut num_partition_maps: u32 = 0;
+    let mut lvd_sector: Option<u32> = None;
+
+    for i in 32..64 {
+        let mut desc = [0u8; 2048];
+        read_sector(session, i, &mut desc)?;
+
+        let desc_tag = u16::from_le_bytes([desc[0], desc[1]]);
+        match desc_tag {
+            // Partition Descriptor — tells us where the physical partition starts
+            5 => {
+                partition_start = u32::from_le_bytes([desc[188], desc[189], desc[190], desc[191]]);
+            }
+            // Logical Volume Descriptor — contains FSD location and partition maps
+            6 => {
+                num_partition_maps = u32::from_le_bytes([desc[268], desc[269], desc[270], desc[271]]);
+                lvd_sector = Some(i);
+            }
+            // Terminating Descriptor — end of VDS
+            8 => break,
+            _ => continue,
+        }
+    }
+
+    if partition_start == 0 {
+        return Err(Error::DiscError { detail: "UDF: no Partition Descriptor found".into() });
+    }
+
+    // Step 3: Parse partition maps from LVD to find metadata partition
+    // BD-ROM discs (UDF 2.50) use a metadata partition (Type 2 map with "*UDF Metadata Partition")
+    // The metadata file is stored at lba=0 of the physical partition
+    let metadata_start = if num_partition_maps >= 2 {
+        let lvd_sec = lvd_sector.ok_or_else(|| Error::DiscError {
+            detail: "UDF: no LVD found".into(),
+        })?;
+
+        // Read LVD to check partition map type
+        let mut lvd = [0u8; 2048];
+        read_sector(session, lvd_sec, &mut lvd)?;
+
+        // Parse partition maps starting at offset 440
+        // Map 0 = Type 1 (physical), Map 1 = Type 2 (metadata)
+        let _pm1_type = lvd[440]; // First map type
+        let pm1_len = lvd[441] as usize;
+
+        if pm1_len > 0 && 440 + pm1_len < 2048 {
+            let pm2_type = lvd[440 + pm1_len]; // Second map type
+
+            if pm2_type == 2 {
+                // Type 2 = metadata partition
+                // The metadata file ICB is at physical partition lba 0
+                // Read it to find where the metadata content starts
+                let meta_file_lba = partition_start; // lba 0 of partition
+                let mut meta_icb = [0u8; 2048];
+                read_sector(session, meta_file_lba, &mut meta_icb)?;
+
+                let meta_tag = u16::from_le_bytes([meta_icb[0], meta_icb[1]]);
+                if meta_tag == 266 {
+                    // Extended File Entry — get allocation extent
+                    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],
+                                                      meta_icb[ad_off + 2], meta_icb[ad_off + 3]]) & 0x3FFFFFFF;
+                    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
+                    partition_start + ad_pos
+                } else {
+                    // Fallback: no metadata partition, use physical partition directly
+                    partition_start
+                }
+            } else {
+                partition_start
+            }
+        } else {
+            partition_start
+        }
+    } else {
+        // Single partition map — no metadata partition (older UDF)
+        partition_start
+    };
+
+    // Step 4: Read File Set Descriptor from metadata partition
+    // FSD is at metadata-relative lba 0 (first sector of metadata content)
+    let mut fsd = [0u8; 2048];
+    read_sector(session, metadata_start, &mut fsd)?;
+
+    let fsd_tag = u16::from_le_bytes([fsd[0], fsd[1]]);
+    if fsd_tag != 256 {
+        return Err(Error::DiscError {
+            detail: format!("FSD: expected tag 256, got {} at sector {}", fsd_tag, metadata_start),
+        });
+    }
+
+    // Root Directory ICB: long_ad at FSD offset 400
+    // long_ad = extent_length(4) + extent_location: lba(4) + part_ref(2) + impl_use(6)
+    let root_lba = u32::from_le_bytes([fsd[404], fsd[405], fsd[406], fsd[407]]);
+
+    // Step 5: Read root directory and build file tree
+    let root = read_directory(session, partition_start, metadata_start, root_lba, "", 0)?;
+
+    Ok(UdfFs {
+        root,
+        partition_start,
+        metadata_start,
+    })
+}
+
+/// Read a UDF directory and its children (up to max_depth levels).
+///
+/// Each directory is an ICB (Extended File Entry) pointing to directory data
+/// containing File Identifier Descriptors (FIDs). Each FID names a file/subdir
+/// and points to its ICB.
+fn read_directory(
+    session: &mut DriveSession,
+    part_start: u32,
+    meta_start: u32,
+    meta_lba: u32,
+    name: &str,
+    depth: u32,
+) -> Result<DirEntry> {
+    // Read ICB for this directory
+    let mut icb = [0u8; 2048];
+    read_sector(session, meta_start + meta_lba, &mut icb)?;
+
+    let tag = u16::from_le_bytes([icb[0], icb[1]]);
+
+    // Get allocation extent: where the directory data lives
+    let (ad_len, ad_pos) = match tag {
+        266 => {
+            let l_ea = u32::from_le_bytes([icb[208], icb[209], icb[210], icb[211]]) as usize;
+            let ad_off = 216 + l_ea;
+            let len = u32::from_le_bytes([icb[ad_off], icb[ad_off + 1],
+                                          icb[ad_off + 2], icb[ad_off + 3]]) & 0x3FFFFFFF;
+            let pos = u32::from_le_bytes([icb[ad_off + 4], icb[ad_off + 5],
+                                          icb[ad_off + 6], icb[ad_off + 7]]);
+            (len, pos)
+        }
+        261 => {
+            let l_ea = u32::from_le_bytes([icb[168], icb[169], icb[170], icb[171]]) as usize;
+            let ad_off = 176 + l_ea;
+            let len = u32::from_le_bytes([icb[ad_off], icb[ad_off + 1],
+                                          icb[ad_off + 2], icb[ad_off + 3]]) & 0x3FFFFFFF;
+            let pos = u32::from_le_bytes([icb[ad_off + 4], icb[ad_off + 5],
+                                          icb[ad_off + 6], icb[ad_off + 7]]);
+            (len, pos)
+        }
+        _ => {
+            return Ok(DirEntry {
+                name: name.to_string(), is_dir: true, meta_lba, size: 0, entries: Vec::new(),
+            });
+        }
+    };
+
+    // Read directory data
+    let dir_abs = meta_start + ad_pos;
+    let sector_count = ((ad_len + 2047) / 2048).min(64);
+    let mut dir_data = vec![0u8; sector_count as usize * 2048];
+    for i in 0..sector_count {
+        read_sector(session, dir_abs + i,
+                   &mut dir_data[(i as usize) * 2048..(i as usize + 1) * 2048])?;
+    }
+
+    // Parse File Identifier Descriptors
+    let mut entries = Vec::new();
+    let mut pos = 0;
+
+    while pos + 38 < dir_data.len().min(ad_len as usize) {
+        let fid_tag = u16::from_le_bytes([dir_data[pos], dir_data[pos + 1]]);
+        if fid_tag != 257 {
+            break;
+        }
+
+        let file_chars = dir_data[pos + 18];
+        let l_fi = dir_data[pos + 19] as usize;
+
+        // FID ICB is a long_ad starting at offset 20:
+        //   [20:24] = extent_length
+        //   [24:28] = extent_location (LBA within metadata partition)
+        //   [28:30] = partition_reference_number
+        //   [30:36] = implementation_use
+        let icb_lba = u32::from_le_bytes([dir_data[pos + 24], dir_data[pos + 25],
+                                          dir_data[pos + 26], dir_data[pos + 27]]);
+        let l_iu = u16::from_le_bytes([dir_data[pos + 36], dir_data[pos + 37]]) as usize;
+
+        let is_dir = (file_chars & 0x02) != 0;
+        let is_parent = (file_chars & 0x08) != 0;
+
+        if !is_parent && l_fi > 0 {
+            let name_start = pos + 38 + l_iu;
+            let entry_name = parse_udf_name(&dir_data[name_start..name_start + l_fi]);
+
+            if !entry_name.is_empty() {
+                // Read the ICB to get file size
+                let file_size = read_file_size(session, meta_start, icb_lba).unwrap_or(0);
+
+                if is_dir && depth < 3 {
+                    // Recurse into subdirectory (max 3 levels: BDMV/PLAYLIST/*.mpls)
+                    let subdir = read_directory(session, part_start, meta_start, icb_lba, &entry_name, depth + 1)?;
+                    entries.push(subdir);
+                } else {
+                    entries.push(DirEntry {
+                        name: entry_name,
+                        is_dir,
+                        meta_lba: icb_lba,
+                        size: file_size,
+                        entries: Vec::new(),
+                    });
+                }
+            }
+        }
+
+        // Advance to next FID (4-byte aligned)
+        let fid_len = ((38 + l_iu + l_fi + 3) & !3) as usize;
+        pos += fid_len;
+    }
+
+    Ok(DirEntry {
+        name: name.to_string(),
+        is_dir: true,
+        meta_lba,
+        size: ad_len as u64,
+        entries,
+    })
+}
+
+/// Read file size (info_length) from an Extended File Entry ICB.
+fn read_file_size(session: &mut DriveSession, meta_start: u32, meta_lba: u32) -> Result<u64> {
+    let mut icb = [0u8; 2048];
+    read_sector(session, meta_start + meta_lba, &mut icb)?;
+
+    let tag = u16::from_le_bytes([icb[0], icb[1]]);
+    match tag {
+        // Both File Entry (261) and Extended File Entry (266) have
+        // info_length as a u64 at offset 56
+        261 | 266 => {
+            Ok(u64::from_le_bytes([icb[56], icb[57], icb[58], icb[59],
+                                   icb[60], icb[61], icb[62], icb[63]]))
+        }
+        _ => Ok(0),
+    }
+}
+
+/// Parse a UDF filename from raw bytes.
+///
+/// UDF uses a compression ID as the first byte:
+///   8  = 8-bit characters (ASCII)
+///   16 = 16-bit big-endian Unicode (UTF-16BE)
+fn parse_udf_name(data: &[u8]) -> String {
+    if data.is_empty() {
+        return String::new();
+    }
+
+    match data[0] {
+        8 => {
+            // 8-bit ASCII
+            String::from_utf8_lossy(&data[1..]).trim().to_string()
+        }
+        16 => {
+            // 16-bit big-endian Unicode
+            let mut s = String::new();
+            let chars = &data[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 let Some(ch) = char::from_u32(c as u32) {
+                        s.push(ch);
+                    }
+                }
+            }
+            s.trim().to_string()
+        }
+        _ => String::from_utf8_lossy(&data[1..]).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<()> {
+    session.read_disc(lba, 1, buf)?;
+    Ok(())
+}