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

auto_editor/exports/shotcut.py

@@ -1,147 +0,0 @@
-import xml.etree.ElementTree as ET
-
-from auto_editor.timeline import Clip, v3
-from auto_editor.utils.func import aspect_ratio, to_timecode
-
-"""
-Shotcut uses the MLT timeline format
-
-See docs here:
-https://mltframework.org/docs/mltxml/
-
-"""
-
-
-def shotcut_write_mlt(output: str, tl: v3) -> None:
-    mlt = ET.Element(
-        "mlt",
-        attrib={
-            "LC_NUMERIC": "C",
-            "version": "7.9.0",
-            "title": "Shotcut version 22.09.23",
-            "producer": "main_bin",
-        },
-    )
-
-    width, height = tl.res
-    num, den = aspect_ratio(width, height)
-    tb = tl.tb
-
-    ET.SubElement(
-        mlt,
-        "profile",
-        attrib={
-            "description": "automatic",
-            "width": f"{width}",
-            "height": f"{height}",
-            "progressive": "1",
-            "sample_aspect_num": "1",
-            "sample_aspect_den": "1",
-            "display_aspect_num": f"{num}",
-            "display_aspect_den": f"{den}",
-            "frame_rate_num": f"{tb.numerator}",
-            "frame_rate_den": f"{tb.denominator}",
-            "colorspace": "709",
-        },
-    )
-
-    playlist_bin = ET.SubElement(mlt, "playlist", id="main_bin")
-    ET.SubElement(playlist_bin, "property", name="xml_retain").text = "1"
-
-    global_out = to_timecode(len(tl) / tb, "standard")
-
-    producer = ET.SubElement(mlt, "producer", id="bg")
-
-    ET.SubElement(producer, "property", name="length").text = global_out
-    ET.SubElement(producer, "property", name="eof").text = "pause"
-    ET.SubElement(producer, "property", name="resource").text = "#000"  # background
-    ET.SubElement(producer, "property", name="mlt_service").text = "color"
-    ET.SubElement(producer, "property", name="mlt_image_format").text = "rgba"
-    ET.SubElement(producer, "property", name="aspect_ratio").text = "1"
-
-    playlist = ET.SubElement(mlt, "playlist", id="background")
-    ET.SubElement(
-        playlist,
-        "entry",
-        attrib={"producer": "bg", "in": "00:00:00.000", "out": global_out},
-    ).text = "1"
-
-    chains = 0
-    producers = 0
-
-    if tl.v:
-        clips = [clip for clip in tl.v[0] if isinstance(clip, Clip)]
-    elif tl.a:
-        clips = tl.a[0]
-    else:
-        clips = []
-
-    for clip in clips:
-        src = clip.src
-        length = to_timecode((clip.offset + clip.dur) / tb, "standard")
-
-        if clip.speed == 1:
-            resource = f"{src.path}"
-            caption = f"{src.path.stem}"
-            chain = ET.SubElement(
-                mlt, "chain", attrib={"id": f"chain{chains}", "out": length}
-            )
-        else:
-            chain = ET.SubElement(
-                mlt, "producer", attrib={"id": f"producer{producers}", "out": length}
-            )
-            resource = f"{clip.speed}:{src.path}"
-            caption = f"{src.path.stem} ({clip.speed}x)"
-
-            producers += 1
-
-        ET.SubElement(chain, "property", name="length").text = length
-        ET.SubElement(chain, "property", name="resource").text = resource
-
-        if clip.speed != 1:
-            ET.SubElement(chain, "property", name="warp_speed").text = f"{clip.speed}"
-            ET.SubElement(chain, "property", name="warp_pitch").text = "1"
-            ET.SubElement(chain, "property", name="mlt_service").text = "timewarp"
-
-        ET.SubElement(chain, "property", name="caption").text = caption
-
-        chains += 1
-
-    main_playlist = ET.SubElement(mlt, "playlist", id="playlist0")
-    ET.SubElement(main_playlist, "property", name="shotcut:video").text = "1"
-    ET.SubElement(main_playlist, "property", name="shotcut:name").text = "V1"
-
-    producers = 0
-    for i, clip in enumerate(clips):
-        _in = to_timecode(clip.offset / tb, "standard")
-        _out = to_timecode((clip.offset + clip.dur) / tb, "standard")
-
-        tag_name = f"chain{i}"
-        if clip.speed != 1:
-            tag_name = f"producer{producers}"
-            producers += 1
-
-        ET.SubElement(
-            main_playlist,
-            "entry",
-            attrib={"producer": tag_name, "in": _in, "out": _out},
-        )
-
-    tractor = ET.SubElement(
-        mlt,
-        "tractor",
-        attrib={"id": "tractor0", "in": "00:00:00.000", "out": global_out},
-    )
-    ET.SubElement(tractor, "property", name="shotcut").text = "1"
-    ET.SubElement(tractor, "property", name="shotcut:projectAudioChannels").text = "2"
-    ET.SubElement(tractor, "track", producer="background")
-    ET.SubElement(tractor, "track", producer="playlist0")
-
-    tree = ET.ElementTree(mlt)
-
-    ET.indent(tree, space="\t", level=0)
-
-    if output == "-":
-        print(ET.tostring(mlt, encoding="unicode"))
-    else:
-        tree.write(output, xml_declaration=True, encoding="utf-8")

