pq/libfreemkv
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Buffer UDF sector reads — eliminates scan hang on USB drives

Browse Source
This commit is contained in:
Matt Jackson
2026-04-17 18:24:29 +00:00
parent bc62cb35f4
commit c6b08381ce
3 changed files with 160 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/disc/bluray.rs
+22
View File
@@ -12,8 +12,19 @@ impl Disc {
reader: &mut dyn SectorReader,
udf_fs: &udf::UdfFs,
) -> Vec<DiscTitle> {
let t0 = std::time::Instant::now();
let mut titles = Vec::new();
if let Some(playlist_dir) = udf_fs.find_dir("/BDMV/PLAYLIST") {
let mpls_count = playlist_dir
.entries
.iter()
.filter(|e| !e.is_dir && e.name.to_lowercase().ends_with(".mpls"))
.count();
eprintln!(
"[titles {:.1}s] {} MPLS files",
t0.elapsed().as_secs_f64(),
mpls_count
);
for entry in &playlist_dir.entries {
if !entry.is_dir && entry.name.to_lowercase().ends_with(".mpls") {
let path = format!("/BDMV/PLAYLIST/{}", entry.name);
@@ -21,12 +32,23 @@ impl Disc {
if let Some(title) =
Self::parse_playlist(reader, udf_fs, &entry.name, &mpls_data)
{
eprintln!(
"[titles {:.1}s] {} -> title ({:.0}s)",
t0.elapsed().as_secs_f64(),
entry.name,
title.duration_secs
);
titles.push(title);
}
}
}
}
}
eprintln!(
"[titles {:.1}s] done: {} titles",
t0.elapsed().as_secs_f64(),
titles.len()
);
titles
}
src/disc/mod.rs
+43 -4
View File
@@ -940,17 +940,37 @@ impl Disc {
/// The session must be open and unlocked (Drive::open handles this).
/// All disc reads use standard READ(10) via UDF -- no vendor SCSI commands.
pub fn scan(session: &mut Drive, opts: &ScanOptions) -> Result<Self> {
let t0 = std::time::Instant::now();
// READ CAPACITY may fail in LibreDrive mode — proceed with 0 and estimate later
let capacity = Self::read_capacity(session).unwrap_or(0);
eprintln!(
"[scan {:.1}s] capacity={}",
t0.elapsed().as_secs_f64(),
capacity
);
// AACS handshake (Blu-ray/UHD)
let handshake = Self::do_handshake(session, opts);
eprintln!("[scan {:.1}s] handshake done", t0.elapsed().as_secs_f64());
// Request max read speed — removes riplock on DVD
// (BD/UHD speed is set by firmware init, but DVD needs explicit SET CD SPEED)
session.set_speed(0xFFFF);
eprintln!("[scan {:.1}s] speed set", t0.elapsed().as_secs_f64());
let mut disc = Self::scan_with(session, capacity, handshake, opts)?;
let batch = detect_max_batch_sectors(session.device_path());
let mut buffered = udf::BufferedSectorReader::new(session, batch);
let udf_fs = udf::read_filesystem(&mut buffered)?;
eprintln!(
"[scan {:.1}s] UDF parsed, prefetching metadata ({} sectors)...",
t0.elapsed().as_secs_f64(),
udf_fs.metadata_sectors()
);
buffered.prefetch(udf_fs.metadata_start(), udf_fs.metadata_sectors());
eprintln!("[scan {:.1}s] metadata cached", t0.elapsed().as_secs_f64());
let mut disc = Self::scan_with(&mut buffered, capacity, handshake, opts, udf_fs)?;
eprintln!("[scan {:.1}s] scan_with done", t0.elapsed().as_secs_f64());
// CSS key extraction for DVDs (bus auth → disc key → title key).
// Must be a single auth session — can't call authenticate() separately.
@@ -988,7 +1008,8 @@ impl Disc {
capacity: u32,
opts: &ScanOptions,
) -> Result<Self> {
Self::scan_with(reader, capacity, None, opts)
let udf_fs = udf::read_filesystem(reader)?;
Self::scan_with(reader, capacity, None, opts, udf_fs)
}
/// Core scan pipeline — works with any SectorReader.
@@ -997,15 +1018,19 @@ impl Disc {
capacity: u32,
handshake: Option<HandshakeResult>,
opts: &ScanOptions,
udf_fs: udf::UdfFs,
) -> Result<Self> {
// 1. UDF filesystem
let udf_fs = udf::read_filesystem(reader)?;
let t0 = std::time::Instant::now();
// 2. Resolve encryption (AACS, CSS, or none)
let encrypted =
udf_fs.find_dir("/AACS").is_some() || udf_fs.find_dir("/BDMV/AACS").is_some();
let aacs = if encrypted {
eprintln!(
"[scan_with {:.1}s] resolving encryption...",
t0.elapsed().as_secs_f64()
);
if let Some(keydb_path) = opts.resolve_keydb() {
Self::resolve_encryption(&udf_fs, reader, &keydb_path, handshake.as_ref()).ok()
} else {
@@ -1014,6 +1039,10 @@ impl Disc {
} else {
None
};
eprintln!(
"[scan_with {:.1}s] encryption done",
t0.elapsed().as_secs_f64()
);
// 3. Titles — BD (MPLS playlists) or DVD (IFO title sets)
let (mut titles, content_format) = if udf_fs.find_dir("/BDMV").is_some() {
@@ -1029,6 +1058,11 @@ impl Disc {
} else {
(Vec::new(), ContentFormat::BdTs)
};
eprintln!(
"[scan_with {:.1}s] titles done: {}",
t0.elapsed().as_secs_f64(),
titles.len()
);
titles.sort_by(|a, b| {
b.duration_secs
.partial_cmp(&a.duration_secs)
@@ -1037,7 +1071,12 @@ impl Disc {
// 4. Metadata + labels
let meta_title = Self::read_meta_title(reader, &udf_fs);
eprintln!(
"[scan_with {:.1}s] meta_title done",
t0.elapsed().as_secs_f64()
);
crate::labels::apply(reader, &udf_fs, &mut titles);
eprintln!("[scan_with {:.1}s] labels done", t0.elapsed().as_secs_f64());
// 5. Derive format, layers, region
let format = Self::detect_format(&titles);
src/udf.rs
+95
View File
@@ -61,6 +61,11 @@ impl UdfFs {
self.metadata_start
}
/// Metadata partition size in sectors.
pub(crate) fn metadata_sectors(&self) -> u32 {
self.metadata_sectors
}
/// Find a directory by path (e.g. "/BDMV/PLAYLIST").
/// Path matching is case-insensitive.
pub fn find_dir(&self, path: &str) -> Option<&DirEntry> {
@@ -832,6 +837,96 @@ fn parse_dstring(data: &[u8]) -> String {
/// Read a single 2048-byte sector from the drive.
/// Uses standard READ(10) — no unlock required.
/// Buffered sector reader — reduces SCSI round-trips by pre-fetching blocks.
/// Each SCSI command has ~500ms overhead on USB drives, so reading 32 sectors
/// at once (one command) is 32x faster than 32 individual reads.
pub(crate) struct BufferedSectorReader<'a> {
inner: &'a mut dyn SectorReader,
cache_start: u32,
cache: Vec<u8>,
cache_sectors: u32,
batch: u16,
}
impl<'a> BufferedSectorReader<'a> {
pub(crate) fn new(inner: &'a mut dyn SectorReader, batch: u16) -> Self {
Self {
inner,
cache_start: u32::MAX,
cache: Vec::new(),
cache_sectors: 0,
batch,
}
}
}
impl BufferedSectorReader<'_> {
/// Pre-read a range of sectors into the cache.
/// Used to bulk-load the UDF metadata partition so subsequent reads are instant.
pub(crate) fn prefetch(&mut self, start_lba: u32, count: u32) {
// Read in chunks of 30 sectors (within USB SCSI limits)
let total = count as usize * 2048;
self.cache.resize(total, 0);
let mut offset = 0u32;
while offset < count {
let batch = (count - offset).min(self.batch as u32) as u16;
let buf_off = offset as usize * 2048;
if self
.inner
.read_sectors(
start_lba + offset,
batch,
&mut self.cache[buf_off..buf_off + batch as usize * 2048],
)
.is_err()
{
break;
}
offset += batch as u32;
}
self.cache_start = start_lba;
self.cache_sectors = offset;
}
}
impl SectorReader for BufferedSectorReader<'_> {
fn read_sectors(
&mut self,
lba: u32,
count: u16,
buf: &mut [u8],
) -> std::result::Result<usize, crate::error::Error> {
if count == 1 {
// Single sector — use cache
if lba >= self.cache_start && lba < self.cache_start + self.cache_sectors {
let offset = (lba - self.cache_start) as usize * 2048;
buf[..2048].copy_from_slice(&self.cache[offset..offset + 2048]);
return Ok(2048);
}
let block = self.batch;
self.cache.resize(block as usize * 2048, 0);
match self.inner.read_sectors(lba, block, &mut self.cache) {
Ok(_) => {
self.cache_start = lba;
self.cache_sectors = block as u32;
}
Err(_) => {
// Near end of disc or error — single sector fallback
self.cache.resize(2048, 0);
self.inner.read_sectors(lba, 1, &mut self.cache)?;
self.cache_start = lba;
self.cache_sectors = 1;
}
}
buf[..2048].copy_from_slice(&self.cache[..2048]);
Ok(2048)
} else {
// Multi-sector read — pass through
self.inner.read_sectors(lba, count, buf)
}
}
}
fn read_sector(reader: &mut dyn SectorReader, lba: u32, buf: &mut [u8]) -> Result<()> {
reader.read_sectors(lba, 1, buf)?;
Ok(())