auto-editor 27.0.0__tar.gz → 27.1.1__tar.gz

{auto_editor-27.0.0 → auto_editor-27.1.1}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: auto-editor
-Version: 27.0.0
+Version: 27.1.1
 Summary: Auto-Editor: Effort free video editing!
 Author-email: WyattBlue <wyattblue@auto-editor.com>
-License: Unlicense
+License-Expression: Unlicense
 Project-URL: Bug Tracker, https://github.com/WyattBlue/auto-editor/issues
 Project-URL: Source Code, https://github.com/WyattBlue/auto-editor
 Project-URL: homepage, https://auto-editor.com

auto_editor-27.1.1/auto_editor/__init__.py

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

{auto_editor-27.0.0 → auto_editor-27.1.1}/auto_editor/__main__.py

@@ -75,6 +75,7 @@ class Args:
 
     # Audio Rendering
     audio_codec: str = "auto"
+    audio_layout: str | None = None
     audio_bitrate: str = "auto"
     mix_audio_streams: bool = False
     keep_tracks_separate: bool = False
@@ -336,6 +337,13 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         metavar="ENCODER",
         help="Set audio codec for output media",
     )
+    parser.add_argument(
+        "--audio-layout",
+        "-channel-layout",
+        "-layout",
+        metavar="LAYOUT",
+        help="Set the audio layout for the output media/timeline",
+    )
     parser.add_argument(
         "--audio-bitrate",
         "-b:a",

{auto_editor-27.0.0 → auto_editor-27.1.1}/auto_editor/cmds/desc.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import sys
 from dataclasses import dataclass, field
 
-from auto_editor.ffwrapper import initFileInfo
+from auto_editor.ffwrapper import FileInfo
 from auto_editor.utils.log import Log
 from auto_editor.vanparse import ArgumentParser
 
@@ -22,7 +22,7 @@ def desc_options(parser: ArgumentParser) -> ArgumentParser:
 def main(sys_args: list[str] = sys.argv[1:]) -> None:
     args = desc_options(ArgumentParser("desc")).parse_args(DescArgs, sys_args)
     for path in args.input:
-        src = initFileInfo(path, Log())
+        src = FileInfo.init(path, Log())
         if src.description is not None:
             sys.stdout.write(f"\n{src.description}\n\n")
         else:

{auto_editor-27.0.0 → auto_editor-27.1.1}/auto_editor/cmds/info.py

@@ -5,7 +5,7 @@ import sys
 from dataclasses import dataclass, field
 from typing import Any, Literal, TypedDict
 
-from auto_editor.ffwrapper import initFileInfo
+from auto_editor.ffwrapper import FileInfo
 from auto_editor.json import dump
 from auto_editor.make_layers import make_sane_timebase
 from auto_editor.timeline import v3
@@ -102,7 +102,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
             file_info[file] = {"type": "timeline"}
             continue
 
-        src = initFileInfo(file, log)
+        src = FileInfo.init(file, log)
 
         if len(src.videos) + len(src.audios) + len(src.subtitles) == 0:
             file_info[file] = {"type": "unknown"}

{auto_editor-27.0.0 → auto_editor-27.1.1}/auto_editor/cmds/levels.py

@@ -9,7 +9,7 @@ import bv
 import numpy as np
 
 from auto_editor.analyze import *
-from auto_editor.ffwrapper import initFileInfo
+from auto_editor.ffwrapper import FileInfo
 from auto_editor.lang.palet import env
 from auto_editor.lib.contracts import is_bool, is_nat, is_nat1, is_str, is_void, orc
 from auto_editor.utils.bar import initBar
@@ -87,7 +87,7 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
     bar = initBar("none")
     log = Log(quiet=True)
 
-    sources = [initFileInfo(path, log) for path in args.input]
+    sources = [FileInfo.init(path, log) for path in args.input]
     if len(sources) < 1:
         log.error("levels needs at least one input file")
 

{auto_editor-27.0.0 → auto_editor-27.1.1}/auto_editor/cmds/repl.py

@@ -7,7 +7,7 @@ from os import environ
 
 import auto_editor
 from auto_editor.analyze import initLevels
-from auto_editor.ffwrapper import initFileInfo
+from auto_editor.ffwrapper import FileInfo
 from auto_editor.lang.palet import ClosingError, Lexer, Parser, env, interpret
 from auto_editor.lang.stdenv import make_standard_env
 from auto_editor.lib.data_structs import print_str
@@ -48,11 +48,6 @@ def repl_options(parser: ArgumentParser) -> ArgumentParser:
         type=frame_rate,
         help="Set custom timebase",
     )
