feat: add disc26-29 fixtures (MS IGLOO series)

bdpl/analyze/__init__.py

@@ -85,6 +85,7 @@ def _parse_disc_hints(bdmv_path: Path, clips: dict[str, ClipInfo] | None = None)
             # Build title → playlist mapping via index titles → movie objects
             obj_playlists: dict[int, list[int]] = {}
             obj_play_marks: dict[int, list[tuple[int, int]]] = {}
+            obj_jump_titles: dict[int, list[int]] = {}
             for obj in mo.objects:
                 if obj.referenced_playlists:
                     obj_playlists[obj.object_id] = obj.referenced_playlists
@@ -96,10 +97,14 @@ def _parse_disc_hints(bdmv_path: Path, clips: dict[str, ClipInfo] | None = None)
                 ]
                 if marks:
                     obj_play_marks[obj.object_id] = marks
+                jts = obj.referenced_titles
+                if jts:
+                    obj_jump_titles[obj.object_id] = jts
             hints["movie_objects"] = {
                 "count": len(mo.objects),
                 "obj_playlists": obj_playlists,
                 "obj_play_marks": obj_play_marks,
+                "obj_jump_titles": obj_jump_titles,
             }
         except Exception:
             log.debug("Failed to parse MovieObject.bdmv", exc_info=True)
