muxtools 0.0.1__py3-none-any.whl

muxtools/__init__.py

@@ -0,0 +1,28 @@
+from .utils import *
+from .muxing import *
+from .audio import *
+from .subtitle import *
+from .misc import *
+
+from . import main
+from . import functions
+from .main import *
+from .functions import *
+
+
+def entry_point():
+    import sys
+    from .cli import install_libraries, install_dependencies
+
+    if sys.argv:
+        if sys.argv[-1].lower() in ["libs", "libraries"]:
+            install_libraries()
+            sys.exit(0)
+        elif sys.argv[-1].lower() in ["install", "deps", "dependencies"]:
+            install_dependencies()
+            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."
+    )

muxtools/__main__.py

@@ -0,0 +1,4 @@
+from . import entry_point
+
+if __name__ == "__main__":
+    entry_point()

muxtools/audio/__init__.py

@@ -0,0 +1,6 @@
+from . import encoders, extractors, tools
+
+from .audioutils import *
+from .encoders import *
+from .extractors import *
+from .tools import *

muxtools/audio/audioutils.py

@@ -0,0 +1,216 @@
+import os
+import re
+import subprocess
+from shutil import rmtree
+from pymediainfo import Track
+from functools import cmp_to_key
+
+
+from ..utils.log import warn, error
+from ..muxing.muxfiles import AudioFile
+from ..utils.env import get_temp_workdir
+from ..utils.download import get_executable
+from ..utils.types import DitherType, Trim, AudioFormat
+
+__all__ = ["ensure_valid_in", "sanitize_trims", "format_from_track", "is_fancy_codec", "has_libFLAC", "has_libFDK"]
+
+
+def ensure_valid_in(
+    input: AudioFile,
+    supports_pipe: bool = True,
+    dither: bool = True,
+    dither_type: DitherType = DitherType.TRIANGULAR,
+    caller: any = None,
+) -> AudioFile | subprocess.Popen:
+    """
+    Ensures valid input for any encoder that accepts flac (all of them).
+    Passes existing file if no need to dither and is either wav or flac.
+    """
+    from .encoders import FF_FLAC
+
+    def getflac(input: AudioFile):
+        if supports_pipe:
+            return FF_FLAC(dither=dither, dither_type=dither_type).get_pipe(input)
+        else:
+            return FF_FLAC(
+                compression_level=0, dither=dither, dither_type=dither_type, output=os.path.join(get_temp_workdir(), "tempflac")
+            ).encode_audio(input, temp=True)
+
+    if input.has_multiple_tracks(caller):
+        msg = f"'{input.name}' is a container with multiple tracks.\n"
+        msg += f"The first audio track will be {'piped' if supports_pipe else 'extracted'} using default ffmpeg."
+        warn(msg, caller, 5)
+
+    minfo = input.get_mediainfo()
+    if is_fancy_codec(minfo):
+        warn("Encoding tracks with special DTS Features or Atmos is very much discouraged.", caller, 10)
+    form = minfo.format.lower()
+    if "wav" in form or "flac" in form or "pcm" in form:
+        if minfo.bit_depth > 16 and dither:
+            return getflac(input)
+        return input
+    else:
+        if input.is_lossy():
+            warn(f"It's strongly recommended to not reencode lossy audio! ({minfo.format})", caller, 5)
+        return getflac(input)
+
+
+def compare_trims(trim: Trim, trim2: Trim):
+    if trim[0] is None and trim2[0] is not None:
+        return -1
+    elif trim[0] is not None and trim2[0] is None:
+        return 1
+    else:
+        if trim[0] is None and trim2[0] is None:
+            return trim[1] - trim2[1]
+        else:
+            return trim[0] - trim2[0]
+
+
+def clean_trims(trims: list[Trim]):
+    sorted_trims = sorted(trims, key=cmp_to_key(compare_trims))
+
+    final_trims = []
+    for start, end in sorted_trims:
+        if final_trims:
+            prev_start, prev_end = final_trims[-1]
+            if start is None and prev_end is not None:
+                continue
+            elif prev_end is not None and prev_end >= start:
+                final_trims[-1] = (prev_start, max(prev_end, end))
+            elif prev_end is None and end is None:
+                continue
+            else:
+                final_trims.append((start, end))
+        elif start is not None or end is not None:
+            final_trims.append((start, end))
+
+    return final_trims
+
+
+def sanitize_trims(
+    trims: Trim | list[Trim], total_frames: int = 0, uses_frames: bool = True, allow_negative_start: bool = False, caller: any = None
+) -> list[Trim]:
+    caller = caller if caller else sanitize_trims
+    if not isinstance(trims, (list, tuple)):
+        raise error("Trims must be a list of 2-tuples (or just one 2-tuple)", caller)
+    if not isinstance(trims, list):
+        trims = [trims]
+    for index, trim in enumerate(trims):
+        if not isinstance(trim, tuple):
+            raise error(f"The trim {trim} is not a tuple", caller)
+        if len(trim) != 2:
+            raise error(f"The trim {trim} needs 2 elements", caller)
+        for i in trim:
+            if not isinstance(i, (int, type(None))):
+                raise error(f"The trim {trim} must have 2 ints or None's", caller)
+        if trim[-1] == 0:
+            raise error("Slices cannot end with 0, if attempting to use an empty slice, use `None`", caller)
+
+        if trim[0] and trim[0] < 0 and not allow_negative_start:
+            raise error("The first part of a trim cannot be negative.", caller)
+
+        if trim[1] and uses_frames:
+            if total_frames and trim[1] > total_frames:
+                warn(f"The trim {trim} extends the frame number that was passed. Will be set to max frame.", caller, 5)
+                trims[index] = (trim[0], total_frames - 1)
+            if trim[1] < 0:
+                if not total_frames:
+                    raise error("A trim cannot be negative if you're not passing the total frame number.", caller)
+                new_val = total_frames + trim[1]
+                trims[index] = (trim[0], new_val)
+                if new_val < 0:
+                    raise error(f"The negative number of the trim {trim} is out of bounds.", caller)
+
+    return clean_trims(trims)
+
+
+# Of course these are not all of the formats possible but those are the most common from what I know.
+# fmt: off
+formats = [
+    # Lossy
+    AudioFormat("AC-3",         "ac3",      "A_AC3"),
+    AudioFormat("E-AC-3",       "eac3",     "A_EAC3"),
+    AudioFormat("AAC*",         "m4a",      "A_AAC*"), # Lots of different AAC formats idk what they mean, don't care either
+    AudioFormat("Opus",         "opus",     "A_OPUS"),
+    AudioFormat("Vorbis",       "ogg",      "A_VORBIS"),
+    AudioFormat("/",            "mp3",      "mp4a-6B"), # MP3 has the format name split up into 3 variables so we're gonna ignore this
+    
+    # Lossless
+    AudioFormat("FLAC",         "flac",     "A_FLAC", False),
+    AudioFormat("MLP FBA*",     "thd",      "A_TRUEHD", False), # Atmos stuff has some more shit in the format name
+    AudioFormat("PCM*",         "wav",      "A_PCM*", False),
+
+    # Disgusting DTS Stuff
+    AudioFormat("DTS XLL",      "dtshd",    "A_DTS", False), # Can be HD-MA or Headphone X or X, who the fuck knows
+    AudioFormat("DTS",          "dts",      "A_DTS"), # Can be lossy
+]
+# fmt: on
+
+
+def format_from_track(track: Track) -> AudioFormat | None:
+    for format in formats:
+        f = str(track.format)
+        if hasattr(track, "format_additionalfeatures") and track.format_additionalfeatures:
+            f = f"{f} {track.format_additionalfeatures}"
+        if "*" in format.format:
+            # matches = filter([f.lower()], format.format.lower())
+            if re.match(format.format.replace("*", ".*"), f, re.IGNORECASE):
+                return format
+        else:
+            if format.format.casefold() == f.casefold():
+                return format
+
+        if "*" in format.codecid:
+            # matches = filter([str(track.codec_id).lower()], format.codecid)
+            if re.match(format.codecid.replace("*", ".*"), str(track.codec_id), re.IGNORECASE):
+                return format
+        else:
+            if format.codecid.casefold() == str(track.codec_id).casefold():
+                return format
+    return None
+
+
+def is_fancy_codec(track: Track) -> bool:
+    """
+    Tries to check if a track is some fancy DTS (X, Headphone X) or TrueHD with Atmos
+
+    :param track:   Input track to check
+    """
+    codec_id = str(track.codec_id).casefold()
+    if codec_id == "A_TRUEHD".casefold():
+        # If it contains something other than "MLP FBA" it's probably atmos
+        return bool(re.sub("MLP FBA", "", str(track.format).strip(), re.IGNORECASE))
+    elif codec_id == "A_DTS".casefold():
+        # Not even lossless if this doesn't exist
+        if not hasattr(track, "format_additionalfeatures"):
+            return False
+        # If those additional features contain something after removing "XLL" its some fancy stuff
+        return bool(re.sub("XLL", "", str(track.format_additionalfeatures).strip(), re.IGNORECASE))
+
+    return False
+
+
+def has_libFDK() -> bool:
+    """
+    Returns if whatever installation of ffmpeg being used has been compiled with libFDK
+    """
+    exe = get_executable("ffmpeg")
+    p = subprocess.run([exe, "-encoders"], capture_output=True, text=True)
+    for line in p.stderr.splitlines():
+        if "libfdk_aac" in line.lower():
+            return True
+    return False
+
+
+def has_libFLAC() -> bool:
+    """
+    Returns if whatever installation of qaac being used has libFLAC
+    and as such can accept flac input
+    """
+    exe = get_executable("qaac")
+    p = subprocess.run([exe, "--check"], capture_output=True, text=True)
+    for line in p.stderr.splitlines():
+        if "libflac" in line.lower():
+            return True
+    return False