-    parser.add_argument(
-        "--temp-dir",
-        metavar="PATH",
-        help="Set where the temporary directory is located",
-    )
     return parser
 
 
@@ -60,8 +55,8 @@ def main(sys_args: list[str] = sys.argv[1:]) -> None:
     args = repl_options(ArgumentParser(None)).parse_args(REPL_Args, sys_args)
 
     if args.input:
-        log = Log(quiet=True, temp_dir=args.temp_dir)
-        sources = [initFileInfo(path, log) for path in args.input]
+        log = Log(quiet=True)
+        sources = [FileInfo.init(path, log) for path in args.input]
         src = sources[0]
         tb = src.get_fps() if args.timebase is None else args.timebase
         env["timebase"] = tb

{auto_editor-27.0.0 → auto_editor-27.1.1}/auto_editor/cmds/test.py

@@ -14,7 +14,7 @@ from time import perf_counter
 import bv
 import numpy as np
 
-from auto_editor.ffwrapper import FileInfo, initFileInfo
+from auto_editor.ffwrapper import FileInfo
 from auto_editor.lang.palet import Lexer, Parser, env, interpret
 from auto_editor.lang.stdenv import make_standard_env
 from auto_editor.lib.data_structs import Char
@@ -62,7 +62,7 @@ log = Log()
 
 
 def fileinfo(path: str) -> FileInfo:
-    return initFileInfo(path, log)
+    return FileInfo.init(path, log)
 
 
 def calculate_sha256(filename: str) -> str:
@@ -186,6 +186,7 @@ class Runner:
             assert container.duration is not None
             assert container.duration > 17300000 and container.duration < 2 << 24
 
+            assert len(container.streams) == 2
             video = container.streams[0]
             audio = container.streams[1]
             assert isinstance(video, bv.VideoStream)
@@ -199,6 +200,29 @@ class Runner:
             assert audio.codec.name == "aac"
             assert audio.sample_rate == 48000
             assert audio.language == "eng"
+            assert audio.layout.name == "stereo"
+
+    def test_to_mono(self) -> None:
+        out = self.main(["example.mp4"], ["-layout", "mono"], output="example_mono.mp4")
+        with bv.open(out) as container:
+            assert container.duration is not None
+            assert container.duration > 17300000 and container.duration < 2 << 24
+
+            assert len(container.streams) == 2
+            video = container.streams[0]
+            audio = container.streams[1]
+            assert isinstance(video, bv.VideoStream)
+            assert isinstance(audio, bv.AudioStream)
+            assert video.base_rate == 30
+            assert video.average_rate is not None
+            assert video.average_rate == 30, video.average_rate
+            assert (video.width, video.height) == (1280, 720)
+            assert video.codec.name == "h264"
+            assert video.language == "eng"
+            assert audio.codec.name == "aac"
+            assert audio.sample_rate == 48000
+            assert audio.language == "eng"
+            assert audio.layout.name == "mono"
 
     # PR #260
     def test_high_speed(self):
@@ -332,8 +356,18 @@ class Runner:
         assert cn.videos[0].height == 380
         assert cn.audios[0].samplerate == 48000
 
+    # def test_premiere_multi(self):
+    #     p_xml = self.main([f"resources/multi-track.mov"], ["-exp"], "multi.xml")
+
+    #     cn = fileinfo(self.main([p_xml], []))
+    #     assert len(cn.videos) == 1
+    #     assert len(cn.audios) == 2
+
     def test_premiere(self):
         for test_name in all_files:
+            if test_name == "multi-track.mov":
+                continue
+
             p_xml = self.main([f"resources/{test_name}"], ["-exp"], "out.xml")
             self.main([p_xml], [])
 

{auto_editor-27.0.0 → auto_editor-27.1.1}/auto_editor/edit.py

@@ -5,16 +5,15 @@ import sys
 from fractions import Fraction
 from heapq import heappop, heappush
 from os.path import splitext
+from pathlib import Path
 from subprocess import run
 from typing import TYPE_CHECKING, Any
 
 import bv
