logic2ableton 2.3.0__tar.gz → 2.3.2__tar.gz

{logic2ableton-2.3.0 → logic2ableton-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logic2ableton
-Version: 2.3.0
+Version: 2.3.2
 Summary: Session transfer between Logic Pro, Ableton Live, and Pro Tools - six conversion lanes with evidence-first reports
 Author: evilander
 License-Expression: MIT
@@ -123,6 +123,8 @@ The product goal is **speed with evidence**: every run emits a report showing ex
 - MIDI notes transfer as native MIDI tracks (and `.mid` exports), but the software instruments, their settings, and MIDI effects are not recreated — reload instruments in Ableton
 - Region placement, loops, track names and markers come from the project's own arrangement data. That decoding was worked out on Logic 10.6 and Logic 11 saves; the report says "Region positions: read from the Logic arrangement" when it applies. Saves it cannot read fall back to audio timestamps, `MIDI 1`, `MIDI 2`, ... track names, and a warning
 - Regions that start before bar 1 are moved to bar 1 (audio is trimmed by the same amount) because a Live arrangement cannot start earlier
+- Looped audio regions are written as repeated clips, spaced at the project tempo. If the tempo changes under a looped audio region, check the repeats; the report lists every region it unrolled
+- Logic tracks that share a name are kept apart by numbering the later ones (`Guitar`, `Guitar (2)`), and the report says which were renamed
 - Logic's tempo track is not decoded (only the project tempo is); supply tempo changes with `--timeline`
 - `--smpte-start` only matters for the timestamp fallback; it must then match the project's own synchronization setting (default `01:00:00:00`), and the report lists any files placed at bar 1 because their timestamp precedes it
 - Automation is not recreated
@@ -314,6 +316,20 @@ logic2ableton "/path/to/MySong.logicx" --output ./output --json-progress
 ableton2logic "/path/to/MySet.als" --output ./output --json-progress
 ```
 
+Progress events report audio counts (`tracks`, `clips`, `audio_files`) separately
+from `midi_tracks` and `midi_notes`. Previews include recovered MIDI content.
+For Ableton output, the completion event's `midi_tracks` counts native tracks in
+the set; `midi_files` separately counts exported `.mid` sidecars.
+
+A failed run ends with an `error` event whose `failure_stage` names the step that
+failed (for example `timeline`, `parsing` or `generating`) and whose `error`
+holds the reason. The saved report keeps any analysis already done and ends
+with the same stage and reason.
+
+Pro Tools previews check referenced audio on disk. The report lists found,
+missing, and skipped sources, and `compatibility_warnings` names missing media
+before conversion begins. These notes also appear in the desktop preview.
+
 ## CLI Options
 
 Every lane's input argument accepts one or more paths. Pass several to convert

{logic2ableton-2.3.0 → logic2ableton-2.3.2}/README.md

@@ -99,6 +99,8 @@ The product goal is **speed with evidence**: every run emits a report showing ex
 - MIDI notes transfer as native MIDI tracks (and `.mid` exports), but the software instruments, their settings, and MIDI effects are not recreated — reload instruments in Ableton
 - Region placement, loops, track names and markers come from the project's own arrangement data. That decoding was worked out on Logic 10.6 and Logic 11 saves; the report says "Region positions: read from the Logic arrangement" when it applies. Saves it cannot read fall back to audio timestamps, `MIDI 1`, `MIDI 2`, ... track names, and a warning
 - Regions that start before bar 1 are moved to bar 1 (audio is trimmed by the same amount) because a Live arrangement cannot start earlier
+- Looped audio regions are written as repeated clips, spaced at the project tempo. If the tempo changes under a looped audio region, check the repeats; the report lists every region it unrolled
+- Logic tracks that share a name are kept apart by numbering the later ones (`Guitar`, `Guitar (2)`), and the report says which were renamed
 - Logic's tempo track is not decoded (only the project tempo is); supply tempo changes with `--timeline`
 - `--smpte-start` only matters for the timestamp fallback; it must then match the project's own synchronization setting (default `01:00:00:00`), and the report lists any files placed at bar 1 because their timestamp precedes it
 - Automation is not recreated
@@ -290,6 +292,20 @@ logic2ableton "/path/to/MySong.logicx" --output ./output --json-progress
 ableton2logic "/path/to/MySet.als" --output ./output --json-progress
 ```
 
+Progress events report audio counts (`tracks`, `clips`, `audio_files`) separately
+from `midi_tracks` and `midi_notes`. Previews include recovered MIDI content.
+For Ableton output, the completion event's `midi_tracks` counts native tracks in
+the set; `midi_files` separately counts exported `.mid` sidecars.
+
+A failed run ends with an `error` event whose `failure_stage` names the step that
+failed (for example `timeline`, `parsing` or `generating`) and whose `error`
+holds the reason. The saved report keeps any analysis already done and ends
+with the same stage and reason.
+
+Pro Tools previews check referenced audio on disk. The report lists found,
+missing, and skipped sources, and `compatibility_warnings` names missing media
+before conversion begins. These notes also appear in the desktop preview.
+
 ## CLI Options
 
 Every lane's input argument accepts one or more paths. Pass several to convert

logic2ableton-2.3.2/logic2ableton/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.3.2"

{logic2ableton-2.3.0 → logic2ableton-2.3.2}/logic2ableton/ableton_generator.py

@@ -314,33 +314,39 @@ def _make_audio_clip_xml(
     _val(ts_remote, "Denominator", str(time_sig_denominator))
     _val(ts_remote, "Time", "0")
 
-    # WarpMarkers — start and end always; warped clips that cross a tempo
-    # breakpoint get an extra marker at each one so Live's playback speed
-    # tracks the song's actual tempo curve instead of one flat ratio for
-    # the whole file. With no timeline, this reduces to the plain
-    # single-tempo formula (no map lookups) so output is unchanged.
+    # WarpMarkers map source seconds to clip-content beats — start and end
+    # always; warped clips that cross a tempo breakpoint get an extra marker at
+    # each one so Live's playback speed tracks the song's actual tempo curve
+    # instead of one flat ratio for the whole file. With no timeline, this
+    # reduces to the plain single-tempo formula (no map lookups) so output is
+    # unchanged.
+    #
+    # Under a tempo map the played slice starts at source second offset_secs,
+    # which sits at the clip's arrangement position. Source audio before the
+    # slice never plays and keeps the flat base-tempo ratio, so LoopStart
+    # (offset_beats, computed at the base tempo) still lands on offset_secs;
+    # from there on, content beats follow the tempo map from start_beats.
+    marker_points: list[tuple[float, float]] = [(0.0, 0.0)]
     if tempo_map.events:
-        end_abs_beat = tempo_map.seconds_to_beats(start_seconds + duration_secs)
-        warp_end_beat_time = end_abs_beat - start_beats
-        breakpoints = tempo_map.breakpoints_between(start_beats, end_abs_beat) if is_warped else []
+        end_abs_beat = tempo_map.seconds_to_beats(start_seconds + duration_secs - offset_secs)
+        if offset_secs > 0:
+            marker_points.append((offset_secs, offset_beats))
+        if is_warped:
+            for event in tempo_map.breakpoints_between(start_beats, end_abs_beat):
+                marker_points.append((
+                    offset_secs + tempo_map.beats_to_seconds(event.beat) - start_seconds,
+                    offset_beats + event.beat - start_beats,
+                ))
+        marker_points.append((duration_secs, offset_beats + end_abs_beat - start_beats))
     else:
-        warp_end_beat_time = duration_secs * tempo_map.base_tempo / 60
-        breakpoints = []
+        marker_points.append((duration_secs, duration_secs * tempo_map.base_tempo / 60))
 
     warp_markers = ET.SubElement(clip, "WarpMarkers")
-    wm_start = ET.SubElement(warp_markers, "WarpMarker")
-    wm_start.set("Id", str(allocator.next()))
-    wm_start.set("SecTime", "0")
-    wm_start.set("BeatTime", "0")
-    for event in breakpoints:
-        wm_mid = ET.SubElement(warp_markers, "WarpMarker")
-        wm_mid.set("Id", str(allocator.next()))
-        wm_mid.set("SecTime", str(tempo_map.beats_to_seconds(event.beat) - start_seconds))
-        wm_mid.set("BeatTime", str(event.beat - start_beats))
-    wm_end = ET.SubElement(warp_markers, "WarpMarker")
-    wm_end.set("Id", str(allocator.next()))
-    wm_end.set("SecTime", str(duration_secs))
-    wm_end.set("BeatTime", str(warp_end_beat_time))
+    for sec_time, beat_time in marker_points:
+        marker = ET.SubElement(warp_markers, "WarpMarker")
+        marker.set("Id", str(allocator.next()))
+        marker.set("SecTime", "0" if sec_time == 0 else str(sec_time))
+        marker.set("BeatTime", "0" if beat_time == 0 else str(beat_time))
 
     # WarpMode: 0 = Beats (default for arrangement clips)
     _val(clip, "WarpMode", "0")

{logic2ableton-2.3.0 → logic2ableton-2.3.2}/logic2ableton/cli.py

@@ -25,6 +25,7 @@ from logic2ableton.protools_import import (
     build_protools_import_report,
     protools_to_ableton_project,
     protools_to_logic_project,
+    resolve_protools_media,
 )
 from logic2ableton.protools_parser import parse_protools_session
 from logic2ableton.protools_transfer import (
@@ -277,12 +278,21 @@ def _emit_failure(
     report_path = _report_path(
         output_dir, input_path, project_name=project_name, suffix=report_suffix, unique=unique
     )
-    report_text = report or _build_failure_report(mode, input_path, stage, error)
+    if report:
+        # A failure after analysis keeps the analysis report, but the saved
+        # report must still say what failed and why.
+        report_text = (
+            f"{report.rstrip()}\n\nCONVERSION FAILED\n  Stage: {stage}\n  Error: {error}\n"
+        )
+    else:
+        report_text = _build_failure_report(mode, input_path, stage, error)
     _, report_note = _persist_report_with_note(report_path, report_text)
     message = f"Failed during {stage}: {error}.{report_note}"
     payload: dict[str, object] = {
         "direction": mode,
         "input": str(input_path),
+        "failure_stage": stage,
+        "error": error,
         "report": report_text,
         "report_path": str(report_path),
         "artifact_path": str(report_path),
@@ -671,6 +681,7 @@ def _run_forward(args: argparse.Namespace) -> int:
                 compatibility_warnings=project.compatibility_warnings,
             )
         if jp:
+            midi_track_count = sum(1 for track in project.midi_tracks if track.note_count > 0)
             _emit(
                 "complete",
                 1.0,
@@ -683,6 +694,8 @@ def _run_forward(args: argparse.Namespace) -> int:
                 tracks=len(project.track_names),
                 audio_files=len(project.audio_files),
                 plugins=len(project.plugins),
+                midi_tracks=midi_track_count,
+                midi_notes=project.total_midi_notes,
                 compatibility_warnings=project.compatibility_warnings,
             )
         else:
@@ -739,7 +752,8 @@ def _run_forward(args: argparse.Namespace) -> int:
             tracks=len(project.track_names),
             clips=clip_count,
             audio_files=audio_count,
-            midi_tracks=midi_files,
+            midi_tracks=sum(1 for track in project.midi_tracks if track.note_count > 0),
+            midi_files=midi_files,
             midi_notes=project.total_midi_notes,
             compatibility_warnings=project.compatibility_warnings,
             **({"warning": warning} if warning else {}),
@@ -1016,7 +1030,16 @@ def _run_protools_import(args: argparse.Namespace, mode: str) -> int:
         )
 
     try:
-        report = build_protools_import_report(session, destination=destination, tempo=tempo)
+        # Share resolved media and counts between preview and conversion.
+        media_preflight = resolve_protools_media(session)
+        project = (
+            protools_to_logic_project(session, tempo=args.tempo, preflight=media_preflight)
+            if to_ableton else
+            protools_to_ableton_project(session, tempo=args.tempo, preflight=media_preflight)
+        )
+        report = build_protools_import_report(
+            session, destination=destination, tempo=tempo, preflight=media_preflight,
+        )
     except Exception as exc:
         return _emit_failure(
             mode=mode,
@@ -1067,12 +1090,12 @@ def _run_protools_import(args: argparse.Namespace, mode: str) -> int:
                 artifact_path=str(report_path),
                 report=report,
                 report_path=str(report_path),
-                tracks=len(session.tracks),
-                clips=session.total_regions,
-                audio_files=len(session.audio_files),
-                midi_tracks=len(session.midi_tracks),
-                midi_notes=session.total_midi_notes,
-                compatibility_warnings=session.compatibility_warnings,
+                tracks=len(project.track_names) if to_ableton else len(project.audio_tracks),
+                clips=len(project.audio_files) if to_ableton else len(project.clips),
+                audio_files=len(media_preflight.referenced_files),
+                midi_tracks=sum(1 for track in project.midi_tracks if track.note_count > 0),
+                midi_notes=project.total_midi_notes,
+                compatibility_warnings=project.compatibility_warnings,
             )
         else:
             print(f"\nReport: {report_path}")
@@ -1084,7 +1107,6 @@ def _run_protools_import(args: argparse.Namespace, mode: str) -> int:
         print(f"\nGenerating {destination} output in {output_dir}...")
 
     if to_ableton:
-        project = protools_to_logic_project(session, tempo=args.tempo)
         template_path = Path(args.template) if args.template else None
         try:
             als_path = generate_als(
@@ -1127,7 +1149,8 @@ def _run_protools_import(args: argparse.Namespace, mode: str) -> int:
                 tracks=len(project.track_names),
                 clips=clip_count,
                 audio_files=audio_count,
-                midi_tracks=midi_files,
+                midi_tracks=sum(1 for track in project.midi_tracks if track.note_count > 0),
+                midi_files=midi_files,
                 midi_notes=project.total_midi_notes,
                 compatibility_warnings=project.compatibility_warnings,
                 **({"warning": warning} if warning else {}),
@@ -1144,7 +1167,6 @@ def _run_protools_import(args: argparse.Namespace, mode: str) -> int:
             print("\nDone!")
         return 0
 
-    project = protools_to_ableton_project(session, tempo=args.tempo)
     try:
         transfer = generate_logic_transfer(project, output_dir, copy_audio=not args.no_copy)
     except Exception as exc:

{logic2ableton-2.3.0 → logic2ableton-2.3.2}/logic2ableton/logic_parser.py

@@ -912,10 +912,55 @@ def _unroll_regions(regions: list[LogicMidiRegion]) -> list[LogicMidiNote]:
     return notes
 
 
+def _unique_track_names(arrangement: LogicArrangement, warnings: list[str]) -> dict[int, str]:
+    """Display name per Logic track id, numbering tracks that share a name.
+
+    Outputs group clips by track name, so two Logic tracks both called
+    "Guitar" would otherwise merge into one track. The first track (by lane,
+    then position) keeps the plain name; later ones become "Guitar (2)", ...
+    """
+    first_seen: dict[int, tuple[int, int]] = {}
+    for placement in arrangement.regions:
+        # Only tracks that produce output compete for a name.
+        if placement.muted:
+            continue
+        if placement.kind == "midi":
+            sequence = arrangement.sequences.get(placement.sequence_id)
+            if sequence is None or not sequence.notes:
+                continue
+        elif placement.audio_file_id not in arrangement.audio_files:
+            continue
+        key = (placement.lane, placement.tick)
+        if placement.track_id not in first_seen or key < first_seen[placement.track_id]:
+            first_seen[placement.track_id] = key
+    names: dict[int, str] = {}
+    used: set[str] = set()
+    renamed: list[str] = []
+    for track_id in sorted(first_seen, key=lambda tid: (first_seen[tid], tid)):
+        base = arrangement.track_name(track_id)
+        name = base
+        number = 2
+        while name.casefold() in used:
+            name = f"{base} ({number})"
+            number += 1
+        used.add(name.casefold())
+        names[track_id] = name
+        if name != base:
+            renamed.append(name)
+    if renamed:
+        examples = ", ".join(renamed[:5]) + (", ..." if len(renamed) > 5 else "")
+        warnings.append(
+            f"{len(renamed)} Logic track(s) share a name with another track and were numbered "
+            f"to keep them separate: {examples}"
+        )
+    return names
+
+
 def _arrangement_midi_tracks(
     arrangement: LogicArrangement,
     *,
     bar_beats: float,
+    track_names_by_id: dict[int, str],
     warnings: list[str],
 ) -> list[LogicMidiTrack]:
     """One LogicMidiTrack per Logic track that has audible MIDI regions."""
@@ -929,7 +974,7 @@ def _arrangement_midi_tracks(
     for track_id, placements in sorted(
         by_track.items(), key=lambda item: (min(p.lane for p in item[1]), min(p.tick for p in item[1]))
     ):
-        track_name = arrangement.track_name(track_id)
+        track_name = track_names_by_id.get(track_id) or arrangement.track_name(track_id)
         regions: list[LogicMidiRegion] = []
         for placement in sorted(placements, key=lambda p: p.tick):
             sequence = arrangement.sequences.get(placement.sequence_id)
@@ -982,14 +1027,16 @@ def _arrangement_audio_refs(
     *,
     tempo: float,
     bar_beats: float,
+    track_names_by_id: dict[int, str],
     warnings: list[str],
 ) -> tuple[list[AudioFileRef], list[str]]:
-    """Audio clips as Logic placed them: one ref per region, on the Logic track's name."""
+    """Audio clips as Logic placed them: one ref per region, one per repetition when looped."""
     by_name = {ref.filename.casefold(): ref for ref in discovered}
     refs: list[AudioFileRef] = []
     lanes: dict[str, int] = {}
     missing: list[str] = []
     muted: list[str] = []
+    looped: list[str] = []
     for placement in sorted(arrangement.regions, key=lambda p: (p.tick, p.lane)):
         if placement.kind != "audio":
             continue
@@ -997,43 +1044,75 @@ def _arrangement_audio_refs(
         if not filename:
             continue
         source = by_name.get(filename.casefold())
-        track_name = arrangement.track_name(placement.track_id)
+        track_name = track_names_by_id.get(placement.track_id) or arrangement.track_name(placement.track_id)
         if source is None:
             missing.append(filename)
             continue
         region = arrangement.audio_regions.get((placement.audio_file_id, placement.audio_region_index))
         region_name = region.name if region and region.name else None
+        label = region_name or filename
         if placement.muted:
-            muted.append(f"{track_name}: {region_name or filename}")
+            muted.append(f"{track_name}: {label}")
             continue
         file_rate = _get_audio_sample_rate(source.file_path)
+        samples_per_beat = 60.0 / tempo * file_rate
         start_beats = arrangement.region_beats(placement.tick, bar_beats)
         content_offset = region.content_offset if region else 0
         content_length = region.content_length if region else None
-        if start_beats < 0:
-            # Live's arrangement starts at bar 1: keep the audio in sync by
-            # trimming the part that would sit before it.
-            trimmed = round(-start_beats * 60.0 / tempo * file_rate)
-            content_offset += trimmed
-            if content_length is not None:
-                content_length = max(0, content_length - trimmed)
-                if content_length == 0:
-                    warnings.append(
-                        f"Audio region '{region_name or filename}' on '{track_name}' ends before bar 1 "
-                        "and was skipped."
+
+        # (start beats, source offset, source length) for each pass the region plays.
+        passes: list[tuple[float, int, int | None]] = [(start_beats, content_offset, content_length)]
+        if placement.looped and content_length:
+            # Logic repeats the region end to end across the loop span and cuts
+            # the last pass at the span's end. Passes are spaced at the project
+            # tempo, which is exact unless the tempo changes under the loop.
+            span_beats = placement.loop_span / PPQ
+            length_beats = content_length / samples_per_beat
+            if span_beats > length_beats * (1 + 1e-9):
+                passes = []
+                repetition = 0
+                while repetition * length_beats < span_beats - 1e-9:
+                    remaining_beats = span_beats - repetition * length_beats
+                    length = (
+                        content_length if remaining_beats >= length_beats
+                        else round(remaining_beats * samples_per_beat)
                     )
-                    continue
-            start_beats = 0.0
-        refs.append(replace(
-            source,
-            track_name=track_name,
-            start_position_samples=max(0, round(start_beats * 60.0 / tempo * file_rate)),
-            content_offset_samples=content_offset,
-            content_duration_samples=content_length,
-            clip_name=region_name,
-            start_beats=start_beats,
-        ))
-        lanes.setdefault(track_name, placement.lane)
+                    passes.append((start_beats + repetition * length_beats, content_offset, length))
+                    repetition += 1
+                looped.append(f"{track_name}: {label} x{len(passes)}")
+
+        for pass_start, pass_offset, pass_length in passes:
+            if pass_start < 0:
+                # The Live arrangement starts at bar 1: keep the audio in sync
+                # by trimming the part that would sit before it.
+                trimmed = round(-pass_start * samples_per_beat)
+                pass_offset += trimmed
+                if pass_length is not None:
+                    pass_length -= trimmed
+                    if pass_length <= 0:
+                        warnings.append(
+                            f"Audio region '{label}' on '{track_name}' ends before bar 1 and was skipped."
+                        )
+                        continue
+                pass_start = 0.0
+            if pass_length is not None and pass_length <= 0:
+                continue
+            refs.append(replace(
+                source,
+                track_name=track_name,
+                start_position_samples=max(0, round(pass_start * samples_per_beat)),
+                content_offset_samples=pass_offset,
+                content_duration_samples=pass_length,
+                clip_name=region_name,
+                start_beats=pass_start,
+            ))
+            lanes.setdefault(track_name, placement.lane)
+    if looped:
+        examples = ", ".join(looped[:5]) + (", ..." if len(looped) > 5 else "")
+        warnings.append(
+            f"{len(looped)} looped audio region(s) were written as repeated clips spaced at the project "
+            f"tempo; check them if the song changes tempo under the loop: {examples}"
+        )
     if missing:
         unique = sorted(set(missing))
         examples = ", ".join(unique[:5]) + (", ..." if len(unique) > 5 else "")
@@ -1118,9 +1197,17 @@ def parse_logic_project(
         # The project's own arrangement says where every region sits, how it
         # loops and which track owns it, so audio timestamps and the SMPTE
         # start are not needed for placement.
-        midi_tracks = _arrangement_midi_tracks(arrangement, bar_beats=bar_beats, warnings=midi_warnings)
+        track_names_by_id = _unique_track_names(arrangement, midi_warnings)
+        midi_tracks = _arrangement_midi_tracks(
+            arrangement, bar_beats=bar_beats, track_names_by_id=track_names_by_id, warnings=midi_warnings,
+        )
         audio_files, track_names = _arrangement_audio_refs(
-            arrangement, audio_files, tempo=meta["tempo"], bar_beats=bar_beats, warnings=midi_warnings,
+            arrangement,
+            audio_files,
+            tempo=meta["tempo"],
+            bar_beats=bar_beats,
+            track_names_by_id=track_names_by_id,
+            warnings=midi_warnings,
         )
         regions = {ref.filename: ref.start_position_samples for ref in audio_files}
         timeline = _arrangement_timeline(arrangement)

{logic2ableton-2.3.0 → logic2ableton-2.3.2}/logic2ableton/logic_project_data.py

@@ -445,6 +445,6 @@ def decode_project_data(data: bytes, *, beats_per_bar: float = 4.0) -> LogicArra
     arrangement.project_start_bar = _project_start_bar(
         data, arrangement.format_version, int(round(beats_per_bar * PPQ)) or PPQ * 4,
     )
-    if len(data) >= 174 and _u32(data, 170) == _u32(data, 174) and 0 < _u32(data, 170) < 10_000_000:
+    if len(data) >= 178 and _u32(data, 170) == _u32(data, 174) and 0 < _u32(data, 170) < 10_000_000:
         arrangement.tempo_bpm = _u32(data, 170) / 10_000
     return arrangement