logic2ableton 2.3.1__tar.gz → 2.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logic2ableton
-Version: 2.3.1
+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
@@ -319,6 +321,11 @@ 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.

{logic2ableton-2.3.1 → 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
@@ -295,6 +297,11 @@ 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.

logic2ableton-2.3.2/logic2ableton/__init__.py

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

{logic2ableton-2.3.1 → 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.1 → logic2ableton-2.3.2}/logic2ableton/cli.py

@@ -278,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),

{logic2ableton-2.3.1 → 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.1 → 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

{logic2ableton-2.3.1 → logic2ableton-2.3.2}/logic2ableton/protools_parser.py

@@ -382,8 +382,12 @@ def _parse_midi(reader: _SessionReader, blocks: list[_Block]) -> list[ProToolsMi
         k = block.offset
         end = block.offset + block.size
         while k + 35 < end:
-            found = data.find(b"MdNLB", k, len(data))
-            if found < 0:
+            # Search, header and events all stay inside this block: trailing
+            # bytes after one chunk must not let the scan reach the next
+            # block's marker, which would parse that chunk twice and shift
+            # every later chunk index.
+            found = data.find(b"MdNLB", k, end)
+            if found < 0 or found + 20 > end:
                 break
             k = found + 11
             n_events = reader.u32(k)
@@ -391,7 +395,7 @@ def _parse_midi(reader: _SessionReader, blocks: list[_Block]) -> list[ProToolsMi
             zero_ticks = reader.u40(k)
             events: list[tuple[int, int, int, int]] = []
             for _ in range(n_events):
-                if k + 35 > len(data):
+                if k + 35 > end:
                     break
                 pos = reader.u40(k) - zero_ticks
                 note = data[k + 8]

{logic2ableton-2.3.1 → logic2ableton-2.3.2}/logic2ableton/protools_transfer.py

@@ -9,7 +9,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from collections.abc import Iterable
 
-from logic2ableton.audio import write_pcm_wav
+from logic2ableton.audio import BLOCK_FRAMES, write_pcm_wav
 
 from logic2ableton.logic_transfer import (
     DecodedAudio,
@@ -102,7 +102,9 @@ def _render_protools_clip_export(
 
 def _logic_audio_export_stem(index: int, ref: AudioFileRef, *, tempo: float, sample_rate: int) -> str:
     stem = _safe_name(Path(ref.filename).stem, f"clip_{index:03d}")
-    beats = samples_to_beats(ref.start_position_samples, tempo, sample_rate)
+    beats = ref.start_beats if ref.start_beats is not None else samples_to_beats(
+        ref.start_position_samples, tempo, sample_rate
+    )
     return f"{index:03d} - {stem} - {beats:09.3f} beats"
 
 
@@ -117,12 +119,12 @@ def _render_protools_logic_audio_export(
     *,
     cache: dict[Path, DecodedAudio | None],
 ) -> tuple[str, int | None, Path]:
-    """Render one Logic-sourced audio file as a Pro Tools-ready timestamped WAV.
+    """Render one Logic region as a Pro Tools-ready timestamped WAV.
 
-    Logic's own audio files already represent a single recorded region, so no
-    clip-level slicing is needed here - only re-stamping the bext
-    TimeReference to the file's start position, which the Logic parser has
-    already normalized to be relative to bar 1 (no further offset applied).
+    Only the slice of the source the region plays is written: from
+    ``content_offset_samples`` for ``content_duration_samples`` (the rest of
+    the file when unset). The bext TimeReference is the region's arrangement
+    position, which the Logic parser has already made relative to bar 1.
     The destination filename is chosen from the render outcome (see
     _clip_export_name's docstring / F11, 2026-09-15 review).
     """
@@ -135,13 +137,21 @@ def _render_protools_logic_audio_export(
         shutil.copy2(ref.file_path, destination)
         return "copied-source", None, destination
 
+    start = max(0, min(decoded.frame_count, ref.content_offset_samples))
+    available = decoded.frame_count - start
+    count = available if ref.content_duration_samples is None else max(0, min(available, ref.content_duration_samples))
+
+    def window() -> Iterable[bytes]:
+        for position in range(start, start + count, BLOCK_FRAMES):
+            yield decoded.read_frames(position, min(BLOCK_FRAMES, start + count - position))
+
     destination = _stem_with_extension(destination_stem, ".wav")
     _write_pt_wav_with_bext(
         destination,
         sample_rate=decoded.frame_rate,
         channels=decoded.channels,
         sample_width=decoded.sample_width,
-        frames=decoded.iter_frames(),
+        frames=window(),
         time_reference_samples=ref.start_position_samples,
     )
     return "timestamped-wav", ref.start_position_samples, destination
@@ -246,16 +256,22 @@ def _export_logic_audio(
                 if export_mode != "reference-only":
                     copied_audio_files += 1
                 if export_mode == "copied-source":
+                    trimmed = ref.content_offset_samples > 0 or ref.content_duration_samples is not None
                     project.compatibility_warnings.append(
-                        f"Audio '{ref.filename}' was copied without a new timestamp; place it using the manifest."
+                        f"Audio '{ref.filename}' was copied without a new timestamp"
+                        + (" or trim" if trimmed else "")
+                        + "; place it using the manifest."
                     )
 
             manifest_files.append(
                 {
                     "file_index": file_index,
                     "filename": ref.filename,
+                    "clip_name": ref.clip_name or Path(ref.filename).stem,
                     "export_name": export_name,
                     "start_position_samples": ref.start_position_samples,
+                    "content_offset_samples": ref.content_offset_samples,
+                    "content_duration_samples": ref.content_duration_samples,
                     "take_number": ref.take_number,
                     "is_comp": ref.is_comp,
                     "comp_name": ref.comp_name,

{logic2ableton-2.3.1 → logic2ableton-2.3.2}/logic2ableton.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logic2ableton
-Version: 2.3.1
+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
@@ -319,6 +321,11 @@ 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.

{logic2ableton-2.3.1 → logic2ableton-2.3.2}/logic2ableton.egg-info/SOURCES.txt

@@ -30,6 +30,7 @@ logic2ableton.egg-info/top_level.txt
 logic2ableton/data/DefaultLiveSet.als
 tests/test_ableton_generator.py
 tests/test_ableton_parser.py
+tests/test_arrangement_regressions.py
 tests/test_cli.py
 tests/test_cli_protools.py
 tests/test_cli_reverse.py

logic2ableton-2.3.2/tests/test_arrangement_regressions.py

@@ -0,0 +1,180 @@
+"""Regressions from the 2026-09-16 review: region trims, loops, track identity, bounds."""
+
+import gzip
+import json
+import struct
+import wave
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+from logic2ableton.ableton_generator import _BUNDLED_TEMPLATE, generate_als
+from logic2ableton.ableton_parser import parse_ableton_project
+from logic2ableton.cli import main
+from logic2ableton.logic_parser import parse_logic_project
+from logic2ableton.logic_project_data import decode_project_data
+from logic2ableton.protools_parser import PT_TICKS_PER_QUARTER, _deobfuscate, parse_protools_session
+from logic2ableton.protools_transfer import generate_protools_transfer_from_logic
+from logic2ableton.timeline import TempoEvent, Timeline
+from scripts.fixture_builders import (
+    _PT_ZERO_TICKS,
+    _logic_object,
+    _pt_block,
+    _pt_midi_event,
+    _pt_string,
+    build_logic_arrangement_project_data,
+    build_synthetic_logicx,
+    build_synthetic_ptx,
+)
+
+RATE = 44_100
+
+
+def _three_level_wav(path: Path) -> Path:
+    """Six seconds of mono PCM: two seconds each at sample values 1000, 2000, 3000."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with wave.open(str(path), "wb") as handle:
+        handle.setparams((1, 2, RATE, 0, "NONE", "not compressed"))
+        for value in (1000, 2000, 3000):
+            handle.writeframes(struct.pack("<h", value) * RATE * 2)
+    return path
+
+
+def _logic_project(tmp_path: Path, *, tracks=None, placements=None) -> Path:
+    """A 120 BPM Logic project whose Guitar region plays seconds 2-4 of Guitar.wav."""
+    data = build_logic_arrangement_project_data(
+        tracks=tracks or {1: "Guitar"},
+        sequences=[],
+        midi_regions=[],
+        audio_files={10: "Guitar.wav"},
+        audio_regions=[{"file": 10, "index": 0, "name": "Middle", "offset": 2 * RATE, "length": 2 * RATE}],
+        audio_placements=placements or [{"bar": 3, "track": 1, "file": 10, "lane": 1}],
+    )
+    logicx = build_synthetic_logicx(tmp_path / "source", project_data=data)
+    _three_level_wav(logicx / "Media" / "Audio Files" / "Guitar.wav")
+    return logicx
+
+
+def test_logic_to_protools_renders_only_the_region_slice(tmp_path):
+    project = parse_logic_project(_logic_project(tmp_path))
+    result = generate_protools_transfer_from_logic(project, tmp_path / "out")
+
+    exported = next(result.package_path.glob("Audio Files/**/*.wav"))
+    with wave.open(str(exported)) as handle:
+        frames = handle.getnframes()
+        first = struct.unpack("<h", handle.readframes(1))[0]
+    assert (frames, first) == (2 * RATE, 2000)
+
+    manifest = json.loads((result.package_path / "manifest.json").read_text(encoding="utf-8"))
+    entry = manifest["tracks"][0]["clips"][0]
+    assert (entry["content_offset_samples"], entry["content_duration_samples"]) == (2 * RATE, 2 * RATE)
+    # bar 3 at 120 BPM is eight beats, four seconds after bar 1
+    assert entry["time_reference_samples"] == 4 * RATE
+
+
+def test_tempo_map_keeps_the_trimmed_source_offset(tmp_path):
+    project = parse_logic_project(_logic_project(tmp_path))
+    project.timeline = Timeline(tempo_events=[TempoEvent(beat=4.0, bpm=60.0)], markers=[])
+    als = generate_als(project, tmp_path / "out", copy_audio=False, template_path=_BUNDLED_TEMPLATE)
+
+    clip = parse_ableton_project(als).clips[0]
+    assert clip.start_beats == 8.0
+    assert clip.source_in_seconds == 2.0
+
+
+def test_tempo_breakpoint_inside_a_trimmed_clip_maps_from_the_offset(tmp_path):
+    project = parse_logic_project(_logic_project(tmp_path, placements=[{"bar": 1.5, "track": 1, "file": 10, "lane": 1}]))
+    project.timeline = Timeline(tempo_events=[TempoEvent(beat=4.0, bpm=60.0)], markers=[])
+    als = generate_als(project, tmp_path / "out", copy_audio=False, template_path=_BUNDLED_TEMPLATE)
+
+    root = ET.fromstring(gzip.decompress(als.read_bytes()))
+    markers = [(float(m.get("SecTime")), float(m.get("BeatTime"))) for m in root.findall(".//AudioClip/WarpMarkers/WarpMarker")]
+    # Region at beat 2 plays from source second 2 (content beat 4 at 120 BPM);
+    # the change to 60 BPM at beat 4 is one second later in source and two beats later in content.
+    assert markers[:3] == [(0.0, 0.0), (2.0, 4.0), (3.0, 6.0)]
+    assert parse_ableton_project(als).clips[0].source_in_seconds == 2.0
+
+
+def test_looped_audio_region_becomes_repeated_clips(tmp_path):
+    # The region is two seconds (four beats at 120 BPM); the loop spans 14 beats.
+    logicx = _logic_project(tmp_path, placements=[{"bar": 1, "track": 1, "file": 10, "lane": 1, "loop_beats": 14}])
+    project = parse_logic_project(logicx)
+
+    clips = [(c.start_beats, c.content_offset_samples, c.content_duration_samples) for c in project.audio_files]
+    assert clips == [
+        (0.0, 2 * RATE, 2 * RATE),
+        (4.0, 2 * RATE, 2 * RATE),
+        (8.0, 2 * RATE, 2 * RATE),
+        (12.0, 2 * RATE, RATE),
+    ]
+    assert any("looped audio region" in warning and "x4" in warning for warning in project.compatibility_warnings)
+
+    als = generate_als(project, tmp_path / "out", copy_audio=False, template_path=_BUNDLED_TEMPLATE)
+    rendered = parse_ableton_project(als).clips
+    assert [(c.start_beats, c.end_beats) for c in rendered] == [(0.0, 4.0), (4.0, 8.0), (8.0, 12.0), (12.0, 14.0)]
+
+
+def test_same_named_logic_tracks_stay_separate(tmp_path):
+    logicx = _logic_project(
+        tmp_path,
+        tracks={1: "Guitar", 2: "Guitar"},
+        placements=[
+            {"bar": 1, "track": 1, "file": 10, "lane": 1},
+            {"bar": 1, "track": 2, "file": 10, "lane": 2},
+        ],
+    )
+    project = parse_logic_project(logicx)
+    assert project.track_names == ["Guitar", "Guitar (2)"]
+    assert sorted(ref.track_name for ref in project.audio_files) == ["Guitar", "Guitar (2)"]
+    assert any("were numbered" in warning for warning in project.compatibility_warnings)
+
+    als = generate_als(project, tmp_path / "out", copy_audio=False, template_path=_BUNDLED_TEMPLATE)
+    root = ET.fromstring(gzip.decompress(als.read_bytes()))
+    assert len(root.findall(".//Tracks/AudioTrack")) == 2
+
+
+def test_short_project_data_does_not_raise():
+    blob = _logic_object("Song", b"\x00" * 142)
+    assert len(blob) == 174
+    assert decode_project_data(blob).regions == []
+
+
+def test_protools_midi_chunk_search_stays_inside_its_block(tmp_path):
+    ptx = build_synthetic_ptx(tmp_path, midi=False)
+    raw = _deobfuscate(ptx.read_bytes())
+    for index, pitch in enumerate((60, 64, 67)):
+        event = _pt_midi_event(500_000_000, pitch, PT_TICKS_PER_QUARTER, 100)
+        payload = b"MdNLB" + b"\x00" * 6 + struct.pack("<I", 1) + event
+        if index == 0:
+            payload += b"\x00" * 40  # unused tail bytes inside the first chunk's block
+        raw += _pt_block(1, 0x2000, payload)
+    raw += _pt_block(1, 0x2519, _pt_block(2, 0x251A, b"\x00\x00" + _pt_string("Third chunk")))
+    raw += _pt_block(1, 0x2634, _pt_block(2, 0x2633, _pt_block(2, 0x2628, b"\x00\x00") + struct.pack("<I", 2)))
+    placement = _pt_block(
+        2, 0x104F,
+        b"\x00\x00" + struct.pack("<I", 0) + b"\x00" + (_PT_ZERO_TICKS + 4 * PT_TICKS_PER_QUARTER).to_bytes(5, "little"),
+    )
+    raw += _pt_block(1, 0x1058, b"\x00\x00" + _pt_block(2, 0x1057, _pt_block(2, 0x1056, placement)))
+    ptx.write_bytes(_deobfuscate(raw))
+
+    session = parse_protools_session(ptx)
+    assert [note.pitch for note in session.midi_tracks[0].notes] == [67]
+
+
+def test_generation_failure_is_written_into_the_saved_report(tmp_path, capsys):
+    logicx = _logic_project(tmp_path)
+    bad_template = tmp_path / "invalid-template.als"
+    bad_template.write_bytes(gzip.compress(b"<Ableton><LiveSet><Tracks/></LiveSet></Ableton>"))
+
+    exit_code = main([
+        str(logicx), "--output", str(tmp_path / "out"), "--json-progress", "--template", str(bad_template),
+    ])
+    event = json.loads(capsys.readouterr().out.strip().splitlines()[-1])
+
+    assert exit_code == 1
+    assert event["stage"] == "error"
+    assert event["failure_stage"] == "generating"
+    assert "No AudioTrack found" in event["error"]
+    assert "No AudioTrack found" in event["report"]
+    saved = Path(event["report_path"]).read_text(encoding="utf-8")
+    assert "CONVERSION FAILED" in saved and "No AudioTrack found" in saved
+    assert "TRACKS TRANSFERRED" in saved  # the analysis report is kept

logic2ableton-2.3.1/logic2ableton/__init__.py

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