-from bv import AudioResampler, Codec
 
-from auto_editor.ffwrapper import FileInfo, initFileInfo
+from auto_editor.ffwrapper import FileInfo
 from auto_editor.lib.contracts import is_int, is_str
 from auto_editor.make_layers import clipify, make_av, make_timeline
-from auto_editor.output import Ensure, parse_bitrate
 from auto_editor.render.audio import make_new_audio
 from auto_editor.render.subtitle import make_new_subtitles
 from auto_editor.render.video import render_av
@@ -30,14 +29,18 @@ if TYPE_CHECKING:
 
 
 def set_output(
-    out: str | None, _export: str | None, src: FileInfo | None, log: Log
+    out: str | None, _export: str | None, path: Path | None, log: Log
 ) -> tuple[str, dict[str, Any]]:
-    if src is None:
-        root, ext = "out", ".mp4"
+    if out is None:
+        if path is None:
+            log.error("`--output` must be set.")  # When a timeline file is the input.
+        root, ext = splitext(path)
     else:
-        root, ext = splitext(src.path if out is None else out)
-        if ext == "":
-            ext = src.path.suffix
+        root, ext = splitext(out)
+
+    if ext == "":
+        # Use `mp4` as the default, because it is most compatible.
+        ext = ".mp4" if path is None else path.suffix
 
     if _export is None:
         if ext == ".xml":