auto_editor/ffwrapper.py

@@ -1,187 +0,0 @@
-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
-    timecode: str  # in SMPTE
-    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),)
-
-        def get_timecode() -> str:
-            for d in cont.streams.data:
-                if (result := d.metadata.get("timecode")) is not None:
-                    return result
-            for v in cont.streams.video:
-                if (result := v.metadata.get("timecode")) is not None:
-                    return result
-            return "00:00:00:00"
-
-        timecode = get_timecode()
-        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, timecode, videos, audios, subtitles)
-
-    def __repr__(self) -> str:
-        return f"@{self.path.name}"

auto_editor/help.py

@@ -1,223 +0,0 @@
-data = {
-    "Auto-Editor": {
-        "_": """
-Auto-Editor is an automatic video/audio creator and editor. By default, it will detect silence and create a new video with those sections cut out. By changing some of the options, you can export to a traditional editor like Premiere Pro and adjust the edits there, adjust the pacing of the cuts, and change the method of editing like using audio loudness and video motion to judge making cuts.
-
-Run:
-    auto-editor --help
-
-To get the list of options.
-""".strip(),
-        "--set-speed-for-range": """
-This option takes 3 arguments delimited with commas and they are as follows:
- - speed:
-  - How fast to play the media (number)
-Start:
-  - The time when speed first gets applied (time)
-End:
-  - The time when speed stops being applied (time)
-
-example:
-
---set-range-for-speed 2.5,400,800
-
-will set the speed from 400 ticks to 800 ticks to 2.5x
-If timebase is 30, 400 ticks to 800 means 13.33 to 26.66 seconds
-""".strip(),
-        "--edit": """
-Evaluates a palet expression that returns a bool-array?. The array is then used for
-editing.
-
-Examples:
-  --edit audio
-  --edit audio:0.03           ;  Change the threshold. Can be a value between 0-1.
-  --edit audio:3%             ;  You can also use the `%` macro.
-  --edit audio:0.03,stream=0  ;  Only consider the first stream for editing.
-  --edit audio:stream=1,threshold=0.05  ; Here's how you use keyword arguments.
-  --edit (or audio:0.04,stream=0 audio:0.08,stream=1)  ; Consider both streams for editing (merge with logical or), but with different thresholds.
-  --edit motion
-  --edit motion:0.02,blur=3
-  --edit (or audio:0.04 motion:0.02,blur=3)
-  --edit none
-  --edit all/e
-
-Editing Methods:
- - audio  ; Audio silence/loudness detection
-    - threshold threshold? : 4%
-    - stream (or/c nat? 'all) : 'all
-    - mincut nat? : 6
-    - minclip nat? : 3
-
- ; mincut is more significant, there it has a larger default value.
- ; minclip gets applied first, then mincut
-
- - motion  ; Motion detection specialized for noisy real-life videos
-    - threshold threshold? : 2%
-    - stream nat? : 0
-    - blur nat? : 9
-    - width nat1? : 400
-
- - subtitle  ; Detect when subtitle matches pattern as a RegEx string.
-    - pattern string?
-    - stream nat? : 0
-    - ignore-case bool? : #f
-    - max-count (or/c nat? void?) : (void)
-
- - none   ; Do not modify the media in anyway; mark all sections as "loud" (1).
- - all/e  ; Cut out everything out; mark all sections as "silent" (0).
-""".strip(),
-        "--export": """
-This option controls how timelines are exported.
-
-Export Methods:
- - default    ; Export as a regular media file
- - premiere   ; Export as an XML timeline file for Adobe Premiere Pro
-    - name : "Auto-Editor Media Group"
- - resolve    ; Export as an XML timeline file for DaVinci Resolve
-    - name : "Auto-Editor Media Group"
- - final-cut-pro  ; Export as an XML timeline file for Final Cut Pro
-    - name : "Auto-Editor Media Group"
- - shotcut ; Export as an XML timeline file for Shotcut
- - v3 ; Export as an auto-editor v3 timeline file
- - v1 ; Export as an auto-editor v1 timeline file
- - clip-sequence  ; Export as multiple numbered media files
-
-""".strip(),
-        "--player": """
-This option uses shell-like syntax to support using a specific player:
-
-  auto-editor in.mp4 --player mpv
-
-Args for the player program can be added as well:
-
-  auto-editor in.mp4 --player 'mpv --keep-open'
-
-Absolute or relative paths can also be used in the event the player's
-executable can not be resolved:
-
-  auto-editor in.mp4 --player '/path/to/mpv'
-  auto-editor in.mp4 --player './my-relative-path/mpv'
-
-If --player is not set, auto-editor will use the system default.
-If --no-open is used, --player will always be ignored.
-
-on MacOS, QuickTime can be used as the default player this way:
-
-  auto-editor in.mp4 --player 'open -a "quicktime player"'
-""".strip(),
-        "--resolution": """
-
-When working with media files, resolution will be based on the first input with a
-fallback value of 1920x1080
-""".strip(),
-        "--frame-rate": """
-Set the timeline's timebase and the output media's frame rate.
-
-When working with media files, frame-rate will be the first input's frame rate
-with a fallback value of 30
-
-The format must be a string in the form:
- - frame_rate_num/frame_rate_den
- - an integer
- - an floating point number
- - a valid frame rate label
-
-The following labels are recognized:
- - ntsc -> 30000/1001
- - ntsc_film -> 24000/1001
- - pal -> 25
- - film -> 24
-""".strip(),
-        "--temp-dir": """
-If not set, tempdir will be set with Python's tempfile module
-The directory doesn't have to exist beforehand, however, the root path must be valid.
-Beware that the temp directory can get quite big.
-""".strip(),
-        "--audio-bitrate": """
-`--audio-bitrate` sets the target bitrate for the audio encoder.
-By default, the value is `auto` (let the encoder decide).
-It can be set to a natural number with units: ``, `k`, `K`, `M`, or `G`.
-
-""".strip(),
-        "--video-bitrate": """
-`--video-bitrate` sets the target bitrate for the video encoder. `auto` is set as the default. It accepts the same format as `--audio-bitrate`
-""".strip(),
-        "--margin": """
-Default value: 0.2s,0.2s
-
-`--margin` takes either one number of two numbers with a `,` in-between.
-The numbers may be written in the 'time' format. Here is a quick recap:
-
-  frames / timebase : `` (no units)
-  seconds           : `s` `sec` `secs` `second` `seconds`
-  minutes           : `min` `mins` `minute` `minutes`
-  hours             : `hour`
-
-  seconds, minutes  :    MM:SS.SS
-  hours, mins, secs : HH:MM:SS.SS
-
-
-Setting margin examples:
- - `--margin 6`
- - `--margin 4,10`
- - `--margin 0.3s,0.5s`
- - `--margin 1:12.5` ; 1 minute, 12.5 seconds
-
-Behind the scenes, margin is a function that operates on boolean arrays
-(where 1 represents "loud" and 0 represents "silence")
-
-Here is a list of examples on how margin mutates boolean arrays
-
-(margin 0 0 (bool-array 0 0 0 1 0 0 0))
-> (array 'bool 0 0 0 1 0 0 0)
-
-(margin 1 0 (bool-array 0 0 0 1 0 0 0))
-> (array 'bool 0 0 1 1 0 0 0)
-
-(margin 1 1 (bool-array 0 0 0 1 0 0 0))
-> (array 'bool 0 0 1 1 1 0 0)
-
-(margin 1 2 (bool-array 0 0 1 1 0 0 0 0 1 0))
-> (array 'bool 0 1 1 1 1 1 0 1 1 1)
-
-(margin -2 2 (bool-array 0 0 1 1 0 0 0))
-> (array 'bool 0 0 0 0 1 1 0)
-""".strip(),
-        "--audio-normalize": """
-Apply audio normalization after cutting.
-
-Normalization Methods:
- - ebu  ; EBU R128 (double pass) loudness normalization
-   ; Integrated loudness target
-   - i (and/c (or/c int? float?) (between/c -70 -5)) : -24.0
-   ; Loudness range target
-   - lra (and/c (or/c int? float?) (between/c 1 50)) : 7.0
-   ; Set maximum true peak
-   - tp (and/c (or/c int? float?) (between/c -9 0)) : -2.0
-   ; Set offset gain. Gain is applied before the true-peak limiter
-   - gain (and/c (or/c int? float?) (between/c -99 99)) : 0.0
-
- - peak
-  ; Loudness target
-  - t (and/c (or/c int? float?) (between/c -99 0)) : -8.0
-
-If `#f` is chosen, no audio-normalization will be applied.
-
-Note that this option is a thin layer over the audio filter `loudnorm` for `ebu` and `astats`/`volume` for `peak` respectively.
-Check out its docs for more info: https://ffmpeg.org/ffmpeg-filters.html#loudnorm
-
-Examples:
---audio-normalize #f
---audio-normalize ebu:i=-5,lra=40,gain=5,tp=-1
-""".strip(),
-        "--silent-speed": "99999 is the 'cut speed' and values over that or <=0 are considered 'cut speeds' as well",
-        "--video-speed": "99999 is the 'cut speed' and values over that or <=0 are considered 'cut speeds' as well",
-    },
-    "info": {"_": "Retrieve information and properties about media files"},
-    "levels": {"_": "Display loudness over time"},
-    "subdump": {
-        "_": "Dump text-based subtitles to stdout with formatting stripped out"
-    },
-    "desc": {"_": "Display a media's description metadata"},
-    "test": {"_": "Self-Hosted Unit and End-to-End tests"},
-}