auto-editor 27.0.0__py3-none-any.whl → 27.1.0__py3-none-any.whl

auto_editor/formats/fcp7.py

@@ -7,8 +7,8 @@ from math import ceil
 from typing import TYPE_CHECKING
 from xml.etree.ElementTree import Element
 
-from auto_editor.ffwrapper import FileInfo, initFileInfo
-from auto_editor.timeline import ASpace, TlAudio, TlVideo, VSpace, v3
+from auto_editor.ffwrapper import FileInfo
+from auto_editor.timeline import ASpace, Template, TlAudio, TlVideo, VSpace, v3
 
 from .utils import Validator, show
 
@@ -282,7 +282,7 @@ def fcp7_read_xml(path: str, log: Log) -> v3:
                     fileobj = valid.parse(clipitem["file"], {"pathurl": str})
 
                     if "pathurl" in fileobj:
-                        sources[file_id] = initFileInfo(
+                        sources[file_id] = FileInfo.init(
                             uri_to_path(fileobj["pathurl"]),
                             log,
                         )
@@ -317,7 +317,7 @@ def fcp7_read_xml(path: str, log: Log) -> v3:
                 file_id = clipitem["file"].attrib["id"]
                 if file_id not in sources:
                     fileobj = valid.parse(clipitem["file"], {"pathurl": str})
-                    sources[file_id] = initFileInfo(
+                    sources[file_id] = FileInfo.init(
                         uri_to_path(fileobj["pathurl"]), log
                     )
 
@@ -336,10 +336,8 @@ def fcp7_read_xml(path: str, log: Log) -> v3:
                     )
                 )
 
-    primary_src = sources[next(iter(sources))]
-    assert type(primary_src) is FileInfo
-
-    return v3(primary_src, tb, sr, res, "#000", vobjs, aobjs, v1=None)
+    T = Template.init(sources[next(iter(sources))], sr, res=res)
+    return v3(tb, "#000", T, vobjs, aobjs, v1=None)
 
 
 def media_def(
@@ -424,13 +422,14 @@ def resolve_write_audio(audio: Element, make_filedef, tl: v3) -> None:
                 clipitem.append(speedup(aclip.speed * 100))
 
 
-def premiere_write_audio(audio: Element, make_filedef, src: FileInfo, tl: v3) -> None:
+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.
@@ -442,7 +441,7 @@ def premiere_write_audio(audio: Element, make_filedef, src: FileInfo, tl: v3) ->
                 premiereTrackType="Stereo",
             )
 
-            if src.videos:
+            if has_video:
                 ET.SubElement(track, "outputchannelindex").text = f"{channelcount + 1}"
 
             for j, aclip in enumerate(aclips):
@@ -453,7 +452,7 @@ def premiere_write_audio(audio: Element, make_filedef, src: FileInfo, tl: v3) ->
                 _in = f"{aclip.offset}"
                 _out = f"{aclip.offset + aclip.dur}"
 
-                if not src.videos:
+                if not has_video:
                     clip_item_num = j + 1
                 else:
                     clip_item_num = len(aclips) + 1 + j + (t * len(aclips))
@@ -579,7 +578,7 @@ def fcp7_write_xml(name: str, output: str, resolve: bool, tl: v3) -> None:
     if resolve:
         resolve_write_audio(audio, make_filedef, tl)
     else:
-        premiere_write_audio(audio, make_filedef, src, tl)
+        premiere_write_audio(audio, make_filedef, tl)
 
     tree = ET.ElementTree(xmeml)
     ET.indent(tree, space="  ", level=0)

auto_editor/formats/json.py

@@ -6,11 +6,12 @@ from difflib import get_close_matches
 from fractions import Fraction
 from typing import Any
 