@@ -85,11 +88,11 @@ def set_video_codec(
 
     if ctr.vcodecs is not None and codec not in ctr.vcodecs:
         try:
-            cobj = Codec(codec, "w")
+            cobj = bv.Codec(codec, "w")
         except bv.codec.codec.UnknownCodecError:
             log.error(f"Unknown encoder: {codec}")
         # Normalize encoder names
-        if cobj.id not in (Codec(x, "w").id for x in ctr.vcodecs):
+        if cobj.id not in (bv.Codec(x, "w").id for x in ctr.vcodecs):
             log.error(codec_error.format(codec, out_ext))
 
     return codec
@@ -113,11 +116,11 @@ def set_audio_codec(
 
     if ctr.acodecs is None or codec not in ctr.acodecs:
         try:
-            cobj = Codec(codec, "w")
+            cobj = bv.Codec(codec, "w")
         except bv.codec.codec.UnknownCodecError:
             log.error(f"Unknown encoder: {codec}")
         # Normalize encoder names
-        if cobj.id not in (Codec(x, "w").id for x in ctr.acodecs):
+        if cobj.id not in (bv.Codec(x, "w").id for x in ctr.acodecs):
             log.error(codec_error.format(codec, out_ext))
 
     return codec
@@ -160,7 +163,7 @@ def parse_export(export: str, log: Log) -> dict[str, Any]:
 
 def edit_media(paths: list[str], args: Args, log: Log) -> None:
     bar = initBar(args.progress)
-    tl = None
+    tl = src = use_path = None
 
     if args.keep_tracks_separate:
         log.deprecated("--keep-tracks-separate is deprecated.")
@@ -172,31 +175,20 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
             from auto_editor.formats.fcp7 import fcp7_read_xml
 
             tl = fcp7_read_xml(paths[0], log)
-            assert tl.src is not None
-            sources: list[FileInfo] = [tl.src]
-            src: FileInfo | None = tl.src
-
         elif path_ext == ".mlt":
             from auto_editor.formats.shotcut import shotcut_read_mlt
 
             tl = shotcut_read_mlt(paths[0], log)
-            assert tl.src is not None
-            sources = [tl.src]
-            src = tl.src
-
         elif path_ext == ".json":
             from auto_editor.formats.json import read_json
 
             tl = read_json(paths[0], log)
-            sources = [] if tl.src is None else [tl.src]
-            src = tl.src
         else:
-            sources = [initFileInfo(path, log) for path in paths]
-            src = None if not sources else sources[0]
-
-    del paths
+            sources = [FileInfo.init(path, log) for path in paths]
+            src = sources[0]
+            use_path = src.path
 
-    output, export_ops = set_output(args.output, args.export, src, log)
+    output, export_ops = set_output(args.output, args.export, use_path, log)
     assert "export" in export_ops
     export = export_ops["export"]
 
@@ -256,7 +248,8 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
         from auto_editor.formats.fcp11 import fcp11_write_xml
         from auto_editor.timeline import set_stream_to_0
 
-        set_stream_to_0(tl, log)
+        assert src is not None
+        set_stream_to_0(src, tl, log)
         fcp11_write_xml(export_ops["name"], 10, output, True, tl, log)
         return
 
@@ -269,7 +262,7 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
     out_ext = splitext(output)[1].replace(".", "")
 
     # Check if export options make sense.
-    ctr = container_constructor(out_ext.lower())
+    ctr = container_constructor(out_ext.lower(), log)
 
     if ctr.samplerate is not None and args.sample_rate not in ctr.samplerate:
         log.error(f"'{out_ext}' container only supports samplerates: {ctr.samplerate}")
@@ -278,8 +271,6 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
     args.audio_codec = set_audio_codec(args.audio_codec, src, out_ext, ctr, log)
 
     def make_media(tl: v3, output_path: str) -> None:
-        assert src is not None
-
         options = {}
         mov_flags = []
         if args.fragmented and not args.no_fragmented:
@@ -303,51 +294,29 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
             output_stream, vframes = None, iter([])
 
         # Setup audio
-        if ctr.default_aud != "none":
-            ensure = Ensure(bar, samplerate, log)
-            audio_paths = make_new_audio(tl, ctr, ensure, args, bar, log)
-        else:
-            audio_paths = []
-
-        if len(audio_paths) > 1 and ctr.max_audios == 1:
-            log.warning("Dropping extra audio streams (container only allows one)")
-            audio_paths = audio_paths[0:1]
-
-        if audio_paths:
-            try:
-                audio_encoder = bv.Codec(args.audio_codec, "w")
-            except bv.FFmpegError as e:
-                log.error(e)
-            if audio_encoder.audio_formats is None:
-                log.error(f"{args.audio_codec}: No known audio formats avail.")
-            audio_format = audio_encoder.audio_formats[0]
-            resampler = AudioResampler(format=audio_format, layout="stereo", rate=tl.sr)
+        try:
+            audio_encoder = bv.Codec(args.audio_codec, "w")
+        except bv.FFmpegError as e:
+            log.error(e)
+        if audio_encoder.audio_formats is None:
+            log.error(f"{args.audio_codec}: No known audio formats avail.")
+        fmt = audio_encoder.audio_formats[0]
 
         audio_streams: list[bv.AudioStream] = []
-        audio_inputs = []
-        audio_gen_frames = []
-        for i, audio_path in enumerate(audio_paths):
-            audio_stream = output.add_stream(
-                args.audio_codec,
-                format=audio_format,
-                rate=tl.sr,
-                time_base=Fraction(1, tl.sr),
-            )
-            if not isinstance(audio_stream, bv.AudioStream):
-                log.error(f"Not a known audio codec: {args.audio_codec}")
 
-            if args.audio_bitrate != "auto":
-                audio_stream.bit_rate = parse_bitrate(args.audio_bitrate, log)
-                log.debug(f"audio bitrate: {audio_stream.bit_rate}")
-            else:
-                log.debug(f"[auto] audio bitrate: {audio_stream.bit_rate}")
-            if i < len(src.audios) and src.audios[i].lang is not None:
-                audio_stream.metadata["language"] = src.audios[i].lang  # type: ignore
+        if ctr.default_aud == "none":
+            while len(tl.a) > 0:
+                tl.a.pop()
+        elif len(tl.a) > 1 and ctr.max_audios == 1:
+            log.warning("Dropping extra audio streams (container only allows one)")
+
+            while len(tl.a) > 1:
+                tl.a.pop()
 
-            audio_streams.append(audio_stream)
-            audio_input = bv.open(audio_path)
-            audio_inputs.append(audio_input)
-            audio_gen_frames.append(audio_input.decode(audio=0))
+        if len(tl.a) > 0:
+            audio_streams, audio_gen_frames = make_new_audio(output, fmt, tl, args, log)
+        else:
+            audio_streams, audio_gen_frames = [], [iter([])]
 
         # Setup subtitles
         if ctr.default_sub != "none" and not args.sn:
@@ -365,8 +334,8 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
             subtitle_stream = output.add_stream_from_template(
                 subtitle_input.streams.subtitles[0]
             )
-            if i < len(src.subtitles) and src.subtitles[i].lang is not None:
-                subtitle_stream.metadata["language"] = src.subtitles[i].lang  # type: ignore
+            if i < len(tl.T.subtitles) and (lang := tl.T.subtitles[i].lang) is not None:
+                subtitle_stream.metadata["language"] = lang
 
             subtitle_streams.append(subtitle_stream)
             sub_gen_frames.append(subtitle_input.demux(subtitles=0))
@@ -463,13 +432,11 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
                 break
 
             if should_get_audio:
-                for audio_stream, audio_frame in zip(audio_streams, audio_frames):
-                    for reframe in resampler.resample(audio_frame):
-                        assert reframe.pts is not None
-                        heappush(
-                            frame_queue,
-                            Priority(reframe.pts, reframe, audio_stream),
-                        )
+                for audio_stream, aframe in zip(audio_streams, audio_frames):
+                    if aframe is None:
+                        continue
+                    assert aframe.pts is not None
+                    heappush(frame_queue, Priority(aframe.pts, aframe, audio_stream))
             if should_get_sub:
                 for subtitle_stream, packet in zip(subtitle_streams, subtitle_frames):
                     if packet and packet.pts is not None:
@@ -511,8 +478,6 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
         bar.end()
 
         # Close resources
-        for audio_input in audio_inputs:
-            audio_input.close()
         for subtitle_input in subtitle_inputs:
             subtitle_input.close()
         output.close()
@@ -542,11 +507,9 @@ def edit_media(paths: list[str], args: Args, log: Log) -> None:
                 tl.v1.source, [clipify(padded_chunks, tl.v1.source)]
             )
             my_timeline = v3(
-                tl.v1.source,
                 tl.tb,
-                tl.sr,
-                tl.res,
                 "#000",
+                tl.template,
                 vspace,
                 aspace,
                 v1(tl.v1.source, padded_chunks),

auto_editor-27.1.1/auto_editor/ffwrapper.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from fractions import Fraction
+from pathlib import Path
+
+import bv
+
+from auto_editor.utils.log import Log
+
+
+def mux(input: Path, output: Path, stream: int) -> None:
+    input_container = bv.open(input, "r")
+    output_container = bv.open(output, "w")
+
+    input_audio_stream = input_container.streams.audio[stream]
+    output_audio_stream = output_container.add_stream("pcm_s16le")
+
+    for frame in input_container.decode(input_audio_stream):
+        output_container.mux(output_audio_stream.encode(frame))
+
+    output_container.mux(output_audio_stream.encode(None))
+
+    output_container.close()
+    input_container.close()
+
+
+@dataclass(slots=True, frozen=True)
+class VideoStream:
+    width: int
+    height: int
+    codec: str
+    fps: Fraction
+    duration: float
+    sar: Fraction
+    time_base: Fraction | None
+    pix_fmt: str | None
+    color_range: int
+    color_space: int
+    color_primaries: int
+    color_transfer: int
+    bitrate: int
+    lang: str | None
+
+
+@dataclass(slots=True, frozen=True)
+class AudioStream:
+    codec: str
+    samplerate: int
+    layout: str
+    channels: int
+    duration: float
+    bitrate: int
+    lang: str | None
+
+
+@dataclass(slots=True, frozen=True)
+class SubtitleStream:
+    codec: str
+    ext: str
+    lang: str | None
+
+
+@dataclass(slots=True, frozen=True)
+class FileInfo:
+    path: Path
+    bitrate: int
+    duration: float
+    description: str | None
+    videos: tuple[VideoStream, ...]
+    audios: tuple[AudioStream, ...]
+    subtitles: tuple[SubtitleStream, ...]
+
+    def get_res(self) -> tuple[int, int]:
+        if self.videos:
+            return self.videos[0].width, self.videos[0].height
+        return 1920, 1080
+
+    def get_fps(self) -> Fraction:
+        if self.videos:
+            return self.videos[0].fps
+        return Fraction(30)
+
+    def get_sr(self) -> int:
+        if self.audios:
+            return self.audios[0].samplerate
+        return 48000
+
+    @classmethod
+    def init(self, path: str, log: Log) -> FileInfo:
+        try:
+            cont = bv.open(path, "r")
+        except bv.error.FileNotFoundError:
+            log.error(f"Input file doesn't exist: {path}")
+        except bv.error.IsADirectoryError:
+            log.error(f"Expected a media file, but got a directory: {path}")
+        except bv.error.InvalidDataError:
+            log.error(f"Invalid data when processing: {path}")
+
+        videos: tuple[VideoStream, ...] = ()
+        audios: tuple[AudioStream, ...] = ()
+        subtitles: tuple[SubtitleStream, ...] = ()
+
+        for v in cont.streams.video:
+            if v.duration is not None and v.time_base is not None:
+                vdur = float(v.duration * v.time_base)
+            else:
+                vdur = 0.0
+
+            fps = v.average_rate
+            if (fps is None or fps < 1) and v.name in {"png", "mjpeg", "webp"}:
+                fps = Fraction(25)
+            if fps is None or fps == 0:
+                fps = Fraction(30)
+
+            if v.sample_aspect_ratio is None:
+                sar = Fraction(1)
+            else:
+                sar = v.sample_aspect_ratio
+
+            cc = v.codec_context
+
+            if v.name is None:
+                log.error(f"Can't detect codec for video stream {v}")
+
+            videos += (
+                VideoStream(
+                    v.width,
+                    v.height,
+                    v.codec.canonical_name,
+                    fps,
+                    vdur,
+                    sar,
+                    v.time_base,
+                    getattr(v.format, "name", None),
+                    cc.color_range,
+                    cc.colorspace,
+                    cc.color_primaries,
+                    cc.color_trc,
+                    0 if v.bit_rate is None else v.bit_rate,
+                    v.language,
+                ),
+            )
+
+        for a in cont.streams.audio:
+            adur = 0.0
+            if a.duration is not None and a.time_base is not None:
+                adur = float(a.duration * a.time_base)
+
+            a_cc = a.codec_context
+            audios += (
+                AudioStream(
+                    a_cc.codec.canonical_name,
+                    0 if a_cc.sample_rate is None else a_cc.sample_rate,
+                    a.layout.name,
+                    a_cc.channels,
+                    adur,
+                    0 if a_cc.bit_rate is None else a_cc.bit_rate,
+                    a.language,
+                ),
+            )
+
+        for s in cont.streams.subtitles:
+            codec = s.codec_context.name
+            sub_exts = {"mov_text": "srt", "ass": "ass", "webvtt": "vtt"}
+            ext = sub_exts.get(codec, "vtt")
+            subtitles += (SubtitleStream(codec, ext, s.language),)
+
+        desc = cont.metadata.get("description", None)
+        bitrate = 0 if cont.bit_rate is None else cont.bit_rate
+        dur = 0 if cont.duration is None else cont.duration / bv.time_base
+
+        cont.close()
+
+        return FileInfo(Path(path), bitrate, dur, desc, videos, audios, subtitles)
+
+    def __repr__(self) -> str:
+        return f"@{self.path.name}"

{auto_editor-27.0.0 → auto_editor-27.1.1}/auto_editor/formats/fcp11.py

@@ -59,13 +59,6 @@ def fcp11_write_xml(
             return "0s"
         return f"{val * tl.tb.denominator}/{tl.tb.numerator}s"
 
-    src = tl.src
-    assert src is not None
-
-    proj_name = src.path.stem
-    src_dur = int(src.duration * tl.tb)
-    tl_dur = src_dur if resolve else tl.out_len()
-
     if version == 11:
         ver_str = "1.11"
     elif version == 10:
@@ -76,7 +69,16 @@ def fcp11_write_xml(
     fcpxml = Element("fcpxml", version=ver_str)
     resources = SubElement(fcpxml, "resources")
 
+    src_dur = 0
+    tl_dur = 0 if resolve else tl.out_len()
+
     for i, one_src in enumerate(tl.unique_sources()):
+        if i == 0:
+            proj_name = one_src.path.stem
+            src_dur = int(one_src.duration * tl.tb)
+            if resolve:
+                tl_dur = src_dur
+
         SubElement(
             resources,
             "format",
@@ -113,7 +115,7 @@ def fcp11_write_xml(
         format="r1",
         tcStart="0s",
         tcFormat="NDF",
-        audioLayout="mono" if src.audios and src.audios[0].channels == 1 else "stereo",
+        audioLayout=tl.T.layout,
         audioRate="44.1k" if tl.sr == 44100 else "48k",
     )
     spine = SubElement(sequence, "spine")