MattJackson
d1f09439a5
Audit pass against the project docs "no English text in library code" rule.
Found 9 call sites that violated the contract by stuffing English into
io::Error::new(kind, "…") or by abusing Error::DeviceNotFound { path }
as a free-form description field. Each is now a typed Error variant.
New variants and codes: ScsiInterfaceUnavailable (E1004), DeviceLocked
(E1005), IoKitPluginFailed (E1006), UnsupportedPlatform (E2003),
PlatformNotImplemented (E2004), MapfileInvalid (E6011), DiscUrlNotDirect
(E9009).
labels::apply() previously pushed Commentary/Descriptive/Score/IME and
" (Secondary)" English literals into AudioStream.label, leaking into
MKV titles + autorip UI. AudioStream now exposes structured `purpose:
LabelPurpose`, SubtitleStream `qualifier: LabelQualifier`. Callers
translate to localized text. label keeps codec-formatting only.
API hygiene: 11 mux/* modules dropped from `pub` to `pub(crate)` —
their *types* are still re-exported from lib.rs, but the modules were
leaking low-level EBML/TS/network primitives. Stream trait gets a real
rustdoc explaining read-vs-write split. lib.rs grouped re-exports into
documented sections. ScanOptions::with_keydb() removed (one-method-per-
action rule); use struct literal.
Dead-code sweep: removed lookahead.rs (orphan, never declared as mod),
tsreader.rs (TsDemuxReader unused), ebml::{write_int,read_vint,SEEK_*},
ts::{scan_first/last_pts,scan_duration,SCAN_HEAD/TAIL_SIZE,take/set_
remainder}, MkvMuxer codec_private_slots/filled fields and
fill_codec_private method (deferred-codecPrivate path never used since
the v0.10 PES rewrite). cargo clippy --all-targets -D warnings clean.
Tests: new error::tests for variant codes + Display "no English" guard +
io::ErrorKind mapping. 233 lib tests, all green (was 230).
Breaking: ScanOptions::with_keydb removed; mux/* modules pub(crate);
AudioStream and SubtitleStream gained required fields; UnsupportedDrive
{ product_revision: "Renesas not yet implemented" } no longer produced
(use PlatformNotImplemented).
81 lines
2.4 KiB
Rust
81 lines
2.4 KiB
Rust
//! SectorReader — trait for reading 2048-byte disc sectors.
|
||
//!
|
||
//! Implemented by Drive (SCSI) and IsoFile (file-backed).
|
||
//! Used by UDF parser, disc scanner, label parsers — anything that
|
||
//! reads sectors doesn't need to know where they come from.
|
||
|
||
use crate::error::Result;
|
||
|
||
/// Read 2048-byte sectors from a disc or disc image.
|
||
pub trait SectorReader: Send {
|
||
/// Read `count` sectors starting at `lba` into `buf`.
|
||
/// `buf` must be at least `count * 2048` bytes.
|
||
/// `recovery`: true = full retry/reset loop (ripping), false = single attempt (verify).
|
||
/// File-backed readers ignore the flag.
|
||
fn read_sectors(
|
||
&mut self,
|
||
lba: u32,
|
||
count: u16,
|
||
buf: &mut [u8],
|
||
recovery: bool,
|
||
) -> Result<usize>;
|
||
|
||
/// Total capacity in sectors, if known.
|
||
fn capacity(&self) -> u32 {
|
||
0
|
||
}
|
||
}
|
||
|
||
/// SectorReader backed by a file (ISO image).
|
||
/// Seeks to lba * 2048, reads count * 2048 bytes.
|
||
pub struct FileSectorReader {
|
||
file: std::io::BufReader<std::fs::File>,
|
||
capacity: u32,
|
||
}
|
||
|
||
impl FileSectorReader {
|
||
pub fn open(path: &str) -> std::io::Result<Self> {
|
||
let file = std::fs::File::open(path)?;
|
||
let len = file.metadata()?.len();
|
||
let sectors = len / 2048;
|
||
if sectors > u32::MAX as u64 {
|
||
// ~8 TB hard cap (u32::MAX × 2048 bytes). Path lives in the
|
||
// typed Error variant — no English in the message.
|
||
return Err(crate::error::Error::IsoTooLarge {
|
||
path: path.to_string(),
|
||
}
|
||
.into());
|
||
}
|
||
let capacity = sectors as u32;
|
||
Ok(Self {
|
||
file: std::io::BufReader::with_capacity(4 * 1024 * 1024, file),
|
||
capacity,
|
||
})
|
||
}
|
||
}
|
||
|
||
impl SectorReader for FileSectorReader {
|
||
fn read_sectors(
|
||
&mut self,
|
||
lba: u32,
|
||
count: u16,
|
||
buf: &mut [u8],
|
||
_recovery: bool,
|
||
) -> Result<usize> {
|
||
use std::io::{Read, Seek, SeekFrom};
|
||
let offset = lba as u64 * 2048;
|
||
let bytes = count as usize * 2048;
|
||
self.file
|
||
.seek(SeekFrom::Start(offset))
|
||
.map_err(|e| crate::error::Error::IoError { source: e })?;
|
||
self.file
|
||
.read_exact(&mut buf[..bytes])
|
||
.map_err(|e| crate::error::Error::IoError { source: e })?;
|
||
Ok(bytes)
|
||
}
|
||
|
||
fn capacity(&self) -> u32 {
|
||
self.capacity
|
||
}
|
||
}
|