auto-editor 28.1.0__py3-none-any.whl → 29.0.0__py3-none-any.whl

auto_editor/exports/fcp11.py

@@ -1,195 +0,0 @@
-import xml.etree.ElementTree as ET
-from fractions import Fraction
-from xml.etree.ElementTree import Element, ElementTree, SubElement, indent
-
-from auto_editor.ffwrapper import FileInfo
-from auto_editor.timeline import Clip, v3
-from auto_editor.utils.log import Log
-
-"""
-Export a FCPXML 11 file readable with Final Cut Pro 10.6.8 or later.
-
-See docs here:
-https://developer.apple.com/documentation/professional_video_applications/fcpxml_reference
-
-"""
-
-
-def get_colorspace(src: FileInfo) -> str:
-    # See: https://developer.apple.com/documentation/professional_video_applications/fcpxml_reference/asset#3686496
-
-    if not src.videos:
-        return "1-1-1 (Rec. 709)"
-
-    s = src.videos[0]
-    if s.pix_fmt == "rgb24":
-        return "sRGB IEC61966-2.1"
-    if s.color_space == 5:  # "bt470bg"
-        return "5-1-6 (Rec. 601 PAL)"
-    if s.color_space == 6:  # "smpte170m"
-        return "6-1-6 (Rec. 601 NTSC)"
-    if s.color_primaries == 9:  # "bt2020"
-        # See: https://video.stackexchange.com/questions/22059/how-to-identify-hdr-video
-        if s.color_transfer in {16, 18}:  # "smpte2084" "arib-std-b67"
-            return "9-18-9 (Rec. 2020 HLG)"
-        return "9-1-9 (Rec. 2020)"
-
-    return "1-1-1 (Rec. 709)"
-
-
-def make_name(src: FileInfo, tb: Fraction) -> str:
-    if src.get_res()[1] == 720 and tb == 30:
-        return "FFVideoFormat720p30"
-    if src.get_res()[1] == 720 and tb == 25:
-        return "FFVideoFormat720p25"
-    return "FFVideoFormatRateUndefined"
-
-
-def parseSMPTE(val: str, fps: Fraction, log: Log) -> int:
-    if len(val) == 0:
-        return 0
-    try:
-        parts = val.split(":")
-        if len(parts) != 4:
-            raise ValueError(f"Invalid SMPTE format: {val}")
-
-        hours, minutes, seconds, frames = map(int, parts)
-
-        if (
-            hours < 0
-            or minutes < 0
-            or minutes >= 60
-            or seconds < 0
-            or seconds >= 60
-            or frames < 0
-        ):
-            raise ValueError(f"Invalid SMPTE values: {val}")
-
-        if frames >= fps:
-            raise ValueError(f"Frame count {frames} exceeds fps {fps}")
-
-        total_frames = (hours * 3600 + minutes * 60 + seconds) * fps + frames
-        return int(round(total_frames))
-    except (ValueError, ZeroDivisionError) as e:
-        log.error(f"Cannot parse SMPTE timecode '{val}': {e}")
-
-
-def fcp11_write_xml(
-    group_name: str, version: int, output: str, resolve: bool, tl: v3, log: Log
-) -> None:
-    def fraction(val: int) -> str:
-        if val == 0:
-            return "0s"
-        return f"{val * tl.tb.denominator}/{tl.tb.numerator}s"
-
-    if version == 11:
-        ver_str = "1.11"
-    elif version == 10:
-        ver_str = "1.10"
-    else:
-        log.error(f"Unknown final cut pro version: {version}")
-
-    fcpxml = Element("fcpxml", version=ver_str)
-    resources = SubElement(fcpxml, "resources")
-
-    src_dur = 0
-    tl_dur = 0 if resolve else len(tl)
-
-    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",
-            id=f"r{i * 2 + 1}",
-            name=make_name(one_src, tl.tb),
-            frameDuration=fraction(1),
-            width=f"{tl.res[0]}",
-            height=f"{tl.res[1]}",
-            colorSpace=get_colorspace(one_src),
-        )
-
-        startPoint = parseSMPTE(one_src.timecode, tl.tb, log)
-        r2 = SubElement(
-            resources,
-            "asset",
-            id=f"r{i * 2 + 2}",
-            name=one_src.path.stem,
-            start=fraction(startPoint),
-            hasVideo="1" if one_src.videos else "0",
-            format=f"r{i * 2 + 1}",
-            hasAudio="1" if one_src.audios else "0",
-            audioSources="1",
-            audioChannels=f"{2 if not one_src.audios else one_src.audios[0].channels}",
-            duration=fraction(tl_dur),
-        )
-        SubElement(
-            r2, "media-rep", kind="original-media", src=one_src.path.resolve().as_uri()
-        )
-
-    lib = SubElement(fcpxml, "library")
-    evt = SubElement(lib, "event", name=group_name)
-    proj = SubElement(evt, "project", name=proj_name)
-    sequence = SubElement(
-        proj,
-        "sequence",
-        format="r1",
-        tcStart="0s",
-        tcFormat="NDF",
-        audioLayout=tl.T.layout,
-        audioRate="44.1k" if tl.sr == 44100 else "48k",
-    )
-    spine = SubElement(sequence, "spine")
-
-    def make_clip(ref: str, clip: Clip) -> None:
-        startPoint = parseSMPTE(clip.src.timecode, tl.tb, log)
-
-        clip_properties = {
-            "name": proj_name,
-            "ref": ref,
-            "offset": fraction(clip.start + startPoint),
-            "duration": fraction(clip.dur),
-            "start": fraction(clip.offset + startPoint),
-            "tcFormat": "NDF",
-        }
-        asset = SubElement(spine, "asset-clip", clip_properties)
-        if clip.speed != 1:
-            # See the "Time Maps" section.
-            # https://developer.apple.com/documentation/professional_video_applications/fcpxml_reference/story_elements/timemap/
-
-            timemap = SubElement(asset, "timeMap")
-            SubElement(timemap, "timept", time="0s", value="0s", interp="smooth2")
-            SubElement(
-                timemap,
-                "timept",
-                time=fraction(int(src_dur // clip.speed)),
-                value=fraction(src_dur),
-                interp="smooth2",
-            )
-
-    if tl.v and tl.v[0]:
-        clips = [clip for clip in tl.v[0] if isinstance(clip, Clip)]
-    elif tl.a and tl.a[0]:
-        clips = tl.a[0]
-    else:
-        clips = []
-
-    all_refs: list[str] = ["r2"]
-    if resolve:
-        for i in range(1, len(tl.a)):
-            all_refs.append(f"r{(i + 1) * 2}")
-
-    for my_ref in reversed(all_refs):
-        for clip in clips:
-            make_clip(my_ref, clip)
-
-    tree = ElementTree(fcpxml)
-    indent(tree, space="\t", level=0)
-    if output == "-":
-        print(ET.tostring(fcpxml, encoding="unicode"))
-    else:
-        tree.write(output, xml_declaration=True, encoding="utf-8")

auto_editor/exports/fcp7.py

@@ -1,313 +0,0 @@
-from __future__ import annotations
-
-import xml.etree.ElementTree as ET
-from fractions import Fraction
-from math import ceil
-from xml.etree.ElementTree import Element
-
-from auto_editor.ffwrapper import FileInfo
-from auto_editor.timeline import Clip, v3
-
-"""
-Premiere Pro uses the Final Cut Pro 7 XML Interchange Format
-
-See docs here:
-https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/FinalCutPro_XML/Elements/Elements.html
-
-Also, Premiere itself will happily output subtlety incorrect XML files that don't
-come back the way they started.
-"""
-
-DEPTH = "16"
-
-
-def set_tb_ntsc(tb: Fraction) -> tuple[int, str]:
-    # See chart: https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/FinalCutPro_XML/FrameRate/FrameRate.html#//apple_ref/doc/uid/TP30001158-TPXREF103
-    if tb == Fraction(24000, 1001):
-        return 24, "TRUE"
-    if tb == Fraction(30000, 1001):
-        return 30, "TRUE"
-    if tb == Fraction(60000, 1001):
-        return 60, "TRUE"
-
-    ctb = ceil(tb)
-    if ctb not in {24, 30, 60} and ctb * Fraction(999, 1000) == tb:
-        return ctb, "TRUE"
-
-    return int(tb), "FALSE"
-
-
-def speedup(speed: float) -> Element:
-    fil = Element("filter")
-    effect = ET.SubElement(fil, "effect")
-    ET.SubElement(effect, "name").text = "Time Remap"
-    ET.SubElement(effect, "effectid").text = "timeremap"
-
-    para = ET.SubElement(effect, "parameter", authoringApp="PremierePro")
-    ET.SubElement(para, "parameterid").text = "variablespeed"
-    ET.SubElement(para, "name").text = "variablespeed"
-    ET.SubElement(para, "valuemin").text = "0"
-    ET.SubElement(para, "valuemax").text = "1"
-    ET.SubElement(para, "value").text = "0"
-
-    para2 = ET.SubElement(effect, "parameter", authoringApp="PremierePro")
-    ET.SubElement(para2, "parameterid").text = "speed"
-    ET.SubElement(para2, "name").text = "speed"
-    ET.SubElement(para2, "valuemin").text = "-100000"
-    ET.SubElement(para2, "valuemax").text = "100000"
-    ET.SubElement(para2, "value").text = str(speed)
-
-    para3 = ET.SubElement(effect, "parameter", authoringApp="PremierePro")
-    ET.SubElement(para3, "parameterid").text = "frameblending"
-    ET.SubElement(para3, "name").text = "frameblending"
-    ET.SubElement(para3, "value").text = "FALSE"
-
-    return fil
-
-
-def media_def(
-    filedef: Element, url: str, src: FileInfo, tl: v3, tb: int, ntsc: str
-) -> None:
-    ET.SubElement(filedef, "name").text = src.path.stem
-    ET.SubElement(filedef, "pathurl").text = url
-
-    timecode = ET.SubElement(filedef, "timecode")
-    ET.SubElement(timecode, "string").text = "00:00:00:00"
-    ET.SubElement(timecode, "displayformat").text = "NDF"
-    rate = ET.SubElement(timecode, "rate")
-    ET.SubElement(rate, "timebase").text = f"{tb}"
-    ET.SubElement(rate, "ntsc").text = ntsc
-
-    rate = ET.SubElement(filedef, "rate")
-    ET.SubElement(rate, "timebase").text = f"{tb}"
-    ET.SubElement(rate, "ntsc").text = ntsc
-
-    # DaVinci Resolve needs this tag even though it's blank
-    ET.SubElement(filedef, "duration").text = ""
-
-    mediadef = ET.SubElement(filedef, "media")
-
-    if len(src.videos) > 0:
-        videodef = ET.SubElement(mediadef, "video")
-
-        vschar = ET.SubElement(videodef, "samplecharacteristics")
-        rate = ET.SubElement(vschar, "rate")
-        ET.SubElement(rate, "timebase").text = f"{tb}"
-        ET.SubElement(rate, "ntsc").text = ntsc
-        ET.SubElement(vschar, "width").text = f"{tl.res[0]}"
-        ET.SubElement(vschar, "height").text = f"{tl.res[1]}"
-        ET.SubElement(vschar, "pixelaspectratio").text = "square"
-
-    for aud in src.audios:
-        audiodef = ET.SubElement(mediadef, "audio")
-        aschar = ET.SubElement(audiodef, "samplecharacteristics")
-        ET.SubElement(aschar, "depth").text = DEPTH
-        ET.SubElement(aschar, "samplerate").text = f"{tl.sr}"
-        ET.SubElement(audiodef, "channelcount").text = f"{aud.channels}"
-
-
-def resolve_write_audio(audio: Element, make_filedef, tl: v3) -> None:
-    for t, aclips in enumerate(tl.a):
-        track = ET.SubElement(audio, "track")
-        for j, aclip in enumerate(aclips):
-            src = aclip.src
-
-            _start = f"{aclip.start}"
-            _end = f"{aclip.start + aclip.dur}"
-            _in = f"{aclip.offset}"
-            _out = f"{aclip.offset + aclip.dur}"
-
-            if not src.videos:
-                clip_item_num = j + 1
-            else:
-                clip_item_num = len(aclips) + 1 + j
-
-            clipitem = ET.SubElement(track, "clipitem", id=f"clipitem-{clip_item_num}")
-            ET.SubElement(clipitem, "name").text = src.path.stem
-            ET.SubElement(clipitem, "start").text = _start
-            ET.SubElement(clipitem, "end").text = _end
-            ET.SubElement(clipitem, "enabled").text = "TRUE"
-            ET.SubElement(clipitem, "in").text = _in
-            ET.SubElement(clipitem, "out").text = _out
-
-            make_filedef(clipitem, aclip.src)
-
-            sourcetrack = ET.SubElement(clipitem, "sourcetrack")
-            ET.SubElement(sourcetrack, "mediatype").text = "audio"
-            ET.SubElement(sourcetrack, "trackindex").text = f"{t + 1}"
-
-            if src.videos:
-                link = ET.SubElement(clipitem, "link")
-                ET.SubElement(link, "linkclipref").text = f"clipitem-{j + 1}"
-                ET.SubElement(link, "mediatype").text = "video"
-                link = ET.SubElement(clipitem, "link")
-                ET.SubElement(link, "linkclipref").text = f"clipitem-{clip_item_num}"
-
-            if aclip.speed != 1:
-                clipitem.append(speedup(aclip.speed * 100))
-
-
-def premiere_write_audio(audio: Element, make_filedef, tl: v3) -> None:
-    ET.SubElement(audio, "numOutputChannels").text = "2"
-    aformat = ET.SubElement(audio, "format")
-    aschar = ET.SubElement(aformat, "samplecharacteristics")
-    ET.SubElement(aschar, "depth").text = DEPTH
-    ET.SubElement(aschar, "samplerate").text = f"{tl.sr}"
-
-    has_video = tl.v and tl.v[0]
-    t = 0
-    for aclips in tl.a:
-        for channelcount in range(0, 2):  # Because "stereo" is hardcoded.
-            t += 1
-            track = ET.Element(
-                "track",
-                currentExplodedTrackIndex=f"{channelcount}",
-                totalExplodedTrackCount="2",  # Because "stereo" is hardcoded.
-                premiereTrackType="Stereo",
-            )
-
-            if has_video:
-                ET.SubElement(track, "outputchannelindex").text = f"{channelcount + 1}"
-
-            for j, aclip in enumerate(aclips):
-                src = aclip.src
-
-                _start = f"{aclip.start}"
-                _end = f"{aclip.start + aclip.dur}"
-                _in = f"{aclip.offset}"
-                _out = f"{aclip.offset + aclip.dur}"
-
-                if not has_video:
-                    clip_item_num = j + 1
-                else:
-                    clip_item_num = len(aclips) + 1 + j + (t * len(aclips))
-
-                clipitem = ET.SubElement(
-                    track,
-                    "clipitem",
-                    id=f"clipitem-{clip_item_num}",
-                    premiereChannelType="stereo",
-                )
-                ET.SubElement(clipitem, "name").text = src.path.stem
-                ET.SubElement(clipitem, "enabled").text = "TRUE"
-                ET.SubElement(clipitem, "start").text = _start
-                ET.SubElement(clipitem, "end").text = _end
-                ET.SubElement(clipitem, "in").text = _in
-                ET.SubElement(clipitem, "out").text = _out
-
-                make_filedef(clipitem, aclip.src)
-
-                sourcetrack = ET.SubElement(clipitem, "sourcetrack")
-                ET.SubElement(sourcetrack, "mediatype").text = "audio"
-                ET.SubElement(sourcetrack, "trackindex").text = f"{t}"
-                labels = ET.SubElement(clipitem, "labels")
-                ET.SubElement(labels, "label2").text = "Iris"
-
-                if aclip.speed != 1:
-                    clipitem.append(speedup(aclip.speed * 100))
-
-            audio.append(track)
-
-
-def fcp7_write_xml(name: str, output: str, resolve: bool, tl: v3) -> None:
-    width, height = tl.res
-    timebase, ntsc = set_tb_ntsc(tl.tb)
-
-    src_to_url: dict[FileInfo, str] = {}
-    src_to_id: dict[FileInfo, str] = {}
-
-    file_defs: set[str] = set()  # Contains urls
-
-    for src in set(tl.sources):
-        the_id = f"file-{len(src_to_id) + 1}"
-        src_to_url[src] = f"{src.path.resolve()}"
-        src_to_id[src] = the_id
-
-    def make_filedef(clipitem: Element, src: FileInfo) -> None:
-        pathurl = src_to_url[src]
-        filedef = ET.SubElement(clipitem, "file", id=src_to_id[src])
-        if pathurl not in file_defs:
-            media_def(filedef, pathurl, src, tl, timebase, ntsc)
-            file_defs.add(pathurl)
-
-    xmeml = ET.Element("xmeml", version="5")
-    if resolve:
-        sequence = ET.SubElement(xmeml, "sequence")
-    else:
-        sequence = ET.SubElement(xmeml, "sequence", explodedTracks="true")
-
-    ET.SubElement(sequence, "name").text = name
-    ET.SubElement(sequence, "duration").text = f"{len(tl)}"
-    rate = ET.SubElement(sequence, "rate")
-    ET.SubElement(rate, "timebase").text = f"{timebase}"
-    ET.SubElement(rate, "ntsc").text = ntsc
-    media = ET.SubElement(sequence, "media")
-    video = ET.SubElement(media, "video")
-    vformat = ET.SubElement(video, "format")
-    vschar = ET.SubElement(vformat, "samplecharacteristics")
-
-    ET.SubElement(vschar, "width").text = f"{width}"
-    ET.SubElement(vschar, "height").text = f"{height}"
-    ET.SubElement(vschar, "pixelaspectratio").text = "square"
-
-    rate = ET.SubElement(vschar, "rate")
-    ET.SubElement(rate, "timebase").text = f"{timebase}"
-    ET.SubElement(rate, "ntsc").text = ntsc
-
-    if len(tl.v) > 0 and len(tl.v[0]) > 0:
-        track = ET.SubElement(video, "track")
-
-        for j, clip in enumerate(tl.v[0]):
-            assert isinstance(clip, Clip)
-
-            _start = f"{clip.start}"
-            _end = f"{clip.start + clip.dur}"
-            _in = f"{clip.offset}"
-            _out = f"{clip.offset + clip.dur}"
-
-            this_clipid = f"clipitem-{j + 1}"
-            clipitem = ET.SubElement(track, "clipitem", id=this_clipid)
-            ET.SubElement(clipitem, "name").text = src.path.stem
-            ET.SubElement(clipitem, "enabled").text = "TRUE"
-            ET.SubElement(clipitem, "start").text = _start
-            ET.SubElement(clipitem, "end").text = _end
-            ET.SubElement(clipitem, "in").text = _in
-            ET.SubElement(clipitem, "out").text = _out
-
-            make_filedef(clipitem, clip.src)
-
-            ET.SubElement(clipitem, "compositemode").text = "normal"
-            if clip.speed != 1:
-                clipitem.append(speedup(clip.speed * 100))
-
-            if resolve:
-                link = ET.SubElement(clipitem, "link")
-                ET.SubElement(link, "linkclipref").text = this_clipid
-                link = ET.SubElement(clipitem, "link")
-                ET.SubElement(
-                    link, "linkclipref"
-                ).text = f"clipitem-{(len(tl.v[0])) + j + 1}"
-                continue
-
-            for i in range(1 + len(src.audios) * 2):  # `2` because stereo.
-                link = ET.SubElement(clipitem, "link")
-                ET.SubElement(
-                    link, "linkclipref"
-                ).text = f"clipitem-{(i * (len(tl.v[0]))) + j + 1}"
-                ET.SubElement(link, "mediatype").text = "video" if i == 0 else "audio"
-                ET.SubElement(link, "trackindex").text = f"{max(i, 1)}"
-                ET.SubElement(link, "clipindex").text = f"{j + 1}"
-
-    # Audio definitions and clips
-    audio = ET.SubElement(media, "audio")
-    if resolve:
-        resolve_write_audio(audio, make_filedef, tl)
-    else:
-        premiere_write_audio(audio, make_filedef, tl)
-
-    tree = ET.ElementTree(xmeml)
-    ET.indent(tree, space="  ", level=0)
-    if output == "-":
-        print(ET.tostring(xmeml, encoding="unicode"))
-    else:
-        tree.write(output, xml_declaration=True, encoding="utf-8")

auto_editor/exports/json.py

@@ -1,63 +0,0 @@
-import sys
-
-from auto_editor.json import dump
-from auto_editor.timeline import Clip, v3
-from auto_editor.utils.log import Log
-
-
-def as_dict(self: v3) -> dict:
-    def aclip_to_dict(self: Clip) -> dict:
-        return {
-            "name": "audio",
-            "src": self.src,
-            "start": self.start,
-            "dur": self.dur,
-            "offset": self.offset,
-            "speed": self.speed,
-            "volume": self.volume,
-            "stream": self.stream,
-        }
-
-    v = []
-    a = []
-    for vlayer in self.v:
-        vb = [vobj.as_dict() for vobj in vlayer]
-        if vb:
-            v.append(vb)
-    for layer in self.a:
-        ab = [aclip_to_dict(clip) for clip in layer]
-        if ab:
-            a.append(ab)
-
-    return {
-        "version": "3",
-        "timebase": f"{self.tb.numerator}/{self.tb.denominator}",
-        "background": self.background,
-        "resolution": self.T.res,
-        "samplerate": self.T.sr,
-        "layout": self.T.layout,
-        "v": v,
-        "a": a,
-    }
-
-
-def make_json_timeline(ver: str, out: str, tl: v3, log: Log) -> None:
-    if ver not in {"v1", "v3"}:
-        log.error(f"Unknown timeline version: {ver}")
-
-    if out == "-":
-        outfile = sys.stdout
-    else:
-        outfile = open(out, "w")
-
-    if ver == "v3":
-        dump(as_dict(tl), outfile, indent=2)
-    else:
-        if tl.v1 is None:
-            log.error("Timeline can't be converted to v1 format")
-        dump(tl.v1.as_dict(), outfile, indent=2)
-
-    if out == "-":
-        print("")  # Flush stdout
-    else:
-        outfile.close()