muxtools 0.2.2__tar.gz → 0.3.0__tar.gz

muxtools-0.3.0/.github/workflows/publish.yml

@@ -0,0 +1,26 @@
+name: Publish releases when new tag
+on:
+  push:
+    tags:
+      - v[0-9]+**
+
+jobs:
+  package_build:
+    name: Build and push to PyPI
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Prep Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Build
+        run: pipx run build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          user: __token__
+          password: ${{ secrets.AUTH_TOKEN }}

muxtools-0.3.0/.gitignore

@@ -0,0 +1,167 @@
+# Specific to this package
+_binaries/
+premux/
+_workdir/
+config.ini
+/test.py
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/

muxtools-0.3.0/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "tests/test-data"]
+	path = tests/test-data
+	url = https://github.com/Vodes/muxtools-test-data.git

muxtools-0.3.0/.vscode/settings.json

@@ -0,0 +1,10 @@
+{
+    "[python]": {
+        "editor.formatOnType": false,
+        "editor.formatOnSave": true,
+        "editor.defaultFormatter": "charliermarsh.ruff"
+    },
+    "ruff.lint.enable": true,
+    "ruff.lint.args": ["--config", "./pyproject.toml"],
+    "ruff.format.args": ["--config", "./pyproject.toml"]
+}

{muxtools-0.2.2 → muxtools-0.3.0}/PKG-INFO

@@ -1,34 +1,34 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: muxtools
-Version: 0.2.2
+Version: 0.3.0
 Summary: A library for various muxing and automation tools for anything and everything fansubbing related
-Author-email: Vodes <vodes.imp@gmail.com>
-License: MPL 2.0
 Project-URL: Source Code, https://github.com/Vodes/muxtools
-Classifier: Natural Language :: English
+Author-email: Vodes <vodes.imp@gmail.com>
+License-Expression: MPL-2.0
+License-File: LICENSE
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: End Users/Desktop
-Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
-Classifier: Typing :: Typed
+Classifier: Programming Language :: Python :: 3.10
 Classifier: Topic :: Multimedia :: Sound/Audio
 Classifier: Topic :: Multimedia :: Sound/Audio :: Conversion
 Classifier: Topic :: Multimedia :: Video
 Classifier: Topic :: Multimedia :: Video :: Conversion
-Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: requests>=2.31.0
-Requires-Dist: fontcollector>=3.0.0
 Requires-Dist: ass>=0.5.3
-Requires-Dist: wget>=3.2
-Requires-Dist: py7zr>=0.20.5
+Requires-Dist: fontcollector>=3.0.0
+Requires-Dist: psutil>=5.6.4
+Requires-Dist: pydantic>=2.5.0
 Requires-Dist: pymediainfo>=6.0.1
-Requires-Dist: rich>=13.1.0
 Requires-Dist: pyparsebluray>=0.1.4
-Requires-Dist: pydantic>=2.5.0
-Requires-Dist: psutil>=5.6.4
+Requires-Dist: requests>=2.31.0
+Requires-Dist: rich>=13.1.0
+Requires-Dist: videotimestamps>=0.2.0
+Requires-Dist: wget>=3.2
+Description-Content-Type: text/markdown
 
 # muxtools
 

{muxtools-0.2.2 → muxtools-0.3.0}/muxtools/__init__.py

@@ -12,7 +12,7 @@ from .functions import *
 
 def entry_point():
     import sys
-    from .cli import install_libraries, install_dependencies
+    from .cli import install_libraries, install_dependencies, generate_videometa
 
     if sys.argv:
         if sys.argv[-1].lower() in ["libs", "libraries"]:
@@ -21,8 +21,16 @@ def entry_point():
         elif sys.argv[-1].lower() in ["install", "deps", "dependencies"]:
             install_dependencies()
             sys.exit(0)
+        else:
+            if len(sys.argv) > 1:
+                if sys.argv[1].lower() in ["gen-vm", "generate-videometa"]:
+                    file_in = None if len(sys.argv) < 3 else sys.argv[2]
+                    file_out = None if len(sys.argv) < 4 else sys.argv[3]
+                    generate_videometa(file_in, file_out)
+                    sys.exit(0)
 
     error(
         "No arguments passed.\nYou can use [b]libs[/] or [b]libraries[/] to install/update libraries of qaac and eac3to."
-        + "\nYou can use [b]install[/], [b]deps[/] or [b]dependencies[/] to install all sorts of executables."
+        + "\nYou can use [b]install[/], [b]deps[/] or [b]dependencies[/] to install all sorts of executables.\n\n"
+        + "You can also use [b]generate-videometa[/] or [b]gen-vm[/] to generate a VideoMeta file for a video."
     )

