auto-editor 24.27.1__tar.gz → 24.30.1__tar.gz

{auto_editor-24.27.1/auto_editor.egg-info → auto_editor-24.30.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-editor
-Version: 24.27.1
+Version: 24.30.1
 Summary: Auto-Editor: Effort free video editing!
 Author-email: WyattBlue <wyattblue@auto-editor.com>
 License: Unlicense
@@ -11,8 +11,8 @@ Keywords: video,audio,media,editor,editing,processing,nonlinear,automatic,silenc
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy>=1.22.0
-Requires-Dist: pyav==12.2.*
+Requires-Dist: numpy>=1.23.0
+Requires-Dist: pyav==12.3.*
 Requires-Dist: ae-ffmpeg==1.2.*
 
 <p align="center"><img src="https://auto-editor.com/img/auto-editor-banner.webp" title="Auto-Editor" width="700"></p>
@@ -182,6 +182,3 @@ auto-editor --margin --help
 
 ## Copyright
 Auto-Editor is under the [Public Domain](https://github.com/WyattBlue/auto-editor/blob/master/LICENSE) and includes all directories besides the ones listed below. Auto-Editor was created by [these people.](https://auto-editor.com/blog/thank-you-early-testers)
-
-ae-ffmpeg is under the [LGPLv3 License](https://github.com/WyattBlue/auto-editor/blob/master/ae-ffmpeg/LICENSE.txt). The ffmpeg and ffprobe programs were created by the FFmpeg team.
-

{auto_editor-24.27.1 → auto_editor-24.30.1}/README.md

@@ -165,6 +165,3 @@ auto-editor --margin --help
 
 ## Copyright
 Auto-Editor is under the [Public Domain](https://github.com/WyattBlue/auto-editor/blob/master/LICENSE) and includes all directories besides the ones listed below. Auto-Editor was created by [these people.](https://auto-editor.com/blog/thank-you-early-testers)
-
-ae-ffmpeg is under the [LGPLv3 License](https://github.com/WyattBlue/auto-editor/blob/master/ae-ffmpeg/LICENSE.txt). The ffmpeg and ffprobe programs were created by the FFmpeg team.
-

auto_editor-24.30.1/auto_editor/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "24.30.1"
+version = "24w30a"

auto_editor-24.30.1/auto_editor/analyze.py

@@ -0,0 +1,377 @@
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass
+from fractions import Fraction
+from math import ceil
+from typing import TYPE_CHECKING
+
+import av
+import numpy as np
+from av.audio.fifo import AudioFifo
+from av.subtitles.subtitle import AssSubtitle
+
+from auto_editor import version
+from auto_editor.utils.subtitle_tools import convert_ass_to_text
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from fractions import Fraction
+    from typing import Any
+
+    from numpy.typing import NDArray
+
+    from auto_editor.ffwrapper import FileInfo
+    from auto_editor.utils.bar import Bar
+    from auto_editor.utils.log import Log
+
+
+@dataclass(slots=True)
+class FileSetup:
+    src: FileInfo
+    strict: bool
+    tb: Fraction
+    bar: Bar
+    temp: str
+    log: Log
+
+
+class LevelError(Exception):
+    pass
+
+
+def mut_remove_small(
+    arr: NDArray[np.bool_], lim: int, replace: int, with_: int
+) -> None:
+    start_p = 0
+    active = False
+    for j, item in enumerate(arr):
+        if item == replace:
+            if not active:
+                start_p = j
+                active = True
+
+            if j == len(arr) - 1 and j - start_p < lim:
+                arr[start_p:] = with_
+        elif active:
+            if j - start_p < lim:
+                arr[start_p:j] = with_
+            active = False
+
+
+def mut_remove_large(
+    arr: NDArray[np.bool_], lim: int, replace: int, with_: int
+) -> None:
+    start_p = 0
+    active = False
+    for j, item in enumerate(arr):
+        if item == replace:
+            if not active:
+                start_p = j
+                active = True
+
+            if j == len(arr) - 1 and j - start_p >= lim:
+                arr[start_p:] = with_
+        elif active:
+            if j - start_p > lim:
+                arr[start_p:j] = with_
+            active = False
+
+
+def obj_tag(tag: str, tb: Fraction, obj: dict[str, Any]) -> str:
+    key = f"{tag}:{tb}:"
+    for k, v in obj.items():
+        key += f"{k}={v},"
+
+    key = key[:-1]  # remove unnecessary char
+    return key
+
+
+def iter_audio(src, tb: Fraction, stream: int = 0) -> Iterator[float]:
+    fifo = AudioFifo()
+    try:
+        container = av.open(src.path, "r")
+        audio_stream = container.streams.audio[stream]
+        sample_rate = audio_stream.rate
+
+        exact_size = (1 / tb) * sample_rate
+        accumulated_error = 0
+
+        # Resample so that audio data is between [-1, 1]
+        resampler = av.AudioResampler(
+            av.AudioFormat("flt"), audio_stream.layout, sample_rate
+        )
+
+        for frame in container.decode(audio=stream):
+            frame.pts = None  # Skip time checks
+
+            for reframe in resampler.resample(frame):
+                fifo.write(reframe)
+
+            while fifo.samples >= ceil(exact_size):
+                size_with_error = exact_size + accumulated_error
+                current_size = round(size_with_error)
+                accumulated_error = size_with_error - current_size
+
+                audio_chunk = fifo.read(current_size)
+                assert audio_chunk is not None
+                arr = audio_chunk.to_ndarray().flatten()
+                yield float(np.max(np.abs(arr)))
+
+    finally:
+        container.close()
+
+
+def iter_motion(src, tb, stream: int, blur: int, width: int) -> Iterator[float]:
+    container = av.open(src.path, "r")
+
+    video = container.streams.video[stream]
+    video.thread_type = "AUTO"
+
+    prev_frame = None
+    current_frame = None
+    total_pixels = src.videos[0].width * src.videos[0].height
+    index = 0
+    prev_index = -1
+
+    graph = av.filter.Graph()
+    graph.link_nodes(
+        graph.add_buffer(template=video),
+        graph.add("scale", f"{width}:-1"),
+        graph.add("format", "gray"),
+        graph.add("gblur", f"sigma={blur}"),
+        graph.add("buffersink"),
+    ).configure()
+
+    for unframe in container.decode(video):
+        if unframe.pts is None:
+            continue
+
+        graph.push(unframe)
+        frame = graph.pull()
+        assert frame.time is not None
+        index = round(frame.time * tb)
+
+        current_frame = frame.to_ndarray()
+        if prev_frame is None:
+            value = 0.0
+        else:
+            # Use `int16` to avoid underflow with `uint8` datatype
+            diff = np.abs(prev_frame.astype(np.int16) - current_frame.astype(np.int16))
+            value = np.count_nonzero(diff) / total_pixels
+
+        for _ in range(index - prev_index):
+            yield value
+
+        prev_frame = current_frame
+        prev_index = index
+
+    container.close()
+
+
+@dataclass(slots=True)
+class Levels:
+    src: FileInfo
+    tb: Fraction
+    bar: Bar
+    temp: str
+    log: Log
+
+    @property
+    def media_length(self) -> int:
+        if self.src.audios:
+            if (arr := self.read_cache("audio", {"stream": 0})) is not None:
+                return len(arr)
+
+            result = sum(1 for _ in iter_audio(self.src, self.tb, 0))
+            self.log.debug(f"Audio Length: {result}")
+            return result
+
+        # If there's no audio, get length in video metadata.
+        with av.open(self.src.path) as container:
+            if len(container.streams.video) == 0:
+                self.log.error("Could not get media duration")
+
+            video = container.streams.video[0]
+
+            if video.duration is None or video.time_base is None:
+                dur = 0
+            else:
+                dur = int(video.duration * video.time_base * self.tb)
+            self.log.debug(f"Video duration: {dur}")
+
+        return dur
+
+    def none(self) -> NDArray[np.bool_]:
+        return np.ones(self.media_length, dtype=np.bool_)
+
+    def all(self) -> NDArray[np.bool_]:
+        return np.zeros(self.media_length, dtype=np.bool_)
+
+    def read_cache(self, tag: str, obj: dict[str, Any]) -> None | np.ndarray:
+        workfile = os.path.join(
+            os.path.dirname(self.temp), f"ae-{version}", "cache.npz"
+        )
+
+        try:
+            npzfile = np.load(workfile, allow_pickle=False)
+        except Exception as e:
+            self.log.debug(e)
+            return None
+
+        key = f"{self.src.path}:{obj_tag(tag, self.tb, obj)}"
+        if key not in npzfile.files:
+            return None
+
+        self.log.debug("Using cache")
+        return npzfile[key]
+
+    def cache(self, tag: str, obj: dict[str, Any], arr: np.ndarray) -> np.ndarray:
+        workdur = os.path.join(os.path.dirname(self.temp), f"ae-{version}")
+        if not os.path.exists(workdur):
+            os.mkdir(workdur)
+
+        tag = obj_tag(tag, self.tb, obj)
+        np.savez(os.path.join(workdur, "cache.npz"), **{f"{self.src.path}:{tag}": arr})
+
+        return arr
+
+    def audio(self, stream: int) -> NDArray[np.float64]:
+        if stream >= len(self.src.audios):
+            raise LevelError(f"audio: audio stream '{stream}' does not exist.")
+
+        if (arr := self.read_cache("audio", {"stream": stream})) is not None:
+            return arr
+
+        with av.open(self.src.path, "r") as container:
+            audio = container.streams.audio[stream]
+            if audio.duration is not None and audio.time_base is not None:
+                inaccurate_dur = int(audio.duration * audio.time_base * self.tb)
+            elif container.duration is not None:
+                inaccurate_dur = int(container.duration / av.time_base * self.tb)
+            else:
+                inaccurate_dur = 1024
+
+        bar = self.bar
+        bar.start(inaccurate_dur, "Analyzing audio volume")
+
+        result = np.zeros((inaccurate_dur), dtype=np.float64)
+        index = 0
+        for value in iter_audio(self.src, self.tb, stream):
+            if index > len(result) - 1:
+                result = np.concatenate(
+                    (result, np.zeros((len(result)), dtype=np.float64))
+                )
+            result[index] = value
+            bar.tick(index)
+            index += 1
+
+        bar.end()
+        return self.cache("audio", {"stream": stream}, result[:index])
+
+    def motion(self, stream: int, blur: int, width: int) -> NDArray[np.float64]:
+        if stream >= len(self.src.videos):
+            raise LevelError(f"motion: video stream '{stream}' does not exist.")
+
+        mobj = {"stream": stream, "width": width, "blur": blur}
+        if (arr := self.read_cache("motion", mobj)) is not None:
+            return arr
+
+        with av.open(self.src.path, "r") as container:
+            video = container.streams.video[stream]
+            inaccurate_dur = (
+                1024
+                if video.duration is None or video.time_base is None
+                else int(video.duration * video.time_base * self.tb)
+            )
+
+        bar = self.bar
+        bar.start(inaccurate_dur, "Analyzing motion")
+
+        result = np.zeros((inaccurate_dur), dtype=np.float64)
+        index = 0
+        for value in iter_motion(self.src, self.tb, stream, blur, width):
+            if index > len(result) - 1:
+                result = np.concatenate(
+                    (result, np.zeros((len(result)), dtype=np.float64))
+                )
+            result[index] = value
+            bar.tick(index)
+            index += 1
+
+        bar.end()
+        return self.cache("motion", mobj, result[:index])
+
+    def subtitle(
+        self,
+        pattern: str,
+        stream: int,
+        ignore_case: bool,
+        max_count: int | None,
+    ) -> NDArray[np.bool_]:
+        if stream >= len(self.src.subtitles):
+            raise LevelError(f"subtitle: subtitle stream '{stream}' does not exist.")
+
+        try:
+            flags = re.IGNORECASE if ignore_case else 0
+            re_pattern = re.compile(pattern, flags)
+        except re.error as e:
+            self.log.error(e)
+
+        try:
+            container = av.open(self.src.path, "r")
+            subtitle_stream = container.streams.subtitles[stream]
+            assert isinstance(subtitle_stream.time_base, Fraction)
+        except Exception as e:
+            self.log.error(e)
+
+        # Get the length of the subtitle stream.
+        sub_length = 0
+        for packet in container.demux(subtitle_stream):
+            if packet.pts is None or packet.duration is None:
+                continue
+            for subset in packet.decode():
+                # See definition of `AVSubtitle`
+                # in: https://ffmpeg.org/doxygen/trunk/avcodec_8h_source.html
+                start = float(packet.pts * subtitle_stream.time_base)
+                dur = float(packet.duration * subtitle_stream.time_base)
+
+                end = round((start + dur) * self.tb)
+                sub_length = max(sub_length, end)
+
+        result = np.zeros((sub_length), dtype=np.bool_)
+        del sub_length
+
+        count = 0
+        early_exit = False
+        container.seek(0)
+        for packet in container.demux(subtitle_stream):
+            if packet.pts is None or packet.duration is None:
+                continue
+            if early_exit:
+                break
+            for subset in packet.decode():
+                if max_count is not None and count >= max_count:
+                    early_exit = True
+                    break
+
+                start = float(packet.pts * subtitle_stream.time_base)
+                dur = float(packet.duration * subtitle_stream.time_base)
+
+                san_start = round(start * self.tb)
+                san_end = round((start + dur) * self.tb)
+
+                for sub in subset:
+                    if isinstance(sub, AssSubtitle):
+                        line = convert_ass_to_text(sub.ass.decode(errors="ignore"))
+                    else:
+                        continue
+
+                    if line and re.search(re_pattern, line):
+                        result[san_start:san_end] = 1
+                        count += 1
+
+        container.close()
+
+        return result

{auto_editor-24.27.1 → auto_editor-24.30.1}/auto_editor/edit.py

@@ -68,12 +68,8 @@ def set_video_codec(
 ) -> str:
     if codec == "auto":
         codec = "h264" if (src is None or not src.videos) else src.videos[0].codec
-        if ctr.vcodecs is not None:
-            if ctr.vstrict and codec not in ctr.vcodecs:
-                return ctr.vcodecs[0]
-
-            if codec in ctr.disallow_v:
-                return ctr.vcodecs[0]
+        if codec not in ctr.vcodecs and ctr.default_vid != "none":
+            return ctr.default_vid
         return codec
 
     if codec == "copy":
@@ -83,12 +79,7 @@ def set_video_codec(
             log.error("Input file does not have a video stream to copy codec from.")
         codec = src.videos[0].codec
 
-    if ctr.vstrict:
-        assert ctr.vcodecs is not None
-        if codec not in ctr.vcodecs:
-            log.error(codec_error.format(codec, out_ext))
-
-    if codec in ctr.disallow_v:
+    if ctr.vcodecs is not None and codec not in ctr.vcodecs:
         log.error(codec_error.format(codec, out_ext))
 
     return codec
@@ -99,8 +90,10 @@ def set_audio_codec(
 ) -> str:
     if codec == "auto":
         codec = "aac" if (src is None or not src.audios) else src.audios[0].codec
-        if ctr.acodecs is not None and codec not in ctr.acodecs:
-            return ctr.acodecs[0]
+        if codec not in ctr.acodecs and ctr.default_aud != "none":
+            return ctr.default_aud
+        if codec == "mp3float":
+            return "mp3"
         return codec
 
     if codec == "copy":
@@ -209,10 +202,8 @@ def edit_media(
     else:
         samplerate = args.sample_rate
 
-    ensure = Ensure(ffmpeg, bar, samplerate, temp, log)
-
     if tl is None:
-        tl = make_timeline(sources, ensure, args, samplerate, bar, temp, log)
+        tl = make_timeline(sources, args, samplerate, bar, temp, log)
 
     if export["export"] == "timeline":
         from auto_editor.formats.json import make_json_timeline
@@ -223,7 +214,7 @@ def edit_media(
     if args.preview:
         from auto_editor.preview import preview
 
-        preview(ensure, tl, temp, log)
+        preview(tl, temp, log)
         return
 
     if export["export"] == "json":
@@ -272,13 +263,15 @@ def edit_media(
         sub_output = []
         apply_later = False
 
-        if ctr.allow_subtitle and not args.sn:
+        ensure = Ensure(ffmpeg, bar, samplerate, temp, log)
+
+        if ctr.default_sub != "none" and not args.sn:
             sub_output = make_new_subtitles(tl, ensure, temp)
 
-        if ctr.allow_audio:
+        if ctr.default_aud != "none":
             audio_output = make_new_audio(tl, ensure, args, ffmpeg, bar, temp, log)
 
-        if ctr.allow_video:
+        if ctr.default_vid != "none":
             if tl.v:
                 out_path, apply_later = render_av(ffmpeg, tl, args, bar, ctr, temp, log)
                 visual_output.append((True, out_path))

{auto_editor-24.27.1 → auto_editor-24.30.1}/auto_editor/lang/palet.py

@@ -18,12 +18,7 @@ from typing import TYPE_CHECKING
 import numpy as np
 from numpy import logical_and, logical_not, logical_or, logical_xor
 
-from auto_editor.analyze import (
-    LevelError,
-    mut_remove_large,
-    mut_remove_small,
-    to_threshold,
-)
+from auto_editor.analyze import LevelError, mut_remove_large, mut_remove_small
 from auto_editor.lib.contracts import *
 from auto_editor.lib.data_structs import *
 from auto_editor.lib.err import MyError
@@ -690,6 +685,9 @@ def palet_map(proc: Proc, seq: Any) -> Any:
         return Quoted(tuple(map(proc, seq.val)))
     if isinstance(seq, list | range):
         return list(map(proc, seq))
+    elif isinstance(seq, np.ndarray):
+        vectorized_proc = np.vectorize(proc)
+        return vectorized_proc(seq)
     return proc(seq)
 
 
@@ -1469,6 +1467,26 @@ def edit_all() -> np.ndarray:
     return env["@levels"].all()
 
 
+def audio_levels(stream: int) -> np.ndarray:
+    if "@levels" not in env:
+        raise MyError("Can't use `audio` if there's no input media")
+
+    try:
+        return env["@levels"].audio(stream)
+    except LevelError as e:
+        raise MyError(e)
+
+
+def motion_levels(stream: int, blur: int = 9, width: int = 400) -> np.ndarray:
+    if "@levels" not in env:
+        raise MyError("Can't use `motion` if there's no input media")
+
+    try:
+        return env["@levels"].motion(stream, blur, width)
+    except LevelError as e:
+        raise MyError(e)
+
+
 def edit_audio(
     threshold: float = 0.04,
     stream: object = Sym("all"),
@@ -1491,7 +1509,7 @@ def edit_audio(
 
     try:
         for s in stream_range:
-            audio_list = to_threshold(levels.audio(s), threshold)
+            audio_list = levels.audio(s) >= threshold
             if stream_data is None:
                 stream_data = audio_list
             else:
@@ -1521,7 +1539,7 @@ def edit_motion(
     levels = env["@levels"]
     strict = env["@filesetup"].strict
     try:
-        return to_threshold(levels.motion(stream, blur, width), threshold)
+        return levels.motion(stream, blur, width) >= threshold
     except LevelError as e:
         return raise_(e) if strict else levels.all()
 
@@ -1582,7 +1600,7 @@ def my_eval(env: Env, node: object) -> Any:
                     return ref(oper, my_eval(env, node[1]))
 
             raise MyError(
-                f"Tried to run: {print_str(oper)} with args: {print_str(node[1:])}"
+                f"{print_str(oper)} is not a function. Tried to run with args: {print_str(node[1:])}"
             )
 
         if type(oper) is Syntax:
@@ -1617,10 +1635,12 @@ env.update({
     # edit procedures
     "none": Proc("none", edit_none, (0, 0)),
     "all/e": Proc("all/e", edit_all, (0, 0)),
+    "audio-levels": Proc("audio-levels", audio_levels, (1, 1), is_nat),
     "audio": Proc("audio", edit_audio, (0, 4),
         is_threshold, orc(is_nat, Sym("all")), is_nat,
         {"threshold": 0, "stream": 1, "minclip": 2, "mincut": 2}
     ),
+    "motion-levels": Proc("motion-levels", motion_levels, (1, 3), is_nat, is_nat1, {"blur": 1, "width": 2}),
     "motion": Proc("motion", edit_motion, (0, 4),
         is_threshold, is_nat, is_nat1,
         {"threshold": 0, "stream": 1, "blur": 1, "width": 2}

{auto_editor-24.27.1 → auto_editor-24.30.1}/auto_editor/lib/contracts.py

@@ -5,6 +5,8 @@ from dataclasses import dataclass
 from fractions import Fraction
 from typing import Any
 
+from numpy import float64
+
 from .data_structs import Sym, print_str
 from .err import MyError
 
@@ -41,7 +43,7 @@ def check_contract(c: object, val: object) -> bool:
         return val is True
     if c is False:
         return val is False
-    if type(c) in (int, float, Fraction, complex, str, Sym):
+    if type(c) in (int, float, float64, Fraction, complex, str, Sym):
         return val == c
     raise MyError(f"Invalid contract, got: {print_str(c)}")
 
@@ -163,17 +165,21 @@ is_int = Contract("int?", lambda v: type(v) is int)
 is_nat = Contract("nat?", lambda v: type(v) is int and v > -1)
 is_nat1 = Contract("nat1?", lambda v: type(v) is int and v > 0)
 int_not_zero = Contract("(or/c (not/c 0) int?)", lambda v: v != 0 and is_int(v))
-is_num = Contract("number?", lambda v: type(v) in (int, float, Fraction, complex))
-is_real = Contract("real?", lambda v: type(v) in (int, float, Fraction))
-is_float = Contract("float?", lambda v: type(v) is float)
+is_num = Contract(
+    "number?", lambda v: type(v) in (int, float, float64, Fraction, complex)
+)
+is_real = Contract("real?", lambda v: type(v) in (int, float, float64, Fraction))
+is_float = Contract("float?", lambda v: type(v) in (float, float64))
 is_frac = Contract("frac?", lambda v: type(v) is Fraction)
 is_str = Contract("string?", lambda v: type(v) is str)
 any_p = Contract("any", lambda v: True)
 is_void = Contract("void?", lambda v: v is None)
-is_int_or_float = Contract("(or/c int? float?)", lambda v: type(v) in (int, float))
+is_int_or_float = Contract(
+    "(or/c int? float?)", lambda v: type(v) in (int, float, float64)
+)
 is_threshold = Contract(
     "threshold?",
-    lambda v: type(v) in (int, float) and v >= 0 and v <= 1,  # type: ignore
+    lambda v: type(v) in (int, float, float64) and v >= 0 and v <= 1,  # type: ignore
 )
 is_proc = Contract("procedure?", lambda v: isinstance(v, Proc | Contract))
 

{auto_editor-24.27.1 → auto_editor-24.30.1}/auto_editor/make_layers.py

@@ -18,7 +18,6 @@ from auto_editor.utils.types import Args, CoerceError, time
 if TYPE_CHECKING:
     from numpy.typing import NDArray
 
-    from auto_editor.output import Ensure
     from auto_editor.utils.bar import Bar
     from auto_editor.utils.chunks import Chunks
     from auto_editor.utils.log import Log
@@ -75,7 +74,6 @@ def make_av(src: FileInfo, all_clips: list[list[Clip]]) -> tuple[VSpace, ASpace]
 def run_interpreter_for_edit_option(
     text: str, filesetup: FileSetup
 ) -> NDArray[np.bool_]:
-    ensure = filesetup.ensure
     src = filesetup.src
     tb = filesetup.tb
     bar = filesetup.bar
@@ -87,8 +85,8 @@ def run_interpreter_for_edit_option(
         if log.is_debug:
             log.debug(f"edit: {parser}")
 
-        env["timebase"] = filesetup.tb
-        env["@levels"] = Levels(ensure, src, tb, bar, temp, log)
+        env["timebase"] = tb
+        env["@levels"] = Levels(src, tb, bar, temp, log)
         env["@filesetup"] = filesetup
 
         results = interpret(env, parser)
@@ -139,7 +137,6 @@ def parse_time(val: str, arr: NDArray, tb: Fraction) -> int:  # raises: `CoerceE
 
 def make_timeline(
     sources: list[FileInfo],
-    ensure: Ensure,
     args: Args,
     sr: int,
     bar: Bar,
@@ -169,7 +166,7 @@ def make_timeline(
     concat = np.concatenate
 
     for i, src in enumerate(sources):
-        filesetup = FileSetup(src, ensure, len(sources) < 2, tb, bar, temp, log)
+        filesetup = FileSetup(src, len(sources) < 2, tb, bar, temp, log)
 
         edit_result = run_interpreter_for_edit_option(method, filesetup)
         mut_margin(edit_result, start_margin, end_margin)
@@ -296,22 +293,4 @@ def make_timeline(
     else:
         v1_compatiable = None
 
-    tl = v3(inp, tb, sr, res, args.background, vtl, atl, v1_compatiable)
-
-    # Additional monotonic check, o(n^2) time complexity so disable by default.
-
-    # if len(sources) != 1:
-    #     return tl
-
-    # last_i = 0
-    # for index in range(tl.end):
-    #     for layer in tl.v:
-    #         for lobj in layer:
-    #             if index >= lobj.start and index < (lobj.start + lobj.dur):
-    #                 _i = round((lobj.offset + index - lobj.start) * lobj.speed)
-    #                 if (_i < last_i):
-    #                     print(_i, last_i)
-    #                     raise ValueError("not monotonic")
-    #                 last_i = _i
-
-    return tl
+    return v3(inp, tb, sr, res, args.background, vtl, atl, v1_compatiable)