-from auto_editor.ffwrapper import FileInfo, initFileInfo
+from auto_editor.ffwrapper import FileInfo
 from auto_editor.json import dump, load
 from auto_editor.lib.err import MyError
 from auto_editor.timeline import (
     ASpace,
+    Template,
     TlAudio,
     TlVideo,
     VSpace,
@@ -59,7 +60,7 @@ def read_v3(tl: Any, log: Log) -> v3:
     def make_src(v: str) -> FileInfo:
         if v in srcs:
             return srcs[v]
-        temp = initFileInfo(v, log)
+        temp = FileInfo.init(v, log)
         srcs[v] = temp
         return temp
 
@@ -151,11 +152,11 @@ def read_v3(tl: Any, log: Log) -> v3:
             a.append(a_out)
 
     try:
-        src = srcs[next(iter(srcs))]
+        T = Template.init(srcs[next(iter(srcs))])
     except StopIteration:
-        src = None
+        T = Template(sr, "stereo", res, [], [])
 
-    return v3(src, tb, sr, res, bg, v, a, v1=None)
+    return v3(tb, bg, T, v, a, v1=None)
 
 
 def read_v1(tl: Any, log: Log) -> v3:
@@ -168,7 +169,7 @@ def read_v1(tl: Any, log: Log) -> v3:
 
     check_file(path, log)
 
-    src = initFileInfo(path, log)
+    src = FileInfo.init(path, log)
 
     vtl: VSpace = []
     atl: ASpace = [[] for _ in range(len(src.audios))]
@@ -207,11 +208,9 @@ def read_v1(tl: Any, log: Log) -> v3:
             atl[a].append(TlAudio(c.start, c.dur, c.src, c.offset, c.speed, 1, a))
 
     return v3(
-        src,
         src.get_fps(),
-        src.get_sr(),
-        src.get_res(),
         "#000",
+        Template.init(src),
         vtl,
         atl,
         v1(src, chunks),

auto_editor/lang/stdenv.py

@@ -13,6 +13,7 @@ from .palet import Syntax, env, is_boolarr, is_iterable, my_eval, p_slice, raise
 if TYPE_CHECKING:
     from typing import Any, Literal
 
+    import numpy as np
     from numpy.typing import NDArray
 
     Number = int | float | complex | Fraction

auto_editor/make_layers.py

@@ -11,7 +11,7 @@ from auto_editor.ffwrapper import FileInfo
 from auto_editor.lang.palet import Lexer, Parser, env, interpret, is_boolean_array
 from auto_editor.lib.data_structs import print_str
 from auto_editor.lib.err import MyError
-from auto_editor.timeline import ASpace, TlAudio, TlVideo, VSpace, v1, v3
+from auto_editor.timeline import ASpace, Template, TlAudio, TlVideo, VSpace, v1, v3
 from auto_editor.utils.func import mut_margin
 from auto_editor.utils.types import CoerceError, time
 
@@ -99,16 +99,17 @@ def parse_time(val: str, arr: NDArray, tb: Fraction) -> int:  # raises: `CoerceE
 
 
 def make_timeline(
-    sources: list[FileInfo],
-    args: Args,
-    sr: int,
-    bar: Bar,
-    log: Log,
+    sources: list[FileInfo], args: Args, sr: int, bar: Bar, log: Log
 ) -> v3:
     inp = None if not sources else sources[0]
 
     if inp is None:
-        tb, res = Fraction(30), (1920, 1080)
+        tb = (
+            Fraction(30)
+            if args.frame_rate is None
+            else make_sane_timebase(args.frame_rate)
+        )
+        res = (1920, 1080) if args.resolution is None else args.resolution
     else:
         tb = make_sane_timebase(
             inp.get_fps() if args.frame_rate is None else args.frame_rate
@@ -302,4 +303,13 @@ def make_timeline(
     else:
         v1_compatiable = None
 
-    return v3(inp, tb, sr, res, args.background, vtl, atl, v1_compatiable)
+    if len(vtl) == 0 and len(atl) == 0:
+        log.error("Timeline is empty, nothing to do.")
+
+    if inp is None:
+        layout = "stereo" if args.audio_layout is None else args.audio_layout
+        template = Template(sr, layout, res, [], [])
+    else:
+        template = Template.init(inp, sr, args.audio_layout, res)
+
+    return v3(tb, args.background, template, vtl, atl, v1_compatiable)

auto_editor/render/audio.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
-import io
+from fractions import Fraction
+from io import BytesIO
 from pathlib import Path
 from typing import TYPE_CHECKING
 
 import bv
 import numpy as np
+from bv import AudioFrame
 from bv.filter.loudnorm import stats
 
 from auto_editor.ffwrapper import FileInfo
@@ -13,17 +15,18 @@ from auto_editor.json import load
 from auto_editor.lang.palet import env
 from auto_editor.lib.contracts import andc, between_c, is_int_or_float
 from auto_editor.lib.err import MyError
-from auto_editor.output import Ensure
 from auto_editor.timeline import TlAudio, v3
-from auto_editor.utils.bar import Bar
 from auto_editor.utils.cmdkw import ParserError, parse_with_palet, pAttr, pAttrs
-from auto_editor.utils.container import Container
+from auto_editor.utils.func import parse_bitrate
 from auto_editor.utils.log import Log
-from auto_editor.wavfile import AudioData, read, write
 
 if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from typing import Any
+
     from auto_editor.__main__ import Args
 
+
 norm_types = {
     "ebu": pAttrs(
         "ebu",
@@ -106,7 +109,7 @@ def apply_audio_normalization(
     else:
         assert "t" in norm
 
-        def get_peak_level(frame: bv.AudioFrame) -> float:
+        def get_peak_level(frame: AudioFrame) -> float:
             # Calculate peak level in dB
             # Should be equivalent to: -af astats=measure_overall=Peak_level:measure_perchannel=0
             max_amplitude = np.abs(frame.to_ndarray()).max()
@@ -143,7 +146,7 @@ def apply_audio_normalization(
             while True:
                 try:
                     aframe = graph.pull()
-                    assert isinstance(aframe, bv.AudioFrame)
+                    assert isinstance(aframe, AudioFrame)
                     output_file.mux(output_stream.encode(aframe))
                 except (bv.BlockingIOError, bv.EOFError):
                     break
@@ -152,20 +155,27 @@ def apply_audio_normalization(
         output_file.close()
 
 
-def process_audio_clip(
-    clip: TlAudio, samp_list: AudioData, samp_start: int, samp_end: int, sr: int
-) -> AudioData:
-    input_buffer = io.BytesIO()
-    write(input_buffer, sr, samp_list[samp_start:samp_end])
+def process_audio_clip(clip: TlAudio, data: np.ndarray, sr: int) -> np.ndarray:
+    to_s16 = bv.AudioResampler(format="s16", layout="stereo", rate=sr)
+    input_buffer = BytesIO()
+
+    with bv.open(input_buffer, "w", format="wav") as container:
+        output_stream = container.add_stream(
+            "pcm_s16le", sample_rate=sr, format="s16", layout="stereo"
+        )
+
+        frame = AudioFrame.from_ndarray(data, format="s16p", layout="stereo")
+        frame.rate = sr
+
+        for reframe in to_s16.resample(frame):
+            container.mux(output_stream.encode(reframe))
+        container.mux(output_stream.encode(None))
+
     input_buffer.seek(0)
 
     input_file = bv.open(input_buffer, "r")
     input_stream = input_file.streams.audio[0]
 
-    output_bytes = io.BytesIO()
-    output_file = bv.open(output_bytes, mode="w", format="wav")
-    output_stream = output_file.add_stream("pcm_s16le", rate=sr)
-
     graph = bv.filter.Graph()
     args = [graph.add_abuffer(template=input_stream)]
 
@@ -191,29 +201,23 @@ def process_audio_clip(
     args.append(graph.add("abuffersink"))
     graph.link_nodes(*args).configure()
 
+    all_frames = []
+    resampler = bv.AudioResampler(format="s16p", layout="stereo", rate=sr)
+
     for frame in input_file.decode(input_stream):
         graph.push(frame)
         while True:
             try:
                 aframe = graph.pull()
-                assert isinstance(aframe, bv.AudioFrame)
-                output_file.mux(output_stream.encode(aframe))
-            except (bv.BlockingIOError, bv.EOFError):
-                break
+                assert isinstance(aframe, AudioFrame)
 
-    # Flush the stream
-    output_file.mux(output_stream.encode(None))
+                for resampled_frame in resampler.resample(aframe):
+                    all_frames.append(resampled_frame.to_ndarray())
 
-    input_file.close()
-    output_file.close()
-
-    output_bytes.seek(0)
-    has_filesig = output_bytes.read(4)
-    output_bytes.seek(0)
-    if not has_filesig:  # Can rarely happen when clip is extremely small
-        return np.empty((0, 2), dtype=np.int16)
+            except (bv.BlockingIOError, bv.EOFError):
+                break
 
-    return read(output_bytes)[1]
+    return np.concatenate(all_frames, axis=1)
 
 
 def mix_audio_files(sr: int, audio_paths: list[str], output_path: str) -> None:
@@ -278,7 +282,7 @@ def mix_audio_files(sr: int, audio_paths: list[str], output_path: str) -> None:
         # Shape becomes (1, samples) for mono
         chunk = np.array([mixed_audio[i : i + chunk_size]])
 
-        frame = bv.AudioFrame.from_ndarray(chunk, format="s16", layout="mono")
+        frame = AudioFrame.from_ndarray(chunk, format="s16", layout="mono")
         frame.rate = sr
         frame.pts = i  # Set presentation timestamp
 
@@ -288,92 +292,223 @@ def mix_audio_files(sr: int, audio_paths: list[str], output_path: str) -> None:
     output_container.close()
 
 
+def file_to_ndarray(src: FileInfo, stream: int, sr: int) -> np.ndarray:
+    all_frames = []
+
+    resampler = bv.AudioResampler(format="s16p", layout="stereo", rate=sr)
+
+    with bv.open(src.path) as container:
+        for frame in container.decode(audio=stream):
+            for resampled_frame in resampler.resample(frame):
+                all_frames.append(resampled_frame.to_ndarray())
+
+    return np.concatenate(all_frames, axis=1)
+
+
+def ndarray_to_file(audio_data: np.ndarray, rate: int, out: str | Path) -> None:
+    layout = "stereo"
+
+    with bv.open(out, mode="w") as output:
+        stream = output.add_stream("pcm_s16le", rate=rate, format="s16", layout=layout)
+
+        frame = bv.AudioFrame.from_ndarray(audio_data, format="s16p", layout=layout)
+        frame.rate = rate
+
+        output.mux(stream.encode(frame))
+        output.mux(stream.encode(None))
+
+
+def ndarray_to_iter(
+    audio_data: np.ndarray, fmt: bv.AudioFormat, layout: str, rate: int
+) -> Iterator[AudioFrame]:
+    chunk_size = rate // 4  # Process 0.25 seconds at a time
+
+    resampler = bv.AudioResampler(rate=rate, format=fmt, layout=layout)
+    for i in range(0, audio_data.shape[1], chunk_size):
+        chunk = audio_data[:, i : i + chunk_size]
+
+        frame = AudioFrame.from_ndarray(chunk, format="s16p", layout="stereo")
+        frame.rate = rate
+        frame.pts = i
+
+        yield from resampler.resample(frame)
+
+
 def make_new_audio(
-    tl: v3, ctr: Container, ensure: Ensure, args: Args, bar: Bar, log: Log
-) -> list[str]:
+    output: bv.container.OutputContainer,
+    audio_format: bv.AudioFormat,
+    tl: v3,
+    args: Args,
+    log: Log,
+) -> tuple[list[bv.AudioStream], list[Iterator[AudioFrame]]]:
+    audio_inputs = []
+    audio_gen_frames = []
+    audio_streams: list[bv.AudioStream] = []
+    audio_paths = _make_new_audio(tl, audio_format, args, log)
+
+    for i, audio_path in enumerate(audio_paths):
+        audio_stream = output.add_stream(
+            args.audio_codec,
+            rate=tl.sr,
+            format=audio_format,
+            layout=tl.T.layout,
+            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(tl.T.audios) and (lang := tl.T.audios[i].lang) is not None:
+            audio_stream.metadata["language"] = lang
+
+        audio_streams.append(audio_stream)
+
+        if isinstance(audio_path, str):
+            audio_input = bv.open(audio_path)
+            audio_inputs.append(audio_input)
+            audio_gen_frames.append(audio_input.decode(audio=0))
+        else:
+            audio_gen_frames.append(audio_path)
+
+    return audio_streams, audio_gen_frames
+
+
+class Getter:
+    __slots__ = ("container", "stream", "rate")
+
+    def __init__(self, path: Path, stream: int, rate: int):
+        self.container = bv.open(path)
+        self.stream = self.container.streams.audio[0]
+        self.rate = rate
+
+    def get(self, start: int, end: int) -> np.ndarray:
+        # start/end is in samples
+
+        container = self.container
+        stream = self.stream
+        resampler = bv.AudioResampler(format="s16p", layout="stereo", rate=self.rate)
+
+        time_base = stream.time_base
+        assert time_base is not None
+        start_pts = int(start / self.rate / time_base)
+
+        # Seek to the approximate position
+        container.seek(start_pts, stream=stream)
+
+        all_frames = []
+        total_samples = 0
+        target_samples = end - start
+
+        # Decode frames until we have enough samples
+        for frame in container.decode(stream):
+            for resampled_frame in resampler.resample(frame):
+                frame_array = resampled_frame.to_ndarray()
+                all_frames.append(frame_array)
+                total_samples += frame_array.shape[1]
+
+                if total_samples >= target_samples:
+                    break
+
+            if total_samples >= target_samples:
+                break
+
+        result = np.concatenate(all_frames, axis=1)
+
+        # Trim to exact size
+        if result.shape[1] > target_samples:
+            result = result[:, :target_samples]
+        elif result.shape[1] < target_samples:
+            # Pad with zeros if we don't have enough samples
+            padding = np.zeros(
+                (result.shape[0], target_samples - result.shape[1]), dtype=result.dtype
+            )
+            result = np.concatenate([result, padding], axis=1)
+
+        assert result.shape[1] == end - start
+        return result  # Return NumPy array with shape (channels, samples)
+
+
+def _make_new_audio(tl: v3, fmt: bv.AudioFormat, args: Args, log: Log) -> list[Any]:
     sr = tl.sr
     tb = tl.tb
-    output: list[str] = []
-    samples: dict[tuple[FileInfo, int], AudioData] = {}
+    output: list[Any] = []
+    samples: dict[tuple[FileInfo, int], Getter] = {}
 
     norm = parse_norm(args.audio_normalize, log)
 
-    temp = log.temp
-
-    if not tl.a or not tl.a[0]:
+    if not tl.a[0]:
         log.error("Trying to render empty audio timeline")
 
-    for i, layer in enumerate(tl.a):
-        bar.start(len(layer), "Creating new audio")
+    layout = tl.T.layout
+    try:
+        bv.AudioLayout(layout)
+    except ValueError:
+        log.error(f"Invalid audio layout: {layout}")
 
-        path = Path(temp, f"new{i}.wav")
-        output.append(f"{path}")
-        arr: AudioData | None = None
+    for i, layer in enumerate(tl.a):
+        arr: np.ndarray | None = None
+        use_iter = False
 
         for c, clip in enumerate(layer):
             if (clip.src, clip.stream) not in samples:
-                audio_path = ensure.audio(clip.src, clip.stream)
-                with open(audio_path, "rb") as file:
-                    samples[(clip.src, clip.stream)] = read(file)[1]
+                samples[(clip.src, clip.stream)] = Getter(
+                    clip.src.path, clip.stream, sr
+                )
 
+            log.conwrite("Creating audio")
             if arr is None:
                 leng = max(round((layer[-1].start + layer[-1].dur) * sr / tb), sr // tb)
-                dtype = np.int32
-                for _samp_arr in samples.values():
-                    dtype = _samp_arr.dtype
-                    break
+                map_path = Path(log.temp, f"{i}.map")
+                arr = np.memmap(map_path, mode="w+", dtype=np.int16, shape=(2, leng))
 
-                arr = np.memmap(
-                    Path(temp, "asdf.map"),
-                    mode="w+",
-                    dtype=dtype,
-                    shape=(leng, 2),
-                )
-                del leng
-
-            samp_list = samples[(clip.src, clip.stream)]
             samp_start = round(clip.offset * clip.speed * sr / tb)
             samp_end = round((clip.offset + clip.dur) * clip.speed * sr / tb)
-            if samp_end > len(samp_list):
-                samp_end = len(samp_list)
+
+            getter = samples[(clip.src, clip.stream)]
 
             if clip.speed != 1 or clip.volume != 1:
-                clip_arr = process_audio_clip(clip, samp_list, samp_start, samp_end, sr)
+                clip_arr = process_audio_clip(
+                    clip, getter.get(samp_start, samp_end), sr
+                )
             else:
-                clip_arr = samp_list[samp_start:samp_end]
+                clip_arr = getter.get(samp_start, samp_end)
 
             # Mix numpy arrays
             start = clip.start * sr // tb
-            car_len = clip_arr.shape[0]
-
-            if start + car_len > len(arr):
-                # Clip 'clip_arr' if bigger than expected.
-                arr[start:] += clip_arr[: len(arr) - start]
+            clip_samples = clip_arr.shape[1]
+            if start + clip_samples > arr.shape[1]:
+                # Shorten `clip_arr` if bigger than expected.
+                arr[:, start:] += clip_arr[:, : arr.shape[1] - start]
             else:
-                arr[start : start + car_len] += clip_arr
-
-            bar.tick(c)
+                arr[:, start : start + clip_samples] += clip_arr
 
         if arr is not None:
             if norm is None:
-                with open(path, "wb") as fid:
-                    write(fid, sr, arr)
+                if args.mix_audio_streams:
+                    path = Path(log.temp, f"new{i}.wav")
+                    ndarray_to_file(arr, sr, path)
+                    output.append(f"{path}")
+                else:
+                    use_iter = True
             else:
-                pre_master = Path(temp, "premaster.wav")
-                with open(pre_master, "wb") as fid:
-                    write(fid, sr, arr)
+                path = Path(log.temp, f"new{i}.wav")
+                pre_master = Path(log.temp, "premaster.wav")
 
+                ndarray_to_file(arr, sr, pre_master)
                 apply_audio_normalization(norm, pre_master, path, log)
+                output.append(f"{path}")
 
-        bar.end()
-
-    try:
-        Path(temp, "asdf.map").unlink(missing_ok=True)
-    except PermissionError:
-        pass
+        if use_iter and arr is not None:
+            output.append(ndarray_to_iter(arr, fmt, layout, sr))
 
     if args.mix_audio_streams and len(output) > 1:
-        new_a_file = f"{Path(temp, 'new_audio.wav')}"
+        new_a_file = f"{Path(log.temp, 'new_audio.wav')}"
         mix_audio_files(sr, output, new_a_file)
         return [new_a_file]
+
     return output

auto_editor/render/video.py

@@ -6,8 +6,8 @@ from typing import TYPE_CHECKING
 import bv
 import numpy as np
 
-from auto_editor.output import parse_bitrate
 from auto_editor.timeline import TlImage, TlRect, TlVideo
+from auto_editor.utils.func import parse_bitrate
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -61,7 +61,6 @@ def render_av(
 ) -> Iterator[tuple[int, bv.VideoFrame]]:
     from_ndarray = bv.VideoFrame.from_ndarray
 
-    src = tl.src
     cns: dict[FileInfo, bv.container.InputContainer] = {}
     decoders: dict[FileInfo, Iterator[bv.VideoFrame]] = {}
     seek_cost: dict[FileInfo, int] = {}