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

auto_editor/exports/fcp11.py

@@ -1,17 +1,10 @@
-from __future__ import annotations
-
 import xml.etree.ElementTree as ET
-from typing import TYPE_CHECKING, cast
+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
-
-if TYPE_CHECKING:
-    from fractions import Fraction
-
-    from auto_editor.ffwrapper import FileInfo
-    from auto_editor.utils.log import Log
-
+from auto_editor.utils.log import Log
 
 """
 Export a FCPXML 11 file readable with Final Cut Pro 10.6.8 or later.
@@ -52,6 +45,35 @@ def make_name(src: FileInfo, tb: Fraction) -> str:
     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:
@@ -90,12 +112,14 @@ def fcp11_write_xml(
             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="0s",
+            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",
@@ -122,12 +146,14 @@ def fcp11_write_xml(
     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),
+            "offset": fraction(clip.start + startPoint),
             "duration": fraction(clip.dur),
-            "start": fraction(clip.offset),
+            "start": fraction(clip.offset + startPoint),
             "tcFormat": "NDF",
         }
         asset = SubElement(spine, "asset-clip", clip_properties)
@@ -146,7 +172,7 @@ def fcp11_write_xml(
             )
 
     if tl.v and tl.v[0]:
-        clips = cast(list[Clip], 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:

auto_editor/exports/json.py

@@ -1,13 +1,44 @@
-from __future__ import annotations
-
 import sys
-from typing import TYPE_CHECKING
 
 from auto_editor.json import dump
-from auto_editor.timeline import v3
-
-if TYPE_CHECKING:
-    from auto_editor.utils.log import Log
+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:
@@ -20,7 +51,7 @@ def make_json_timeline(ver: str, out: str, tl: v3, log: Log) -> None:
         outfile = open(out, "w")
 
     if ver == "v3":
-        dump(tl.as_dict(), outfile, indent=2)
+        dump(as_dict(tl), outfile, indent=2)
     else:
         if tl.v1 is None:
             log.error("Timeline can't be converted to v1 format")

auto_editor/exports/kdenlive.py

@@ -0,0 +1,322 @@
+import json
+import xml.etree.ElementTree as ET
+from os import getcwd
+from uuid import uuid4
+
+from auto_editor.timeline import Clip, v3
+from auto_editor.utils.func import aspect_ratio, to_timecode
+
+"""
+kdenlive uses the MLT timeline format
+
+See docs here:
+https://mltframework.org/docs/mltxml/
+
+kdenlive specifics:
+https://github.com/KDE/kdenlive/blob/master/dev-docs/fileformat.md
+"""
+
+
+def kdenlive_write(output: str, tl: v3) -> None:
+    mlt = ET.Element(
+        "mlt",
+        attrib={
+            "LC_NUMERIC": "C",
+            "version": "7.22.0",
+            "producer": "main_bin",
+            "root": f"{getcwd()}",
+        },
+    )
+
+    width, height = tl.res
+    num, den = aspect_ratio(width, height)
+    tb = tl.tb
+    seq_uuid = uuid4()
+
+    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",
+        },
+    )
+
+    # Reserved producer0
+    global_out = to_timecode(len(tl) / tb, "standard")
+    producer = ET.SubElement(mlt, "producer", id="producer0")
+    ET.SubElement(producer, "property", name="length").text = global_out
+    ET.SubElement(producer, "property", name="eof").text = "continue"
+    ET.SubElement(producer, "property", name="resource").text = "black"
+    ET.SubElement(producer, "property", name="mlt_service").text = "color"
+    ET.SubElement(producer, "property", name="kdenlive:playlistid").text = "black_track"
+    ET.SubElement(producer, "property", name="mlt_image_format").text = "rgba"
+    ET.SubElement(producer, "property", name="aspect_ratio").text = "1"
+
+    # Get all clips
+    if tl.v:
+        clips = [clip for clip in tl.v[0] if isinstance(clip, Clip)]
+    elif tl.a:
+        clips = tl.a[0]
+    else:
+        clips = []
+
+    source_ids = {}
+    source_id = 4
+    clip_playlists = []
+    chains = 0
+    playlists = 0
+    producers = 1
+    a_channels = len(tl.a)
+    v_channels = len(tl.v)
+    warped_clips = [i for i, clip in enumerate(clips) if clip.speed != 1]
+
+    # create all producers for warped clips
+    for clip_idx in warped_clips:
+        for i in range(a_channels + v_channels):
+            clip = clips[clip_idx]
+            path = str(clip.src.path)
+
+            if path not in source_ids:
+                source_ids[path] = str(source_id)
+                source_id += 1
+
+            prod = ET.SubElement(
+                mlt,
+                "producer",
+                attrib={
+                    "id": f"producer{producers}",
+                    "in": "00:00:00.000",
+                    "out": global_out,
+                },
+            )
+            ET.SubElement(
+                prod, "property", name="resource"
+            ).text = f"{clip.speed}:{path}"
+            ET.SubElement(prod, "property", name="warp_speed").text = str(clip.speed)
+            ET.SubElement(prod, "property", name="warp_resource").text = path
+            ET.SubElement(prod, "property", name="warp_pitch").text = "0"
+            ET.SubElement(prod, "property", name="mlt_service").text = "timewarp"
+            ET.SubElement(prod, "property", name="kdenlive:id").text = source_ids[path]
+
+            if i < a_channels:
+                ET.SubElement(prod, "property", name="vstream").text = "0"
+                ET.SubElement(prod, "property", name="astream").text = str(
+                    a_channels - 1 - i
+                )
+                ET.SubElement(prod, "property", name="set.test_audio").text = "0"
+                ET.SubElement(prod, "property", name="set.test_video").text = "1"
+            else:
+                ET.SubElement(prod, "property", name="vstream").text = str(
+                    v_channels - 1 - (i - a_channels)
+                )
+                ET.SubElement(prod, "property", name="astream").text = "0"
+                ET.SubElement(prod, "property", name="set.test_audio").text = "1"
+                ET.SubElement(prod, "property", name="set.test_video").text = "0"
+
+            producers += 1
+
+    # create chains, playlists and tractors for audio channels
+    for i, audio in enumerate(tl.a):
+        path = str(audio[0].src.path)
+
+        if path not in source_ids:
+            source_ids[path] = str(source_id)
+            source_id += 1
+
+        chain = ET.SubElement(mlt, "chain", attrib={"id": f"chain{chains}"})
+        ET.SubElement(chain, "property", name="resource").text = path
+        ET.SubElement(
+            chain, "property", name="mlt_service"
+        ).text = "avformat-novalidate"
+        ET.SubElement(chain, "property", name="vstream").text = "0"
+        ET.SubElement(chain, "property", name="astream").text = str(a_channels - 1 - i)
+        ET.SubElement(chain, "property", name="set.test_audio").text = "0"
+        ET.SubElement(chain, "property", name="set.test_video").text = "1"
+        ET.SubElement(chain, "property", name="kdenlive:id").text = source_ids[path]
+
+        for _i in range(2):
+            playlist = ET.SubElement(mlt, "playlist", id=f"playlist{playlists}")
+            clip_playlists.append(playlist)
+            ET.SubElement(playlist, "property", name="kdenlive:audio_track").text = "1"
+            playlists += 1
+
+        tractor = ET.SubElement(
+            mlt,
+            "tractor",
+            attrib={"id": f"tractor{chains}", "in": "00:00:00.000", "out": global_out},
+        )
+        ET.SubElement(tractor, "property", name="kdenlive:audio_track").text = "1"
+        ET.SubElement(tractor, "property", name="kdenlive:timeline_active").text = "1"
+        ET.SubElement(tractor, "property", name="kdenlive:audio_rec")
+        ET.SubElement(
+            tractor,
+            "track",
+            attrib={"hide": "video", "producer": f"playlist{playlists - 2}"},
+        )
+        ET.SubElement(
+            tractor,
+            "track",
+            attrib={"hide": "video", "producer": f"playlist{playlists - 1}"},
+        )
+        chains += 1
+
+    # create chains, playlists and tractors for video channels
+    for i, video in enumerate(tl.v):
+        path = f"{video[0].src.path}"  # type: ignore
+
+        if path not in source_ids:
+            source_ids[path] = str(source_id)
+            source_id += 1
+
+        chain = ET.SubElement(mlt, "chain", attrib={"id": f"chain{chains}"})
+        ET.SubElement(chain, "property", name="resource").text = path
+        ET.SubElement(
+            chain, "property", name="mlt_service"
+        ).text = "avformat-novalidate"
+        ET.SubElement(chain, "property", name="vstream").text = str(v_channels - 1 - i)
+        ET.SubElement(chain, "property", name="astream").text = "0"
+        ET.SubElement(chain, "property", name="set.test_audio").text = "1"
+        ET.SubElement(chain, "property", name="set.test_video").text = "0"
+        ET.SubElement(chain, "property", name="kdenlive:id").text = source_ids[path]
+
+        for _i in range(2):
+            playlist = ET.SubElement(mlt, "playlist", id=f"playlist{playlists}")
+            clip_playlists.append(playlist)
+            playlists += 1
+
+        tractor = ET.SubElement(
+            mlt,
+            "tractor",
+            attrib={"id": f"tractor{chains}", "in": "00:00:00.000", "out": global_out},
+        )
+        ET.SubElement(tractor, "property", name="kdenlive:timeline_active").text = "1"
+        ET.SubElement(
+            tractor,
+            "track",
+            attrib={"hide": "audio", "producer": f"playlist{playlists - 2}"},
+        )
+        ET.SubElement(
+            tractor,
+            "track",
+            attrib={"hide": "audio", "producer": f"playlist{playlists - 1}"},
+        )
+        chains += 1
+
+    # final chain for the project bin
+    path = str(clips[0].src.path)
+    chain = ET.SubElement(mlt, "chain", attrib={"id": f"chain{chains}"})
+    ET.SubElement(chain, "property", name="resource").text = path
+    ET.SubElement(chain, "property", name="mlt_service").text = "avformat-novalidate"
+    ET.SubElement(chain, "property", name="audio_index").text = "1"
+    ET.SubElement(chain, "property", name="video_index").text = "0"
+    ET.SubElement(chain, "property", name="vstream").text = "0"
+    ET.SubElement(chain, "property", name="astream").text = "0"
+    ET.SubElement(chain, "property", name="kdenlive:id").text = source_ids[path]
+
+    groups = []
+    group_counter = 0
+    producers = 1
+
+    for clip in clips:
+        group_children: list[object] = []
+        _in = to_timecode(clip.offset / tb, "standard")
+        _out = to_timecode((clip.offset + clip.dur) / tb, "standard")
+        path = str(clip.src.path)
+
+        for i, playlist in enumerate(clip_playlists[::2]):
+            # adding 1 extra frame for each previous group to the start time works but feels hacky?
+            group_children.append(
+                {
+                    "data": f"{i}:{clip.start + group_counter}",
+                    "leaf": "clip",
+                    "type": "Leaf",
+                }
+            )
+            clip_prod = ""
+
+            if clip.speed == 1:
+                clip_prod = f"chain{i}"
+            else:
+                clip_prod = f"producer{producers}"
+                producers += 1
+
+            entry = ET.SubElement(
+                playlist,
+                "entry",
+                attrib={"producer": f"{clip_prod}", "in": _in, "out": _out},
+            )
+            ET.SubElement(entry, "property", name="kdenlive:id").text = source_ids[path]
+
+        groups.append({"children": group_children[:], "type": "Normal"})
+        group_counter += 1
+
+    # default sequence tractor
+    sequence = ET.SubElement(
+        mlt,
+        "tractor",
+        attrib={"id": f"{{{seq_uuid}}}", "in": "00:00:00.000", "out": "00:00:00.000"},
+    )
+    ET.SubElement(sequence, "property", name="kdenlive:uuid").text = f"{{{seq_uuid}}}"
+    ET.SubElement(sequence, "property", name="kdenlive:clipname").text = "Sequence 1"
+    ET.SubElement(
+        sequence, "property", name="kdenlive:sequenceproperties.groups"
+    ).text = json.dumps(groups, indent=4)
+    ET.SubElement(sequence, "track", producer="producer0")
+
+    for i in range(chains):
+        ET.SubElement(sequence, "track", producer=f"tractor{i}")
+
+    # main bin
+    playlist_bin = ET.SubElement(mlt, "playlist", id="main_bin")
+    ET.SubElement(
+        playlist_bin, "property", name="kdenlive:docproperties.uuid"
+    ).text = f"{{{seq_uuid}}}"
+    ET.SubElement(
+        playlist_bin, "property", name="kdenlive:docproperties.version"
+    ).text = "1.1"
+    ET.SubElement(playlist_bin, "property", name="xml_retain").text = "1"
+    ET.SubElement(
+        playlist_bin,
+        "entry",
+        attrib={
+            "producer": f"{{{seq_uuid}}}",
+            "in": "00:00:00.000",
+            "out": "00:00:00.000",
+        },
+    )
+    ET.SubElement(
+        playlist_bin,
+        "entry",
+        attrib={"producer": f"chain{chains}", "in": "00:00:00.000"},
+    )
+
+    # reserved last tractor for project
+    tractor = ET.SubElement(
+        mlt,
+        "tractor",
+        attrib={"id": f"tractor{chains}", "in": "00:00:00.000", "out": global_out},
+    )
+    ET.SubElement(tractor, "property", name="kdenlive:projectTractor").text = "1"
+    ET.SubElement(
+        tractor,
+        "track",
+        attrib={"producer": f"{{{seq_uuid}}}", "in": "00:00:00.000", "out": global_out},
+    )
+    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/exports/shotcut.py

@@ -1,5 +1,4 @@
 import xml.etree.ElementTree as ET
-from typing import cast
 
 from auto_editor.timeline import Clip, v3
 from auto_editor.utils.func import aspect_ratio, to_timecode
@@ -71,7 +70,7 @@ def shotcut_write_mlt(output: str, tl: v3) -> None:
     producers = 0
 
     if tl.v:
-        clips = cast(list[Clip], tl.v[0])
+        clips = [clip for clip in tl.v[0] if isinstance(clip, Clip)]
     elif tl.a:
         clips = tl.a[0]
     else:

auto_editor/ffwrapper.py

@@ -4,14 +4,14 @@ from dataclasses import dataclass
 from fractions import Fraction
 from pathlib import Path
 
-import bv
+import av
 
 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_container = av.open(input, "r")
+    output_container = av.open(output, "w")
 
     input_audio_stream = input_container.streams.audio[stream]
     output_audio_stream = output_container.add_stream("pcm_s16le")
@@ -66,6 +66,7 @@ class FileInfo:
     path: Path
     bitrate: int
     duration: float
+    timecode: str  # in SMPTE
     videos: tuple[VideoStream, ...]
     audios: tuple[AudioStream, ...]
     subtitles: tuple[SubtitleStream, ...]
@@ -88,12 +89,12 @@ class FileInfo:
     @classmethod
     def init(self, path: str, log: Log) -> FileInfo:
         try:
-            cont = bv.open(path, "r")
-        except bv.error.FileNotFoundError:
+            cont = av.open(path, "r")
+        except av.error.FileNotFoundError:
             log.error(f"Input file doesn't exist: {path}")
-        except bv.error.IsADirectoryError:
+        except av.error.IsADirectoryError:
             log.error(f"Expected a media file, but got a directory: {path}")
-        except bv.error.InvalidDataError:
+        except av.error.InvalidDataError:
             log.error(f"Invalid data when processing: {path}")
 
         videos: tuple[VideoStream, ...] = ()
@@ -165,12 +166,22 @@ class FileInfo:
             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
+        dur = 0 if cont.duration is None else cont.duration / av.time_base
 
         cont.close()
 
-        return FileInfo(Path(path), bitrate, dur, videos, audios, subtitles)
+        return FileInfo(Path(path), bitrate, dur, timecode, videos, audios, subtitles)
 
     def __repr__(self) -> str:
         return f"@{self.path.name}"

auto_editor/help.py

@@ -78,6 +78,7 @@ Export Methods:
  - 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
+ - kdenlive ; Export as an XML timeline file for kdenlive
  - 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

auto_editor/lang/stdenv.py

@@ -3,8 +3,6 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-import bv
-
 from auto_editor.analyze import mut_remove_large, mut_remove_small
 from auto_editor.lib.contracts import *
 from auto_editor.lib.data_structs import *
@@ -1169,9 +1167,6 @@ def make_standard_env() -> dict[str, Any]:
             "string->vector", lambda s: [Char(c) for c in s], (1, 1), is_str
         ),
         "range->vector": Proc("range->vector", list, (1, 1), is_range),
-        # av
-        "encoder": Proc("encoder", lambda x: bv.Codec(x, "w"), (1, 1), is_str),
-        "decoder": Proc("decoder", lambda x: bv.Codec(x), (1, 1), is_str),
         # reflexion
         "var-exists?": Proc("var-exists?", lambda sym: sym.val in env, (1, 1), is_symbol),
         "rename": Syntax(syn_rename),

auto_editor/make_layers.py

@@ -299,9 +299,9 @@ def make_timeline(
 
     if len(sources) == 1 and inp is not None:
         chunks = chunkify(speed_index, speed_hash)
-        v1_compatiable = v1(inp, chunks)
+        v1_compatible = v1(inp, chunks)
     else:
-        v1_compatiable = None
+        v1_compatible = None
 
     if len(vtl) == 0 and len(atl) == 0:
         log.error("Timeline is empty, nothing to do.")
@@ -312,4 +312,4 @@ def make_timeline(
     else:
         template = Template.init(inp, sr, args.audio_layout, res)
 
-    return v3(tb, args.background, template, vtl, atl, v1_compatiable)
+    return v3(tb, args.background, template, vtl, atl, v1_compatible)

auto_editor/preview.py

@@ -28,23 +28,24 @@ def time_frame(
 def all_cuts(tl: v3, in_len: int) -> list[int]:
     # Calculate cuts
     tb = tl.tb
-    oe: list[tuple[int, int]] = []
+    clip_spans: list[tuple[int, int]] = []
 
     for clip in tl.a[0]:
         old_offset = clip.offset * clip.speed
-        oe.append((round(old_offset * clip.speed), round(old_offset + clip.dur)))
+        clip_spans.append((round(old_offset), round(old_offset + clip.dur)))
 
     cut_lens = []
     i = 0
-    while i < len(oe) - 1:
-        if i == 0 and oe[i][0] != 0:
-            cut_lens.append(oe[i][1])
+    while i < len(clip_spans) - 1:
+        if i == 0 and clip_spans[i][0] != 0:
+            cut_lens.append(clip_spans[i][0])
 
-        cut_lens.append(oe[i + 1][0] - oe[i][1])
+        cut_lens.append(clip_spans[i + 1][0] - clip_spans[i][1])
         i += 1
 
-    if len(oe) > 0 and oe[-1][1] < round(in_len * tb):
-        cut_lens.append(in_len - oe[-1][1])
+    if len(clip_spans) > 0 and clip_spans[-1][1] < round(in_len / tb):
+        cut_lens.append(in_len - clip_spans[-1][1])
+
     return cut_lens
 
 
@@ -53,19 +54,9 @@ def preview(tl: v3, log: Log) -> None:
     tb = tl.tb
 
     # Calculate input videos length
-    all_sources = set()
-    for vlayer in tl.v:
-        for vclip in vlayer:
-            if hasattr(vclip, "src"):
-                all_sources.add(vclip.src)
-    for alayer in tl.a:
-        for aclip in alayer:
-            if hasattr(aclip, "src"):
-                all_sources.add(aclip.src)
-
     in_len = 0
     bar = initBar("none")
-    for src in all_sources:
+    for src in tl.unique_sources():
         in_len += initLevels(src, tb, bar, False, log).media_length
 
     out_len = len(tl)
@@ -77,7 +68,7 @@ def preview(tl: v3, log: Log) -> None:
     time_frame(fp, "output", out_len, tb, f"{round((out_len / in_len) * 100, 2)}%")
     time_frame(fp, "diff", diff, tb, f"{round((diff / in_len) * 100, 2)}%")
 
-    clip_lens = [clip.dur / clip.speed for clip in tl.a[0]]
+    clip_lens = [clip.dur for clip in tl.a[0]]
     log.debug(clip_lens)
 
     fp.write(f"clips:\n - amount:    {len(clip_lens)}\n")
@@ -90,7 +81,7 @@ def preview(tl: v3, log: Log) -> None:
 
     cut_lens = all_cuts(tl, in_len)
     log.debug(cut_lens)
-    fp.write(f"cuts:\n - amount:    {len(clip_lens)}\n")
+    fp.write(f"cuts:\n - amount:    {len(cut_lens)}\n")
     if len(cut_lens) > 0:
         time_frame(fp, "smallest", min(cut_lens), tb)
         time_frame(fp, "largest", max(cut_lens), tb)