{muxtools-0.2.2 → muxtools-0.3.0}/muxtools/audio/encoders.py

@@ -2,6 +2,7 @@ from collections.abc import Sequence
 from pydantic.dataclasses import dataclass, Field
 import subprocess
 import os
+import re
 
 from .tools import Encoder, LosslessEncoder
 from .preprocess import Preprocessor, Resample, Downmix
@@ -26,6 +27,8 @@ class FLAC(LosslessEncoder):
     :param compression_level:   Any int value from 0 to 8 (Higher = better but slower)
     :param preprocess:          Any amount of preprocessors to run before passing it to the encoder.
     :param verify:              Make the encoder verify each encoded sample while encoding to ensure valid output.
+    :param threads:             Number of threads to use for encoding. (Requires FLAC 1.5.0)
+                                `None` will choose whatever your CPU has with a max of 8.
     :param output:              Custom output. Can be a dir or a file.
                                 Do not specify an extension unless you know what you're doing.
     """
@@ -33,12 +36,14 @@ class FLAC(LosslessEncoder):
     compression_level: int = 8
     preprocess: Preprocessor | Sequence[Preprocessor] | None = Field(default_factory=Resample)
     verify: bool = True
+    threads: int | None = None
     output: PathLike | None = None
 
     def encode_audio(self, fileIn: AudioFile | PathLike, quiet: bool = True, **kwargs) -> AudioFile:
         if not isinstance(fileIn, AudioFile):
             fileIn = AudioFile.from_file(fileIn, self)
         flac = get_executable("flac")
+        version = get_binary_version(flac, r"flac .+? version (\d\.\d+\.\d+)")
         output = make_output(fileIn.file, "flac", "libflac", self.output)
         source = ensure_valid_in(fileIn, preprocess=self.preprocess, caller=self, valid_type=ValidInputType.W64_OR_FLAC, supports_pipe=False)
         info(f"Encoding '{fileIn.file.stem}' to FLAC using libFLAC...", self)
@@ -46,12 +51,21 @@ class FLAC(LosslessEncoder):
         args = [flac, f"-{self.compression_level}", "-o", str(output)] + self.get_custom_args()
         if self.verify:
             args.append("--verify")
+
+        if self.threads or self.threads is None:
+            if re.search(r"1\.[2|3|4]\.\d+?", version):
+                warn("Using outdated FLAC encoder that does not support threading!", self)
+            else:
+                if self.threads is None:
+                    self.threads = min(os.cpu_count(), 8)
+                args.append(f"--threads={self.threads}")
+
         args.append(str(source.file.resolve()) if isinstance(source, AudioFile) else "-")
 
         stdin = subprocess.DEVNULL if isinstance(source, AudioFile) else source.stdout
 
         if not run_cmd_pb(args, quiet, ProgressBarConfig("Encoding..."), shell=False, stdin=stdin):
-            tags = version_settings_dict(self.get_mediainfo_settings(args), flac, r"flac .+? version (\d\.\d+\.\d+)", prepend="FLAC")
+            tags = dict(ENCODER=f"FLAC {version}", ENCODER_SETTINGS=self.get_mediainfo_settings(args))
             clean_temp_files()
             return AudioFile(output, fileIn.container_delay, fileIn.source, tags=tags)
         else:
@@ -304,7 +318,7 @@ class FDK_AAC(Encoder):
             exe = get_executable("ffmpeg") if not self.use_binary else get_executable("fdkaac")
 
         if os.name == "nt":
-            warn("It is strongly recommended to use qAAC on windows. See docs.", self, 5)
+            warn("It is strongly recommended to use qAAC on windows. See docs.", self, 1)
         info(f"Encoding '{fileIn.file.stem}' to AAC using libFDK...", self)
 
         tags = dict[str, str]()

{muxtools-0.2.2 → muxtools-0.3.0}/muxtools/audio/extractors.py

@@ -14,10 +14,10 @@ from ..utils.log import error, warn, debug, info
 from ..utils.download import get_executable
 from ..utils.parsing import parse_audioinfo
 from ..utils.files import get_absolute_track
-from ..utils.types import Trim, PathLike, TrackType
+from ..utils.types import Trim, PathLike, TrackType, TimeSourceT, TimeScaleT, TimeScale
 from ..utils.env import get_temp_workdir, run_commandline, communicate_stdout
 from ..utils.subprogress import run_cmd_pb, ProgressBarConfig
-from ..utils.convert import frame_to_timedelta, format_timedelta, frame_to_ms
+from ..utils.convert import format_timedelta, resolve_timesource_and_scale, TimeType
 
 __all__ = ["Eac3to", "Sox", "FFMpeg", "MkvExtract"]
 
@@ -63,7 +63,7 @@ class Eac3to(Extractor):
         info(f"Extracting audio track {self.track} from '{input.stem}'...", self)
 
         out = make_output(input, extension, f"extracted_{self.track}", self.output)
-        code, stdout = communicate_stdout(f'"{eac3to}" "{input}" {track.track_id+1}: "{out}" {self.append}')
+        code, stdout = communicate_stdout(f'"{eac3to}" "{input}" {track.track_id + 1}: "{out}" {self.append}')
         if code == 0:
             if not out.exists():
                 pattern_str = rf"{re.escape(out.stem)} DELAY.*\.{extension}"
@@ -171,9 +171,11 @@ class FFMpeg(HasExtractor, HasTrimmer):
         If you're working with lossless files it is strongly recommended to use SoX instead.
 
         :param trim:                Can be a single trim or a sequence of trims.
-        :param trim_use_ms:         Will use milliseconds instead of frame numbers
-        :param fps:                 Fps fraction that will be used for the conversion. Also accepts a timecode (v2) file.
         :param preserve_delay:      Will preserve existing container delay
+        :param trim_use_ms:         Will use milliseconds instead of frame numbers
+        :param timesource:          The source of timestamps/timecodes. For details check the docstring on the type.
+        :param timescale:           Unit of time (in seconds) in terms of which frame timestamps are represented.\n
+                                    For details check the docstring on the type.
         :param num_frames:          Total number of frames used for calculations
         :param output:              Custom output. Can be a dir or a file.
                                     Do not specify an extension unless you know what you're doing.
@@ -182,7 +184,8 @@ class FFMpeg(HasExtractor, HasTrimmer):
         trim: Trim | list[Trim] | None = None
         preserve_delay: bool = False
         trim_use_ms: bool = False
-        fps: Fraction | PathLike = Fraction(24000, 1001)
+        timesource: TimeSourceT = Fraction(24000, 1001)
+        timescale: TimeScaleT = TimeScale.MKV
         num_frames: int = 0
         output: PathLike | None = None
 
@@ -208,18 +211,21 @@ class FFMpeg(HasExtractor, HasTrimmer):
                 if self.trim_use_ms:
                     arg += f" -ss {format_timedelta(timedelta(milliseconds=trim[0]))}"
                 else:
-                    arg += f" -ss {format_timedelta(frame_to_timedelta(trim[0], self.fps))}"
+                    millis = self.resolved_ts.frame_to_time(trim[0], TimeType.EXACT, 3)
+                    arg += f" -ss {format_timedelta(timedelta(milliseconds=millis))}"
             if trim[1] is not None and trim[1] != 0:
                 end_frame = self.num_frames + trim[1] if trim[1] < 0 else trim[1]
                 if self.trim_use_ms:
                     arg += f" -to {format_timedelta(timedelta(milliseconds=trim[1]))}"
                 else:
-                    arg += f" -to {format_timedelta(frame_to_timedelta(end_frame, self.fps))}"
+                    millis = self.resolved_ts.frame_to_time(end_frame, TimeType.EXACT, 3)
+                    arg += f" -to {format_timedelta(timedelta(milliseconds=millis))}"
             return arg
 
         def trim_audio(self, input: AudioFile, quiet: bool = True) -> AudioFile:
             if not isinstance(input, AudioFile):
                 input = AudioFile.from_file(input, self)
+            self.resolved_ts = resolve_timesource_and_scale(self.timesource, self.timescale, caller=self)
             self.trim = sanitize_trims(self.trim, self.num_frames, not self.trim_use_ms, caller=self)
             minfo = input.get_mediainfo()
             form = format_from_track(minfo)
@@ -248,7 +254,7 @@ class FFMpeg(HasExtractor, HasTrimmer):
                 args.append(str(out.resolve()))
                 if not run_commandline(args, quiet):
                     if tr[0] and lossy:
-                        ms = tr[0] if self.trim_use_ms else frame_to_ms(tr[0], self.fps)
+                        ms = tr[0] if self.trim_use_ms else self.resolved_ts.frame_to_time(tr[0], TimeType.EXACT, 3)
                         cont_delay = self._calc_delay(ms, ainfo.num_samples(), getattr(minfo, "sampling_rate", 48000))
                         debug(f"Additional delay of {cont_delay} ms will be applied to fix remaining sync", self)
                         if self.preserve_delay:
@@ -269,8 +275,10 @@ class FFMpeg(HasExtractor, HasTrimmer):
                     if lossy:
                         nArgs[2:1] = splitcommand(self._targs(tr))
                         if first:
-                            cont_delay = self._calc_delay(ms, ainfo.num_samples(), getattr(minfo, "sampling_rate", 48000))
-                            debug(f"Additional delay of {cont_delay} ms will be applied to fix remaining sync", self)
+                            if tr[0]:
+                                ms = tr[0] if self.trim_use_ms else self.resolved_ts.frame_to_time(tr[0], TimeType.EXACT, 3)
+                                cont_delay = self._calc_delay(ms, ainfo.num_samples(), getattr(minfo, "sampling_rate", 48000))
+                                debug(f"Additional delay of {cont_delay} ms will be applied to fix remaining sync", self)
                             first = False
                     else:
                         nArgs.extend(splitcommand(self._targs(tr)))
@@ -366,7 +374,9 @@ class Sox(Trimmer):
     :param trim:                List of Trims or a single Trim, which is a Tuple of two frame numbers or milliseconds
     :param preserve_delay:      Keeps existing container delay if True
     :param trim_use_ms:         Will use milliseconds instead of frame numbers
-    :param fps:                 The fps fraction used for the calculations. Also accepts a timecode (v2) file.
+    :param timesource:          The source of timestamps/timecodes. For details check the docstring on the type.
+    :param timescale:           Unit of time (in seconds) in terms of which frame timestamps are represented.\n
+                                For details check the docstring on the type.
     :param num_frames:          Total number of frames used for calculations
     :param output:              Custom output. Can be a dir or a file.
                                 Do not specify an extension unless you know what you're doing.
@@ -375,7 +385,8 @@ class Sox(Trimmer):
     trim: Trim | list[Trim] | None = None
     preserve_delay: bool = False
     trim_use_ms: bool = False
-    fps: Fraction | PathLike = Fraction(24000, 1001)
+    timesource: TimeSourceT = Fraction(24000, 1001)
+    timescale: TimeScaleT = TimeScale.MKV
     num_frames: int = 0
     output: PathLike | None = None
 
@@ -386,7 +397,7 @@ class Sox(Trimmer):
         if self.trim_use_ms:
             return abs(val) / 1000
         else:
-            return frame_to_timedelta(abs(val), self.fps).total_seconds()
+            return self.resolved_ts.frame_to_time(abs(val), TimeType.EXACT).__float__()
 
     def trim_audio(self, input: AudioFile, quiet: bool = True) -> AudioFile:
         import sox
@@ -394,6 +405,7 @@ class Sox(Trimmer):
         if not isinstance(input, AudioFile):
             input = AudioFile.from_file(input, self)
         out = make_output(input.file, "flac", "trimmed", self.output)
+        self.resolved_ts = resolve_timesource_and_scale(self.timesource, self.timescale, caller=self)
         self.trim = sanitize_trims(self.trim, self.num_frames, not self.trim_use_ms, allow_negative_start=True, caller=self)
         source = ensure_valid_in(input, caller=self, supports_pipe=False)
 

{muxtools-0.2.2 → muxtools-0.3.0}/muxtools/audio/tools.py

@@ -15,7 +15,7 @@ class HasTrimmer(ABC):
 
 class Extractor(CLIKwargs):
     _no_print = False
-    
+
     @abstractmethod
     def extract_audio(self, input: PathLike, quiet: bool = True) -> AudioFile:
         pass

{muxtools-0.2.2 → muxtools-0.3.0}/muxtools/cli.py

@@ -1,15 +1,17 @@
 import os
 import re
+import sys
 import wget
 import shlex
 import shutil
 import subprocess
 from pathlib import Path
 
-from .utils.log import info, warn
+from .utils.log import info, warn, error
 from .utils.download import unpack_all
 from .utils.env import get_temp_workdir
-from .utils.files import clean_temp_files
+from .utils.files import clean_temp_files, ensure_path_exists, ensure_path, is_video_file
+from .utils.convert import get_timemeta_from_video
 
 CONF = "([green bold]Y[/] | [red]n[/])"
 
@@ -212,3 +214,22 @@ def _run_powershell(args: str | list[str], quiet: bool = False) -> int:
     p.communicate()
     print("")
     return p.returncode
+
+
+def generate_videometa(file: str | None = None, output: str | None = None):
+    if not file:
+        error("You have to pass an input video file!", None)
+        sys.exit(1)
+
+    in_path = ensure_path_exists(file, None)
+    if not is_video_file(in_path):
+        error(f'"{in_path.name}" is not a video file!', None)
+        sys.exit(1)
+
+    if not output:
+        info("Generating VideoMeta file in your current work directory.", None)
+        output = ensure_path(os.getcwd(), None) / f"{in_path.stem}_meta.json"
+    else:
+        output = ensure_path(output, None)
+
+    get_timemeta_from_video(in_path, output, None)

{muxtools-0.2.2 → muxtools-0.3.0}/muxtools/functions.py

@@ -1,8 +1,8 @@
 from fractions import Fraction
 from datetime import timedelta
-from collections.abc import Sequence
 
 from .utils.log import warn, error, info, danger
+from .utils.types import TimeScaleT, TimeScale, TimeSourceT
 from .muxing.muxfiles import AudioFile
 from .audio.audioutils import is_fancy_codec
 from .audio.encoders import Opus
@@ -19,9 +19,10 @@ def do_audio(
     fileIn: PathLike | list[PathLike],
     track: int = 0,
     trims: Trim | list[Trim] | None = None,
-    fps: Fraction | PathLike | Sequence[int] = Fraction(24000, 1001),
+    timesource: TimeSourceT = Fraction(24000, 1001),
+    timescale: TimeScaleT = TimeScale.MKV,
     num_frames: int = 0,
-    extractor: Extractor = FFMpeg.Extractor(),
+    extractor: Extractor | None = FFMpeg.Extractor(),
     trimmer: Trimmer | None = AutoTrimmer(),
     encoder: Encoder | None = AutoEncoder(),
     quiet: bool = True,
@@ -33,14 +34,16 @@ def do_audio(
     :param fileIn:          Input file
     :param track:           Audio track number
     :param trims:           Frame ranges to trim and/or combine, e.g. (24, -24) or [(24, 500), (700, 900)]
-    :param fps:             FPS Fraction used for the conversion to time. Also accepts a timecode (v2) file.
+    :param timesource:      The source of timestamps/timecodes. For details check the docstring on the type.
+    :param timescale:       Unit of time (in seconds) in terms of which frame timestamps are represented.\n
+                            For details check the docstring on the type.
     :param num_frames:      Total number of frames, used for negative numbers in trims
     :param extractor:       Tool used to extract the audio
     :param trimmer:         Tool used to trim the audio
                             AutoTrimmer means it will choose ffmpeg for lossy and Sox for lossless
 
     :param encoder:         Tool used to encode the audio
-                            AutoEncoder means it won't reencode lossy and choose opus otherwise
+                            AutoEncoder means it won't reencode lossy and choose opus otherwise.
 
     :param quiet:           Whether the tool output should be visible
     :param output:          Custom output file or directory, extensions will be automatically added
@@ -77,6 +80,8 @@ def do_audio(
             audio = FFMpeg.Concat(extracted).concat_audio()
         else:
             audio = extractor.extract_audio(fileIn, quiet)
+    else:
+        audio = ensure_path_exists(fileIn, do_audio)
 
     if not isinstance(audio, AudioFile):
         audio = AudioFile.from_file(audio, do_audio)
@@ -89,22 +94,23 @@ def do_audio(
         else:
             trimmer = Sox()
 
+    mediainfo = audio.get_mediainfo()
+
     if isinstance(encoder, AutoEncoder):
         if lossy:
             encoder = None
-        elif is_fancy_codec(audio.get_mediainfo()):
+        elif is_fancy_codec(mediainfo):
             encoder = None
             warn("Audio will not be reencoded due to having Atmos or special DTS features.", do_audio, 2)
         else:
             encoder = Opus()
 
     if trimmer and trims:
-        if not isinstance(fps, str) and isinstance(fps, Sequence):
-            fps = Fraction(*fps)
         setattr(trimmer, "trim", trims)
-        setattr(trimmer, "fps", fps)
+        setattr(trimmer, "timesource", timesource)
+        setattr(trimmer, "timescale", timescale)
         setattr(trimmer, "num_frames", num_frames)
-        if not extractor and not encoder:
+        if not encoder:
             setattr(trimmer, "output", output)
         trimmed = trimmer.trim_audio(audio, quiet)
         ensure_path(audio.file, do_audio).unlink(missing_ok=True)