muxtools/audio/encoders.py

@@ -0,0 +1,329 @@
+from shlex import split as splitcommand
+from dataclasses import dataclass
+import subprocess
+import os
+
+
+from .tools import Encoder
+from ..muxing.muxfiles import AudioFile
+from .audioutils import ensure_valid_in, has_libFDK, has_libFLAC
+from ..utils.download import get_executable
+from ..utils.log import warn, crit, debug, error
+from ..utils.files import make_output, clean_temp_files
+from ..utils.env import get_temp_workdir, run_commandline
+from ..utils.types import DitherType, qAAC_MODE, PathLike
+
+__all__ = ["FLAC", "FLACCL", "FF_FLAC", "Opus", "qAAC", "FDK_AAC"]
+
+
+@dataclass
+class FLAC(Encoder):
+    """
+    Uses the reference libFLAC encoder to encode audio to flac.
+
+    :param compression_level:   Any int value from 0 to 8 (Higher = better but slower)
+    :param dither:              Dithers any input down to 16 bit 48 khz if True
+    :param dither_type:         FFMPEG dither_method used for dithering
+    :param append:              Any other args one might pass to the encoder
+    :param output:              Custom output. Can be a dir or a file.
+                                Do not specify an extension unless you know what you're doing.
+    """
+
+    compression_level: int = 8
+    dither: bool = True
+    dither_type: DitherType = DitherType.TRIANGULAR
+    append: str = ""
+    output: PathLike | None = None
+
+    def encode_audio(self, input: AudioFile, quiet: bool = True, **kwargs) -> AudioFile:
+        if not isinstance(input, AudioFile):
+            input = AudioFile.from_file(input, self)
+        flaccl = get_executable("flac")
+        output = make_output(input.file, "flac", "libflac", self.output)
+        source = ensure_valid_in(input, dither=self.dither, dither_type=self.dither_type, caller=self, supports_pipe=False)
+        debug(f"Encoding '{input.file.stem}' to FLAC using libFLAC...", self)
+
+        args = [flaccl, f"-{self.compression_level}", str(source.file.resolve()) if isinstance(source, AudioFile) else "-"]
+        args.extend(["-o", str(output)])
+        if self.append:
+            args.extend(splitcommand(self.append))
+
+        stdin = subprocess.DEVNULL if isinstance(source, AudioFile) else source.stdout
+
+        if not run_commandline(args, quiet, False, stdin):
+            debug("Done", self)
+            clean_temp_files()
+            return AudioFile(output, input.container_delay, input.source)
+        else:
+            raise crit("Encoding to FLAC using libFLAC failed!", self)
+
+
+@dataclass
+class FLACCL(Encoder):
+    """
+    Uses the CUETools FLACCL encoder to encode audio to flac.
+    This one uses OpenCL or Cuda depending on your GPU and claims to have better compression than libFLAC.
+
+    :param compression_level:   Any int value from 0 to 8 (Higher = better but slower)
+    :param dither:              Dithers any input down to 16 bit 48 khz if True
+    :param dither_type:         FFMPEG dither_method used for dithering
+    :param append:              Any other args one might pass to the encoder
+    :param output:              Custom output. Can be a dir or a file.
+                                Do not specify an extension unless you know what you're doing.
+    """
+
+    compression_level: int = 8
+    dither: bool = True
+    dither_type: DitherType = DitherType.TRIANGULAR
+    append: str = ""
+    output: PathLike | None = None
+
+    def encode_audio(self, input: AudioFile, quiet: bool = True, **kwargs) -> AudioFile:
+        if not isinstance(input, AudioFile):
+            input = AudioFile.from_file(input, self)
+        flaccl = get_executable("CUETools.FLACCL.cmd")
+        output = make_output(input.file, "flac", "flaccl", self.output)
+        source = ensure_valid_in(input, dither=self.dither, dither_type=self.dither_type, caller=self, supports_pipe=False)
+        debug(f"Encoding '{input.file.stem}' to FLAC using FLACCL...", self)
+
+        args = [flaccl, f"-{self.compression_level}", str(source.file.resolve()) if isinstance(source, AudioFile) else "-"]
+        args.extend(["-o", str(output)])
+        if self.append:
+            args.extend(splitcommand(self.append))
+
+        stdin = subprocess.DEVNULL if isinstance(source, AudioFile) else source.stdout
+
+        if not run_commandline(args, quiet, False, stdin):
+            debug("Done", self)
+            clean_temp_files()
+            return AudioFile(output, input.container_delay, input.source)
+        else:
+            raise crit("Encoding to FLAC using FLACCL failed!", self)
+
+
+@dataclass
+class FF_FLAC(Encoder):
+    """
+    Uses the ffmpeg/libav FLAC encoder to encode audio to flac.
+
+    :param compression_level:   Any int value from 0 to 12 (Higher = better but slower)
+    :param dither:              Dithers any input down to 16 bit 48 khz if True
+    :param dither_type:         FFMPEG dither_method used for dithering
+    :param append:              Any other args one might pass to the encoder
+    :param output:              Custom output. Can be a dir or a file.
+                                Do not specify an extension unless you know what you're doing.
+    """
+
+    compression_level: int = 10
+    dither: bool = True
+    dither_type: DitherType = DitherType.TRIANGULAR
+    append: str = ""
+    output: PathLike | None = None
+
+    def _base_command(self, input: AudioFile, compression: int = 0) -> list[str]:
+        # fmt: off
+        args = [get_executable("ffmpeg"), "-hide_banner", "-i", str(input.file.resolve()), "-map", "0:a:0", "-c:a", "flac", "-compression_level", str(compression)]
+        if self.dither:
+            args.extend(['-sample_fmt', 's16', '-ar', '48000', '-resampler', 'soxr', '-precision', '24', '-dither_method', self.dither_type.name.lower()])
+        if self.append:
+            args.extend(splitcommand(self.append))
+        return args
+        # fmt: on
+
+    def encode_audio(self, input: AudioFile, quiet: bool = True, **kwargs) -> AudioFile:
+        if not isinstance(input, AudioFile):
+            input = AudioFile.from_file(input, self)
+        output = make_output(input.file, "flac", "ffmpeg", self.output)
+        if "temp" in kwargs.keys():
+            debug(f"Preparing audio for input to other encoder using ffmpeg...", self)
+        else:
+            debug(f"Encoding '{input.file.stem}' to FLAC using ffmpeg...", self)
+        args = self._base_command(input, self.compression_level)
+        args.append(str(output.resolve()))
+
+        if not run_commandline(args, quiet):
+            debug("Done", self)
+            return AudioFile(output, input.container_delay, input.source)
+        else:
+            raise crit("Encoding to flac using ffmpeg failed!", self)
+
+    def get_pipe(self, input: AudioFile) -> subprocess.Popen:
+        debug(f"Piping audio for input to other encoder using ffmpeg...", self)
+        args = self._base_command(input, 0)
+        args.extend(["-f", "flac", "-"])
+        p = subprocess.Popen(args, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=False)
+        return p
+
+
+@dataclass
+class Opus(Encoder):
+    """
+    Uses opusenc to encode audio to opus.
+
+    :param bitrate:             Any int value representing kbps from 1 to 512
+                                Automatically chooses 192 and 320 for stereo and surround respectively if None
+
+    :param vbr:                 Uses VBR encoding if True
+    :param dither:              Dithers any input down to 16 bit 48 khz if True, lets the encoder handle it if False
+    :param dither_type:         FFMPEG dither_method used for dithering
+    :param append:              Any other args one might pass to the encoder
+    :param output:              Custom output. Can be a dir or a file.
+                                Do not specify an extension unless you know what you're doing.
+    """
+
+    bitrate: int | None = None
+    vbr: bool = True
+    dither: bool = False
+    dither_type: DitherType = DitherType.TRIANGULAR
+    append: str = ""
+    output: PathLike | None = None
+
+    def encode_audio(self, input: AudioFile | PathLike, quiet: bool = True, **kwargs) -> AudioFile:
+        if not isinstance(input, AudioFile):
+            input = AudioFile.from_file(input, self)
+
+        exe = get_executable("opusenc")
+        if not self.bitrate:
+            info = input.get_mediainfo()
+            match (info.channel_s):
+                case _ if info.channel_s == 2:
+                    self.bitrate = 192
+                case _ if info.channel_s > 6:
+                    self.bitrate = 420
+                case _:
+                    self.bitrate = 320
+            debug(f"Encoding '{input.file.stem}' to Opus ({self.bitrate} kbps) using opusenc...", self)
+        else:
+            debug(f"Encoding '{input.file.stem}' to Opus using opusenc...", self)
+
+        output = make_output(input.file, "opus", "opusenc", self.output)
+        source = ensure_valid_in(input, dither=self.dither, dither_type=self.dither_type, caller=self, supports_pipe=True)
+
+        args = [exe, "--vbr" if self.vbr else "--cvbr", "--bitrate", str(self.bitrate)]
+        if self.append:
+            args.extend(splitcommand(self.append))
+        args.append(str(source.file.resolve()) if isinstance(source, AudioFile) else "-")
+        args.append(str(output))
+
+        stdin = subprocess.DEVNULL if isinstance(source, AudioFile) else source.stdout
+
+        if not run_commandline(args, quiet, False, stdin):
+            debug("Done", self)
+            clean_temp_files()
+            return AudioFile(output, input.container_delay, input.source)
+        else:
+            raise crit("Encoding to opus using opusenc failed!", self)
+
+
+@dataclass
+class qAAC(Encoder):
+    """
+    Uses qAAC to encode audio to AAC.
+
+    :param q:                   Quality value ranging from 0 to 127 if using TVBR, otherwise bitrate in kbps
+    :param mode:                Encoding mode, Defaults to TVBR
+    :param dither:              Dithers any input down to 16 bit 48 khz if True, lets the encoder handle it if False
+    :param dither_type:         FFMPEG dither_method used for dithering
+    :param append:              Any other args one might pass to the encoder
+                                Adds " --no-delay --no-optimize" by default to prevent desync with video
+    :param output:              Custom output. Can be a dir or a file.
+                                Do not specify an extension unless you know what you're doing.
+    """
+
+    q: int = 127
+    mode: qAAC_MODE | int = qAAC_MODE.TVBR
+    dither: bool = False
+    dither_type: DitherType = DitherType.TRIANGULAR
+    append: str = ""
+    output: PathLike | None = None
+
+    def encode_audio(self, input: AudioFile, quiet: bool = True, **kwargs) -> AudioFile:
+        if not isinstance(input, AudioFile):
+            input = AudioFile.from_file(input, self)
+        output = make_output(input.file, "aac", "qaac", self.output)
+        source = ensure_valid_in(input, dither=self.dither, dither_type=self.dither_type, caller=self, supports_pipe=False)
+        qaac = get_executable("qaac")
+
+        if not has_libFLAC():
+            raise error(
+                "Your installation of qaac does not have libFLAC.\nIt is needed for proper piping from ffmpeg etc."
+                + "\nYou can download it from https://github.com/xiph/flac/releases"
+                + "\nFor installation check https://github.com/nu774/qaac/wiki/Installation",
+                self,
+            )
+
+        debug(f"Encoding '{input.file.stem}' to AAC using qAAC...", self)
+        args = [qaac, "--no-delay", "--no-optimize", "--threading", f"--{self.mode.name.lower()}", str(self.q)]
+        if self.append:
+            args.extend(splitcommand(self.append))
+        args.extend(["-o", str(output), str(source.file.resolve()) if isinstance(source, AudioFile) else "-"])
+
+        stdin = subprocess.DEVNULL if isinstance(source, AudioFile) else source.stdout
+
+        if not run_commandline(args, quiet, False, stdin):
+            debug("Done", self)
+            clean_temp_files()
+            return AudioFile(output, input.container_delay, input.source)
+        else:
+            raise crit("Encoding to AAC using qAAC failed!", self)
+
+
+@dataclass
+class FDK_AAC(Encoder):
+    """
+    Uses the libFDK implementation in ffmpeg to encode audio to AAC.
+    It's strongly recommended to use qAAC if you're on windows because its straight up the best AAC encoder.
+
+    :param bitrate_mode:        Any int value from 0 - 5
+                                0 will be CBR and using the bitrate below, 1 - 5 are true VBR modes
+                                See https://wiki.hydrogenaud.io/index.php?title=Fraunhofer_FDK_AAC#Bitrate_Modes
+
+    :param bitrate:             Any int value representing kbps
+    :param dither:              Dithers any input down to 16 bit 48 khz if True, lets the encoder handle it if False
+    :param dither_type:         FFMPEG dither_method used for dithering
+    :param append:              Any other args one might pass to the encoder
+    :param output:              Custom output. Can be a dir or a file.
+                                Do not specify an extension unless you know what you're doing.
+    """
+
+    bitrate_mode: int = 5
+    bitrate: int = 256
+    dither: bool = False
+    dither_type: DitherType = DitherType.TRIANGULAR
+    append: str = ""
+    output: PathLike | None = None
+
+    def encode_audio(self, input: AudioFile, quiet: bool = True, **kwargs) -> AudioFile:
+        if not isinstance(input, AudioFile):
+            input = AudioFile.from_file(input, self)
+        output = make_output(input.file, "m4a", "fdkaac", self.output)
+        if not has_libFDK():
+            raise error(
+                "Your installation of ffmpeg wasn't compiled with libFDK."
+                + "\nYou can download builds with the non-free flag from https://github.com/AnimMouse/ffmpeg-autobuild/releases",
+                self,
+            )
+        if os.name == "nt":
+            warn("It is strongly recommended to use qAAC on windows. See docs.", self, 5)
+        debug(f"Encoding '{input.file.stem}' to AAC using libFDK...", self)
+        # fmt: off
+        args = [get_executable("ffmpeg"), "-hide_banner", "-i", str(input.file.resolve()), "-map", "0:a:0", "-c:a", "libfdk_aac"]
+        if self.bitrate_mode > 0:
+            args.extend(['-vbr', str(self.bitrate_mode)])
+        else:
+            args.extend(['-b:a', f'{self.bitrate}k'])
+        if self.dither:
+            args.extend(['-sample_fmt', 's16', '-ar', '48000', '-resampler', 'soxr', '-precision', '24', '-dither_method', self.dither_type.name.lower()])
+        if self.append:
+            args.extend(splitcommand(self.append))
+        args.append(str(output))
+        # fmt: on
+        if not run_commandline(args, quiet, False):
+            debug("Done", self)
+            clean_temp_files()
+            return AudioFile(output, input.container_delay, input.source)
+        else:
+            raise crit("Encoding to AAC using libFDK failed!", self)
+
+
+# TODO: Implement the dolby shit