@@ -289,6 +294,16 @@ def _detect_special_features(
             # All buttons on this page target the same title — this is
             # either the main-play page or a chapter-selection page.
             chapter_selection_jt.update(jts)
+            continue
+        # A page where every button targets an episode playlist is an
+        # episode-selection page (e.g. per-episode CHAPTER menu).
+        all_episode = all(
+            title_to_mpls.get(jt_val - 1) in ep_playlists
+            for jt_val in jts
+            if title_to_mpls.get(jt_val - 1) is not None
+        )
+        if all_episode:
+            chapter_selection_jt.update(jts)
 
     # --- Walk IG hints and build features -----------------------------------
     seen: set[tuple[str, int | None]] = set()
@@ -373,9 +388,12 @@ def _detect_special_features(
     # Supplement with title-hint specials not already covered by IG buttons.
     title_hint_entries = _title_hint_non_episode_entries(hints, classifications, episodes)
     existing_keys = {(feature.playlist, feature.chapter_start) for feature in features}
+    nav_playlists = _nav_playlists_from_hints(hints)
     for mpls, chapter_starts in title_hint_entries:
         if mpls in variant_mpls:
             continue
+        if mpls in nav_playlists:
+            continue
         pl = pl_by_name.get(mpls)
         if pl is None:
             continue
@@ -477,15 +495,35 @@ def _nav_playlists_from_hints(hints: dict) -> set[str]:
 
     These are navigation playlists (disc intro, menu background) and should
     not be treated as special features.
+
+    Follows one level of JumpTitle indirection: if the first_playback MO
+    jumps to a title whose MO plays a playlist, that playlist is included.
     """
     index_hints = hints.get("index", {})
-    obj_pl = hints.get("movie_objects", {}).get("obj_playlists", {})
+    mo_hints = hints.get("movie_objects", {})
+    obj_pl = mo_hints.get("obj_playlists", {})
+    obj_jt = mo_hints.get("obj_jump_titles", {})
     nav: set[str] = set()
+
+    # Build title → movie_object map for JumpTitle resolution.
+    title_to_obj: dict[int, int] = {
+        entry["title"]: entry["movie_object"] for entry in index_hints.get("titles", [])
+    }
+
     for key in ("first_playback_obj", "top_menu_obj"):
         obj_id = index_hints.get(key)
-        if obj_id is not None:
-            for pl_num in obj_pl.get(obj_id, []):
-                nav.add(f"{pl_num:05d}.mpls")
+        if obj_id is None:
+            continue
+        # Direct PlayPl commands.
+        for pl_num in obj_pl.get(obj_id, []):
+            nav.add(f"{pl_num:05d}.mpls")
+        # Follow JumpTitle → title → MO → PlayPl (one level).
+        for jt_num in obj_jt.get(obj_id, []):
+            title_idx = jt_num - 1  # JumpTitle operand is 1-based
+            target_obj = title_to_obj.get(title_idx)
+            if target_obj is not None:
+                for pl_num in obj_pl.get(target_obj, []):
+                    nav.add(f"{pl_num:05d}.mpls")
     return nav
 
 

tests/conftest.py

@@ -340,6 +340,54 @@ def disc25_analysis(disc25_path):
     return _analyze_fixture(disc25_path)
 
 
+@pytest.fixture(scope="session")
+def disc26_path() -> Path:
+    """Return path to bundled disc26 fixture."""
+    return _fixture_path("disc26")
+
+
+@pytest.fixture(scope="session")
+def disc26_analysis(disc26_path):
+    """Run and cache full analysis for the bundled disc26 fixture."""
+    return _analyze_fixture(disc26_path)
+
+
+@pytest.fixture(scope="session")
+def disc27_path() -> Path:
+    """Return path to bundled disc27 fixture."""
+    return _fixture_path("disc27")
+
+
+@pytest.fixture(scope="session")
+def disc27_analysis(disc27_path):
+    """Run and cache full analysis for the bundled disc27 fixture."""
+    return _analyze_fixture(disc27_path)
+
+
+@pytest.fixture(scope="session")
+def disc28_path() -> Path:
+    """Return path to bundled disc28 fixture."""
+    return _fixture_path("disc28")
+
+
+@pytest.fixture(scope="session")
+def disc28_analysis(disc28_path):
+    """Run and cache full analysis for the bundled disc28 fixture."""
+    return _analyze_fixture(disc28_path)
+
+
+@pytest.fixture(scope="session")
+def disc29_path() -> Path:
+    """Return path to bundled disc29 fixture."""
+    return _fixture_path("disc29")
+
+
+@pytest.fixture(scope="session")
+def disc29_analysis(disc29_path):
+    """Run and cache full analysis for the bundled disc29 fixture."""
+    return _analyze_fixture(disc29_path)
+
+
 @pytest.fixture
 def cli_runner() -> Callable[..., subprocess.CompletedProcess[str]]:
     """Return helper to invoke `python -m bdpl.cli` consistently in tests."""

tests/fixtures/disc26/META/DL/bdmt_eng.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<disclib>
+<di:discinfo xmlns:di="urn:BDA:bdmv;discinfo">
+<di:title><di:name>TEST DISC 26</di:name></di:title>
+</di:discinfo>
+</disclib>

tests/fixtures/disc27/META/DL/bdmt_eng.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<disclib>
+<di:discinfo xmlns:di="urn:BDA:bdmv;discinfo">
+<di:title><di:name>TEST DISC 27</di:name></di:title>
+</di:discinfo>
+</disclib>

tests/fixtures/disc28/META/DL/bdmt_eng.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<disclib>
+<di:discinfo xmlns:di="urn:BDA:bdmv;discinfo">
+<di:title><di:name>TEST DISC 28</di:name></di:title>
+</di:discinfo>
+</disclib>

tests/fixtures/disc29/META/DL/bdmt_eng.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<disclib>
+<di:discinfo xmlns:di="urn:BDA:bdmv;discinfo">
+<di:title><di:name>TEST DISC 29</di:name></di:title>
+</di:discinfo>
+</disclib>

tests/test_disc26_scan.py

@@ -0,0 +1,49 @@
+"""Integration tests for the disc26 fixture — 3-episode OVA disc with commentary + extras."""
+
+from __future__ import annotations
+
+import pytest
+
+from bdpl.model import DiscAnalysis
+
+pytestmark = pytest.mark.integration
+
+
+class TestDisc26Episodes:
+    def test_episode_count(self, disc26_analysis: DiscAnalysis) -> None:
+        assert len(disc26_analysis.episodes) == 3
+
+    def test_episodes_are_ordered(self, disc26_analysis: DiscAnalysis) -> None:
+        assert [ep.episode for ep in disc26_analysis.episodes] == list(range(1, 4))
+
+    def test_episode_playlists(self, disc26_analysis: DiscAnalysis) -> None:
+        assert [ep.playlist for ep in disc26_analysis.episodes] == [
+            "00002.mpls",
+            "00003.mpls",
+            "00004.mpls",
+        ]
+
+    def test_episode_durations(self, disc26_analysis: DiscAnalysis) -> None:
+        for ep in disc26_analysis.episodes:
+            dur_min = ep.duration_ms / 60000
+            assert 25 < dur_min < 30, f"ep{ep.episode} duration {dur_min:.1f}min out of range"
+
+
+class TestDisc26Specials:
+    def test_special_count(self, disc26_analysis: DiscAnalysis) -> None:
+        assert len(disc26_analysis.special_features) == 12
+
+    def test_no_commentary(self, disc26_analysis: DiscAnalysis) -> None:
+        commentary = [sf for sf in disc26_analysis.special_features if sf.category == "commentary"]
+        assert len(commentary) == 0
+
+    def test_has_creditless_ed(self, disc26_analysis: DiscAnalysis) -> None:
+        creditless = [
+            sf for sf in disc26_analysis.special_features if sf.category == "creditless_ed"
+        ]
+        assert len(creditless) == 4
+
+
+class TestDisc26Metadata:
+    def test_disc_title(self, disc26_analysis: DiscAnalysis) -> None:
+        assert disc26_analysis.disc_title == "TEST DISC 26"

tests/test_disc27_scan.py

@@ -0,0 +1,49 @@
+"""Integration tests for the disc27 fixture — 3-episode OVA disc with commentary + extras."""
+
+from __future__ import annotations
+
+import pytest
+
+from bdpl.model import DiscAnalysis
+
+pytestmark = pytest.mark.integration
+
+
+class TestDisc27Episodes:
+    def test_episode_count(self, disc27_analysis: DiscAnalysis) -> None:
+        assert len(disc27_analysis.episodes) == 3
+
+    def test_episodes_are_ordered(self, disc27_analysis: DiscAnalysis) -> None:
+        assert [ep.episode for ep in disc27_analysis.episodes] == list(range(1, 4))
+
+    def test_episode_playlists(self, disc27_analysis: DiscAnalysis) -> None:
+        assert [ep.playlist for ep in disc27_analysis.episodes] == [
+            "00002.mpls",
+            "00003.mpls",
+            "00004.mpls",
+        ]
+
+    def test_episode_durations(self, disc27_analysis: DiscAnalysis) -> None:
+        for ep in disc27_analysis.episodes:
+            dur_min = ep.duration_ms / 60000
+            assert 26 < dur_min < 31, f"ep{ep.episode} duration {dur_min:.1f}min out of range"
+
+
+class TestDisc27Specials:
+    def test_special_count(self, disc27_analysis: DiscAnalysis) -> None:
+        assert len(disc27_analysis.special_features) == 12
+
+    def test_no_commentary(self, disc27_analysis: DiscAnalysis) -> None:
+        commentary = [sf for sf in disc27_analysis.special_features if sf.category == "commentary"]
+        assert len(commentary) == 0
+
+    def test_has_creditless_ed(self, disc27_analysis: DiscAnalysis) -> None:
+        creditless = [
+            sf for sf in disc27_analysis.special_features if sf.category == "creditless_ed"
+        ]
+        assert len(creditless) == 6
+
+
+class TestDisc27Metadata:
+    def test_disc_title(self, disc27_analysis: DiscAnalysis) -> None:
+        assert disc27_analysis.disc_title == "TEST DISC 27"

tests/test_disc28_scan.py

@@ -0,0 +1,49 @@
+"""Integration tests for the disc28 fixture — 3-episode OVA disc with creditless + extras."""
+
+from __future__ import annotations
+
+import pytest
+
+from bdpl.model import DiscAnalysis
+
+pytestmark = pytest.mark.integration
+
+
+class TestDisc28Episodes:
+    def test_episode_count(self, disc28_analysis: DiscAnalysis) -> None:
+        assert len(disc28_analysis.episodes) == 3
+
+    def test_episodes_are_ordered(self, disc28_analysis: DiscAnalysis) -> None:
+        assert [ep.episode for ep in disc28_analysis.episodes] == list(range(1, 4))
+
+    def test_episode_playlists(self, disc28_analysis: DiscAnalysis) -> None:
+        assert [ep.playlist for ep in disc28_analysis.episodes] == [
+            "00002.mpls",
+            "00003.mpls",
+            "00004.mpls",
+        ]
+
+    def test_episode_durations(self, disc28_analysis: DiscAnalysis) -> None:
+        for ep in disc28_analysis.episodes:
+            dur_min = ep.duration_ms / 60000
+            assert 25 < dur_min < 33, f"ep{ep.episode} duration {dur_min:.1f}min out of range"
+
+
+class TestDisc28Specials:
+    def test_special_count(self, disc28_analysis: DiscAnalysis) -> None:
+        assert len(disc28_analysis.special_features) == 10
+
+    def test_no_commentary(self, disc28_analysis: DiscAnalysis) -> None:
+        commentary = [sf for sf in disc28_analysis.special_features if sf.category == "commentary"]
+        assert len(commentary) == 0
+
+    def test_has_creditless_ed(self, disc28_analysis: DiscAnalysis) -> None:
+        creditless = [
+            sf for sf in disc28_analysis.special_features if sf.category == "creditless_ed"
+        ]
+        assert len(creditless) == 7
+
+
+class TestDisc28Metadata:
+    def test_disc_title(self, disc28_analysis: DiscAnalysis) -> None:
+        assert disc28_analysis.disc_title == "TEST DISC 28"

tests/test_disc29_scan.py

@@ -0,0 +1,35 @@
+"""Integration tests for the disc29 fixture — special disc with OVA + digital archives."""
+
+from __future__ import annotations
+
+import pytest
+
+from bdpl.model import DiscAnalysis
+
+pytestmark = pytest.mark.integration
+
+
+class TestDisc29Episodes:
+    def test_episode_count(self, disc29_analysis: DiscAnalysis) -> None:
+        assert len(disc29_analysis.episodes) == 1
+
+    def test_episode_playlist(self, disc29_analysis: DiscAnalysis) -> None:
+        assert disc29_analysis.episodes[0].playlist == "00002.mpls"
+
+    def test_episode_duration(self, disc29_analysis: DiscAnalysis) -> None:
+        dur_min = disc29_analysis.episodes[0].duration_ms / 60000
+        assert 43 < dur_min < 45, f"OVA duration {dur_min:.1f}min, expected ~44min"
+
+
+class TestDisc29Specials:
+    def test_special_feature_count(self, disc29_analysis: DiscAnalysis) -> None:
+        assert len(disc29_analysis.special_features) == 3
+
+    def test_all_digital_archives(self, disc29_analysis: DiscAnalysis) -> None:
+        for sf in disc29_analysis.special_features:
+            assert sf.category == "digital_archive"
+
+
+class TestDisc29Metadata:
+    def test_disc_title(self, disc29_analysis: DiscAnalysis) -> None:
+        assert disc29_analysis.disc_title == "TEST DISC 29"