Add MKV muxer, IsoWriter, disc pipeline, and network tests

- MKV muxer: EBML header, segment, cluster, cues, multi-track, keyframe flags — 6 tests - MkvStream: BD-TS roundtrip, metadata preservation — 2 tests - IsoWriter: valid UDF, file size update, custom names, empty content — 4 tests - Disc pipeline: format detection (UHD/BD/DVD), content format, capacity, duration — 5 tests - Network: listen/connect roundtrip, metadata flow — 2 tests (ignored for CI) - Encryption: no AACS dir, no keydb — 2 tests - 297 tests total, all passing
2026-04-11 17:27:36 +00:00
parent 63accb6718
commit 9cb0c369e4
6 changed files with 1001 additions and 0 deletions
@@ -1050,3 +1050,121 @@ fn format_samplerate(audio_rate: u8) -> String {
        _ => String::new(),
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Helper: build a DiscTitle with a single video stream at the given resolution.
+    fn title_with_video(codec: Codec, resolution: &str) -> DiscTitle {
+        DiscTitle {
+            playlist: "00800.mpls".into(),
+            playlist_id: 800,
+            duration_secs: 7200.0,
+            size_bytes: 0,
+            clips: Vec::new(),
+            streams: vec![Stream::Video(VideoStream {
+                pid: 0x1011,
+                codec,
+                resolution: resolution.into(),
+                frame_rate: "23.976".into(),
+                hdr: HdrFormat::Sdr,
+                color_space: ColorSpace::Bt709,
+                secondary: false,
+                label: String::new(),
+            })],
+            extents: Vec::new(),
+            content_format: ContentFormat::BdTs,
+        }
+    }
+
+    #[test]
+    fn detect_format_uhd() {
+        let titles = vec![title_with_video(Codec::Hevc, "2160p")];
+        assert_eq!(Disc::detect_format(&titles), DiscFormat::Uhd);
+    }
+
+    #[test]
+    fn detect_format_bluray() {
+        let titles = vec![title_with_video(Codec::H264, "1080p")];
+        assert_eq!(Disc::detect_format(&titles), DiscFormat::BluRay);
+    }
+
+    #[test]
+    fn detect_format_dvd() {
+        let titles = vec![title_with_video(Codec::Mpeg2, "480i")];
+        assert_eq!(Disc::detect_format(&titles), DiscFormat::Dvd);
+    }
+
+    #[test]
+    fn detect_format_empty() {
+        let titles: Vec<DiscTitle> = Vec::new();
+        assert_eq!(Disc::detect_format(&titles), DiscFormat::Unknown);
+    }
+
+    #[test]
+    fn content_format_default_bdts() {
+        let t = title_with_video(Codec::H264, "1080p");
+        assert_eq!(t.content_format, ContentFormat::BdTs);
+    }
+
+    #[test]
+    fn content_format_dvd_mpegps() {
+        let t = DiscTitle {
+            content_format: ContentFormat::MpegPs,
+            ..title_with_video(Codec::Mpeg2, "480i")
+        };
+        assert_eq!(t.content_format, ContentFormat::MpegPs);
+    }
+
+    #[test]
+    fn disc_capacity_gb() {
+        // Single-layer BD-25: ~12,219,392 sectors
+        let disc = Disc {
+            volume_id: String::new(),
+            meta_title: None,
+            format: DiscFormat::BluRay,
+            capacity_sectors: 12_219_392,
+            capacity_bytes: 12_219_392u64 * 2048,
+            layers: 1,
+            titles: Vec::new(),
+            region: DiscRegion::Free,
+            aacs: None,
+            css: None,
+            encrypted: false,
+            content_format: ContentFormat::BdTs,
+        };
+        let gb = disc.capacity_gb();
+        // 12,219,392 * 2048 / 1073741824 = ~23.3 GB
+        assert!((gb - 23.3).abs() < 0.1, "expected ~23.3 GB, got {}", gb);
+
+        // Zero sectors
+        let disc_zero = Disc {
+            capacity_sectors: 0,
+            capacity_bytes: 0,
+            ..disc
+        };
+        assert_eq!(disc_zero.capacity_gb(), 0.0);
+    }
+
+    #[test]
+    fn disc_title_duration_display_edge_cases() {
+        let mut t = DiscTitle::empty();
+
+        // 0 seconds
+        t.duration_secs = 0.0;
+        assert_eq!(t.duration_display(), "0h 00m");
+
+        // 1 second
+        t.duration_secs = 1.0;
+        assert_eq!(t.duration_display(), "0h 00m");
+
+        // 59 minutes
+        t.duration_secs = 59.0 * 60.0;
+        assert_eq!(t.duration_display(), "0h 59m");
+
+        // 24 hours
+        t.duration_secs = 24.0 * 3600.0;
+        assert_eq!(t.duration_display(), "24h 00m");
+    }
+}
@@ -469,3 +469,155 @@ fn write_fid(buf: &mut [u8], icb_lba: u32, name: &str, is_parent: bool) -> usize

    padded
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Cursor;
+
+    /// Read a little-endian u16 from a byte slice at the given offset.
+    fn le_u16(data: &[u8], off: usize) -> u16 {
+        u16::from_le_bytes([data[off], data[off + 1]])
+    }
+
+    /// Read a little-endian u32 from a byte slice at the given offset.
+    fn le_u32(data: &[u8], off: usize) -> u32 {
+        u32::from_le_bytes([data[off], data[off + 1], data[off + 2], data[off + 3]])
+    }
+
+    /// Read a little-endian u64 from a byte slice at the given offset.
+    fn le_u64(data: &[u8], off: usize) -> u64 {
+        u64::from_le_bytes([
+            data[off],
+            data[off + 1],
+            data[off + 2],
+            data[off + 3],
+            data[off + 4],
+            data[off + 5],
+            data[off + 6],
+            data[off + 7],
+        ])
+    }
+
+    /// Get the sector at a given sector number from the output data.
+    fn sector(data: &[u8], num: u32) -> &[u8] {
+        let start = num as usize * SECTOR_SIZE as usize;
+        &data[start..start + SECTOR_SIZE as usize]
+    }
+
+    #[test]
+    fn isowriter_creates_valid_udf() {
+        let buf = Cursor::new(Vec::new());
+        let mut w = IsoWriter::new(buf, "TEST_VOL", "00001.m2ts");
+        w.start().unwrap();
+        w.write_data(&[0xAA; 4096]).unwrap();
+        w.finish().unwrap();
+        let data = w.writer.into_inner();
+
+        // AVDP at sector 256 should have tag ID = 2
+        let avdp = sector(&data, AVDP_SECTOR);
+        assert_eq!(le_u16(avdp, 0), 2, "AVDP tag ID should be 2");
+
+        // VRS at sector 16 should contain "BEA01"
+        let vrs = sector(&data, VRS_START);
+        assert_eq!(
+            &vrs[1..6],
+            b"BEA01",
+            "VRS sector 16 should contain BEA01"
+        );
+
+        // FSD at metadata sector should have tag ID = 256
+        let fsd = sector(&data, FSD_SECTOR);
+        assert_eq!(le_u16(fsd, 0), 256, "FSD tag ID should be 256");
+    }
+
+    #[test]
+    fn isowriter_updates_file_size() {
+        let buf = Cursor::new(Vec::new());
+        let mut w = IsoWriter::new(buf, "SIZE_TEST", "00001.m2ts");
+        w.start().unwrap();
+
+        let test_data = vec![0x42u8; 8192]; // exactly 4 sectors
+        let written = w.write_data(&test_data).unwrap();
+        assert_eq!(written, 8192);
+
+        w.finish().unwrap();
+        let data = w.writer.into_inner();
+
+        // Read m2ts ICB at M2TS_ICB_SECTOR and check information length at offset 56
+        let icb = sector(&data, M2TS_ICB_SECTOR);
+        let file_size = le_u64(icb, 56);
+        assert_eq!(
+            file_size, 8192,
+            "m2ts ICB file size should match bytes written (8192), got {}",
+            file_size
+        );
+    }
+
+    #[test]
+    fn isowriter_with_names() {
+        let buf = Cursor::new(Vec::new());
+        let mut w = IsoWriter::new(buf, "MY_DISC", "00042.m2ts");
+        w.start().unwrap();
+        w.write_data(&[0x00; 2048]).unwrap();
+        w.finish().unwrap();
+        let data = w.writer.into_inner();
+
+        // Check PVD (sector 32) volume_id at offset 24 as d-string
+        let pvd = sector(&data, VDS_START);
+        // d-string: byte 0 = compression ID (8), then ASCII chars
+        assert_eq!(pvd[24], 8, "PVD volume_id compression ID should be 8");
+        assert_eq!(
+            &pvd[25..32],
+            b"MY_DISC",
+            "PVD should contain volume_id 'MY_DISC'"
+        );
+
+        // Check STREAM directory (sector 266) for m2ts filename in FID
+        let stream_dir = sector(&data, STREAM_DIR_SECTOR);
+        // The FID for the m2ts file should contain the filename after the parent entry.
+        // Search for "00042.m2ts" in the sector data
+        let name = b"00042.m2ts";
+        let found = stream_dir
+            .windows(name.len())
+            .any(|w| w == name);
+        assert!(
+            found,
+            "STREAM directory should contain m2ts filename '00042.m2ts'"
+        );
+    }
+
+    #[test]
+    fn isowriter_empty_content() {
+        let buf = Cursor::new(Vec::new());
+        let mut w = IsoWriter::new(buf, "EMPTY", "00001.m2ts");
+        w.start().unwrap();
+        // No data written
+        w.finish().unwrap();
+        let data = w.writer.into_inner();
+
+        // Should still have valid UDF structure
+        // AVDP at sector 256
+        let avdp = sector(&data, AVDP_SECTOR);
+        assert_eq!(le_u16(avdp, 0), 2, "AVDP tag should be present even with no data");
+
+        // VRS
+        let vrs = sector(&data, VRS_START);
+        assert_eq!(&vrs[1..6], b"BEA01");
+
+        // FSD
+        let fsd = sector(&data, FSD_SECTOR);
+        assert_eq!(le_u16(fsd, 0), 256);
+
+        // m2ts ICB should show 0 file size
+        let icb = sector(&data, M2TS_ICB_SECTOR);
+        let file_size = le_u64(icb, 56);
+        assert_eq!(file_size, 0, "empty content should have 0 file size");
+
+        // Output should be at least DATA_START sectors (the header structure)
+        assert!(
+            data.len() >= DATA_START as usize * SECTOR_SIZE as usize,
+            "output too small for valid UDF structure"
+        );
+    }
+}
@@ -423,3 +423,227 @@ fn parse_channels(s: &str) -> u8 {
        6
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Cursor;
+
+    /// Helper: search for a 4-byte big-endian EBML ID in a byte slice.
+    fn find_id(data: &[u8], id: u32) -> Option<usize> {
+        let bytes = id.to_be_bytes();
+        // Determine how many leading zero bytes to skip
+        let start = if bytes[0] != 0 {
+            0
+        } else if bytes[1] != 0 {
+            1
+        } else if bytes[2] != 0 {
+            2
+        } else {
+            3
+        };
+        let needle = &bytes[start..];
+        data.windows(needle.len()).position(|w| w == needle)
+    }
+
+    fn make_video_track() -> MkvTrack {
+        MkvTrack {
+            track_type: ebml::TRACK_TYPE_VIDEO,
+            codec_id: "V_MPEG4/ISO/AVC",
+            language: "und".into(),
+            name: String::new(),
+            codec_private: Some(vec![0x00, 0x01, 0x02, 0x03]),
+            is_default: true,
+            is_forced: false,
+            pixel_width: 1920,
+            pixel_height: 1080,
+            sample_rate: 0.0,
+            channels: 0,
+            bit_depth: 0,
+        }
+    }
+
+    fn make_audio_track() -> MkvTrack {
+        MkvTrack {
+            track_type: ebml::TRACK_TYPE_AUDIO,
+            codec_id: "A_AC3",
+            language: "eng".into(),
+            name: "English".into(),
+            codec_private: None,
+            is_default: true,
+            is_forced: false,
+            pixel_width: 0,
+            pixel_height: 0,
+            sample_rate: 48000.0,
+            channels: 6,
+            bit_depth: 0,
+        }
+    }
+
+    #[test]
+    fn mkv_writes_ebml_header() {
+        let buf = Cursor::new(Vec::new());
+        let tracks = [make_video_track()];
+        let muxer = MkvMuxer::new(buf, &tracks, Some("Test"), 120.0).unwrap();
+        let data = muxer.writer.into_inner();
+        // EBML header element ID: 0x1A45DFA3
+        assert!(data.len() >= 4);
+        assert_eq!(&data[0..4], &[0x1A, 0x45, 0xDF, 0xA3]);
+    }
+
+    #[test]
+    fn mkv_writes_segment() {
+        let buf = Cursor::new(Vec::new());
+        let tracks = [make_video_track()];
+        let muxer = MkvMuxer::new(buf, &tracks, None, 0.0).unwrap();
+        let data = muxer.writer.into_inner();
+        // Segment element ID: 0x18538067
+        assert!(
+            find_id(&data, ebml::SEGMENT).is_some(),
+            "Segment element not found in output"
+        );
+    }
+
+    #[test]
+    fn mkv_write_frame_creates_cluster() {
+        let buf = Cursor::new(Vec::new());
+        let tracks = [make_video_track()];
+        let mut muxer = MkvMuxer::new(buf, &tracks, None, 60.0).unwrap();
+        muxer
+            .write_frame(0, 0, true, &[0xDE, 0xAD, 0xBE, 0xEF])
+            .unwrap();
+        let data = muxer.writer.into_inner();
+        assert!(
+            find_id(&data, ebml::CLUSTER).is_some(),
+            "Cluster element not found after write_frame"
+        );
+    }
+
+    #[test]
+    fn mkv_finish_writes_cues_element() {
+        // Use a Vec wrapped in Cursor, then check after finish
+        use std::sync::{Arc, Mutex};
+
+        // We'll write to a Cursor, but finish() consumes self.
+        // The trick: Cursor<Vec<u8>> - we can get data back via into_inner chain.
+        // But MkvMuxer::finish consumes self and flushes writer.
+        // We need a way to inspect the output. Let's use a wrapper.
+
+        struct SharedWriter(Arc<Mutex<Cursor<Vec<u8>>>>);
+        impl Write for SharedWriter {
+            fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+                self.0.lock().unwrap().write(buf)
+            }
+            fn flush(&mut self) -> io::Result<()> {
+                self.0.lock().unwrap().flush()
+            }
+        }
+        impl Seek for SharedWriter {
+            fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
+                self.0.lock().unwrap().seek(pos)
+            }
+        }
+
+        let shared = Arc::new(Mutex::new(Cursor::new(Vec::new())));
+        let writer = SharedWriter(shared.clone());
+        let tracks = [make_video_track()];
+        let mut muxer = MkvMuxer::new(writer, &tracks, Some("Cue Test"), 60.0).unwrap();
+        muxer
+            .write_frame(0, 0, true, &[0x01, 0x02, 0x03])
+            .unwrap();
+        muxer.finish().unwrap();
+
+        let data = shared.lock().unwrap().clone().into_inner();
+        assert!(
+            find_id(&data, ebml::CUES).is_some(),
+            "Cues element (0x1C53BB6B) not found after finish()"
+        );
+    }
+
+    #[test]
+    fn mkv_multiple_tracks() {
+        let buf = Cursor::new(Vec::new());
+        let tracks = [make_video_track(), make_audio_track()];
+        let mut muxer = MkvMuxer::new(buf, &tracks, Some("Multi"), 120.0).unwrap();
+        // Write frames to both tracks
+        muxer
+            .write_frame(0, 0, true, &[0x00, 0x00, 0x01])
+            .unwrap();
+        muxer
+            .write_frame(1, 0, false, &[0x0B, 0x77, 0x00])
+            .unwrap();
+        muxer
+            .write_frame(0, 40_000_000, false, &[0x00, 0x00, 0x01])
+            .unwrap();
+        muxer
+            .write_frame(1, 32_000_000, false, &[0x0B, 0x77, 0x01])
+            .unwrap();
+        // Should not panic
+        let data = muxer.writer.into_inner();
+        assert!(data.len() > 100, "output too small for multi-track MKV");
+    }
+
+    #[test]
+    fn mkv_keyframe_flag() {
+        let buf = Cursor::new(Vec::new());
+        let tracks = [make_video_track()];
+        let mut muxer = MkvMuxer::new(buf, &tracks, None, 10.0).unwrap();
+
+        // Record position before first frame
+        let pos_before_kf = muxer.writer.position();
+        muxer
+            .write_frame(0, 0, true, &[0xAA])
+            .unwrap();
+        let pos_after_kf = muxer.writer.position();
+
+        muxer
+            .write_frame(0, 1_000_000, false, &[0xBB])
+            .unwrap();
+        let pos_after_nkf = muxer.writer.position();
+
+        let data = muxer.writer.into_inner();
+
+        // Extract the SimpleBlock regions
+        let kf_region = &data[pos_before_kf as usize..pos_after_kf as usize];
+        let nkf_region = &data[pos_after_kf as usize..pos_after_nkf as usize];
+
+        // In a SimpleBlock, after ID + size + track_vint + 2-byte timestamp,
+        // the next byte is flags. Keyframe flag = 0x80, non-keyframe = 0x00.
+        // Find the flags byte in each region: it's the byte after the 2-byte timestamp.
+        // SimpleBlock ID is 0xA3. Find it and walk past ID + size + vint + ts.
+        fn extract_flags(region: &[u8]) -> u8 {
+            // Find 0xA3 (SimpleBlock ID)
+            let sb_pos = region.iter().position(|&b| b == 0xA3).unwrap();
+            // After ID: size (variable), track vint (1 byte for track<128), ts (2 bytes), flags (1 byte)
+            // Size is 1 byte for small blocks (< 127 bytes)
+            let after_id = sb_pos + 1;
+            // Read VINT size: first byte has high bit set for 1-byte sizes
+            let size_byte = region[after_id];
+            let size_len = if size_byte & 0x80 != 0 { 1 } else { 2 };
+            // Track VINT: 1 byte (track 1 = 0x81)
+            let track_vint_pos = after_id + size_len;
+            let track_vint_len = 1; // track 1 encoded as 0x81
+            // 2-byte relative timestamp
+            let ts_pos = track_vint_pos + track_vint_len;
+            // flags byte
+            let flags_pos = ts_pos + 2;
+            region[flags_pos]
+        }
+
+        let kf_flags = extract_flags(kf_region);
+        let nkf_flags = extract_flags(nkf_region);
+
+        assert_eq!(
+            kf_flags & 0x80,
+            0x80,
+            "keyframe flag should be set (0x80), got 0x{:02X}",
+            kf_flags
+        );
+        assert_eq!(
+            nkf_flags & 0x80,
+            0x00,
+            "non-keyframe flag should be clear, got 0x{:02X}",
+            nkf_flags
+        );
+    }
+}
@@ -140,3 +140,135 @@ impl Read for NetworkStream {
        }
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::disc::{
+        AudioStream, Codec, ColorSpace, ContentFormat, HdrFormat, Stream, VideoStream,
+    };
+    use std::io::{Read, Write};
+    use std::net::TcpListener;
+
+    /// Build a DiscTitle with streams for metadata tests.
+    fn sample_title() -> DiscTitle {
+        DiscTitle {
+            playlist: "NetworkTest".into(),
+            playlist_id: 1,
+            duration_secs: 3600.0,
+            size_bytes: 0,
+            clips: Vec::new(),
+            streams: vec![
+                Stream::Video(VideoStream {
+                    pid: 0x1011,
+                    codec: Codec::Hevc,
+                    resolution: "2160p".into(),
+                    frame_rate: "23.976".into(),
+                    hdr: HdrFormat::Hdr10,
+                    color_space: ColorSpace::Bt2020,
+                    secondary: false,
+                    label: "Main".into(),
+                }),
+                Stream::Audio(AudioStream {
+                    pid: 0x1100,
+                    codec: Codec::TrueHd,
+                    channels: "7.1".into(),
+                    language: "eng".into(),
+                    sample_rate: "48kHz".into(),
+                    secondary: false,
+                    label: "English".into(),
+                }),
+            ],
+            extents: Vec::new(),
+            content_format: ContentFormat::BdTs,
+        }
+    }
+
+    #[test]
+    #[ignore] // Requires TCP; may be flaky in CI environments
+    fn network_listen_connect_roundtrip() {
+        // Bind to OS-assigned port
+        let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+        let port = listener.local_addr().unwrap().port();
+        drop(listener); // Release so NetworkStream::listen can bind
+
+        let addr = format!("127.0.0.1:{}", port);
+        let addr_clone = addr.clone();
+
+        // Spawn listener in a thread
+        let handle = std::thread::spawn(move || {
+            let mut ns = NetworkStream::listen(&addr_clone).unwrap();
+            let mut buf = vec![0u8; 4096];
+            let mut received = Vec::new();
+            loop {
+                match ns.read(&mut buf) {
+                    Ok(0) => break,
+                    Ok(n) => received.extend_from_slice(&buf[..n]),
+                    Err(_) => break,
+                }
+            }
+            received
+        });
+
+        // Small delay to let the listener thread bind
+        std::thread::sleep(std::time::Duration::from_millis(50));
+
+        // Connect and write data
+        let dt = sample_title();
+        let mut writer = NetworkStream::connect(&addr).unwrap().meta(&dt);
+        let payload = b"Hello from the write side of the network stream!";
+        writer.write_all(payload).unwrap();
+        writer.finish().unwrap();
+
+        let received = handle.join().unwrap();
+        // The received data should end with our payload (after the FMKV header)
+        assert!(
+            received.windows(payload.len()).any(|w| w == payload),
+            "payload not found in received data (got {} bytes)",
+            received.len()
+        );
+    }
+
+    #[test]
+    #[ignore] // Requires TCP; may be flaky in CI environments
+    fn network_metadata_flows() {
+        let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+        let port = listener.local_addr().unwrap().port();
+        drop(listener);
+
+        let addr = format!("127.0.0.1:{}", port);
+        let addr_clone = addr.clone();
+
+        let handle = std::thread::spawn(move || {
+            let ns = NetworkStream::listen(&addr_clone).unwrap();
+            let info = ns.info().clone();
+            info
+        });
+
+        std::thread::sleep(std::time::Duration::from_millis(50));
+
+        let dt = sample_title();
+        let mut writer = NetworkStream::connect(&addr).unwrap().meta(&dt);
+        // Must write at least one byte to trigger header send
+        writer.write_all(&[0u8; 192]).unwrap();
+        writer.finish().unwrap();
+
+        let info = handle.join().unwrap();
+        assert_eq!(info.playlist, "NetworkTest");
+        assert_eq!(info.duration_secs, 3600.0);
+        assert_eq!(info.streams.len(), 2);
+    }
+
+    #[test]
+    fn network_empty_addr_errors() {
+        let result = NetworkStream::connect("");
+        assert!(result.is_err(), "empty address should fail");
+    }
+
+    #[test]
+    fn network_no_port_errors() {
+        // Connecting to an address without a port should fail
+        let result = NetworkStream::connect("127.0.0.1");
+        assert!(result.is_err(), "address without port should fail");
+    }
+}