StreamingCommunity 1.7.6__py3-none-any.whl

StreamingCommunity/Src/Lib/FFmpeg/command.py

@@ -0,0 +1,292 @@
+# 31.01.24
+
+import sys
+import time
+import logging
+import subprocess
+from typing import List, Dict
+
+
+# Internal utilities
+from StreamingCommunity.Src.Util._jsonConfig import config_manager
+from StreamingCommunity.Src.Util.os import os_manager, suppress_output
+from StreamingCommunity.Src.Util.console import console
+from .util import need_to_force_to_ts, check_duration_v_a
+from .capture import capture_ffmpeg_real_time
+from ..M3U8 import M3U8_Codec
+
+
+# Config
+DEBUG_MODE = config_manager.get_bool("DEFAULT", "debug")
+DEBUG_FFMPEG = "debug" if DEBUG_MODE else "error"
+USE_CODEC = config_manager.get_bool("M3U8_CONVERSION", "use_codec")
+USE_VCODEC = config_manager.get_bool("M3U8_CONVERSION", "use_vcodec")
+USE_ACODEC = config_manager.get_bool("M3U8_CONVERSION", "use_acodec")
+USE_BITRATE = config_manager.get_bool("M3U8_CONVERSION", "use_bitrate")
+USE_GPU = config_manager.get_bool("M3U8_CONVERSION", "use_gpu")
+FFMPEG_DEFAULT_PRESET = config_manager.get("M3U8_CONVERSION", "default_preset")
+
+
+# Variable
+TQDM_USE_LARGE_BAR = config_manager.get_int('M3U8_DOWNLOAD', 'tqdm_use_large_bar')
+
+
+def join_video(video_path: str, out_path: str, codec: M3U8_Codec = None):
+    
+    """
+    Joins single ts video file to mp4
+    
+    Parameters:
+        - video_path (str): The path to the video file.
+        - out_path (str): The path to save the output file.
+        - vcodec (str): The video codec to use. Defaults to 'copy'.
+        - acodec (str): The audio codec to use. Defaults to 'aac'.
+        - bitrate (str): The bitrate for the audio stream. Defaults to '192k'.
+        - force_ts (bool): Force video path to be mpegts as input.
+    """
+
+    if not os_manager.check_file(video_path):
+        logging.error("Missing input video for ffmpeg conversion.")
+        sys.exit(0)
+
+    # Start command
+    ffmpeg_cmd = ['ffmpeg']
+
+    # Enabled the use of gpu
+    if USE_GPU:
+        ffmpeg_cmd.extend(['-hwaccel', 'cuda'])
+
+    # Add mpegts to force to detect input file as ts file
+    if need_to_force_to_ts(video_path):
+        console.log("[red]Force input file to 'mpegts'.")
+        ffmpeg_cmd.extend(['-f', 'mpegts'])
+        vcodec = "libx264"
+
+    # Insert input video path
+    ffmpeg_cmd.extend(['-i', video_path])
+
+    # Add output Parameters
+    if USE_CODEC and codec != None:
+        if USE_VCODEC:
+            if codec.video_codec_name: 
+                if not USE_GPU: 
+                    ffmpeg_cmd.extend(['-c:v', codec.video_codec_name])
+                else: 
+                    ffmpeg_cmd.extend(['-c:v', 'h264_nvenc'])
+            else: 
+                console.log("[red]Cant find vcodec for 'join_audios'")
+        else:
+            if USE_GPU:
+                ffmpeg_cmd.extend(['-c:v', 'h264_nvenc'])
+
+
+        if USE_ACODEC:
+            if codec.audio_codec_name: 
+                ffmpeg_cmd.extend(['-c:a', codec.audio_codec_name])
+            else: 
+                console.log("[red]Cant find acodec for 'join_audios'")
+
+        if USE_BITRATE:
+            ffmpeg_cmd.extend(['-b:v',  f'{codec.video_bitrate // 1000}k'])
+            ffmpeg_cmd.extend(['-b:a',  f'{codec.audio_bitrate // 1000}k'])
+
+    else:
+        ffmpeg_cmd.extend(['-c', 'copy'])
+
+    # Ultrafast preset always or fast for gpu
+    if not USE_GPU:
+        ffmpeg_cmd.extend(['-preset', FFMPEG_DEFAULT_PRESET])
+    else:
+        ffmpeg_cmd.extend(['-preset', 'fast'])
+
+    # Overwrite
+    ffmpeg_cmd += [out_path, "-y"]
+
+    # Run join
+    if DEBUG_MODE:
+        subprocess.run(ffmpeg_cmd, check=True)
+    else:
+
+        if TQDM_USE_LARGE_BAR:
+            capture_ffmpeg_real_time(ffmpeg_cmd, "[cyan]Join video")
+            print()
+
+        else:
+            console.log(f"[purple]FFmpeg [white][[cyan]Join video[white]] ...")
+            with suppress_output():
+                capture_ffmpeg_real_time(ffmpeg_cmd, "[cyan]Join video")
+                print()
+
+    time.sleep(0.5)
+    if not os_manager.check_file(out_path):
+        logging.error("Missing output video for ffmpeg conversion video.")
+        sys.exit(0)
+
+
+def join_audios(video_path: str, audio_tracks: List[Dict[str, str]], out_path: str, codec: M3U8_Codec = None):
+    """
+    Joins audio tracks with a video file using FFmpeg.
+    
+    Parameters:
+        - video_path (str): The path to the video file.
+        - audio_tracks (list[dict[str, str]]): A list of dictionaries containing information about audio tracks.
+            Each dictionary should contain the 'path' key with the path to the audio file.
+        - out_path (str): The path to save the output file.
+    """
+
+    if not os_manager.check_file(video_path):
+        logging.error("Missing input video for ffmpeg conversion.")
+        sys.exit(0)
+
+    video_audio_same_duration = check_duration_v_a(video_path, audio_tracks[0].get('path'))
+
+    # Start command
+    ffmpeg_cmd = ['ffmpeg']
+
+    # Enabled the use of gpu
+    if USE_GPU:
+        ffmpeg_cmd.extend(['-hwaccel', 'cuda'])
+
+    # Insert input video path
+    ffmpeg_cmd.extend(['-i', video_path])
+
+    # Add audio tracks as input
+    for i, audio_track in enumerate(audio_tracks):
+        if os_manager.check_file(audio_track.get('path')):
+            ffmpeg_cmd.extend(['-i', audio_track.get('path')])
+        else:
+            logging.error(f"Skip audio join: {audio_track.get('path')} dont exist")
+
+    # Map the video and audio streams
+    ffmpeg_cmd.append('-map')
+    ffmpeg_cmd.append('0:v')            # Map video stream from the first input (video_path)
+    
+    for i in range(1, len(audio_tracks) + 1):
+        ffmpeg_cmd.append('-map')
+        ffmpeg_cmd.append(f'{i}:a')     # Map audio streams from subsequent inputs
+
+    # Add output Parameters
+    if USE_CODEC:
+        if USE_VCODEC:
+            if codec.video_codec_name: 
+                if not USE_GPU: 
+                    ffmpeg_cmd.extend(['-c:v', codec.video_codec_name])
+                else: 
+                    ffmpeg_cmd.extend(['-c:v', 'h264_nvenc'])
+            else: 
+                console.log("[red]Cant find vcodec for 'join_audios'")
+        else:
+            if USE_GPU:
+                ffmpeg_cmd.extend(['-c:v', 'h264_nvenc'])
+
+        if USE_ACODEC:
+            if codec.audio_codec_name: 
+                ffmpeg_cmd.extend(['-c:a', codec.audio_codec_name])
+            else: 
+                console.log("[red]Cant find acodec for 'join_audios'")
+
+        if USE_BITRATE:
+            ffmpeg_cmd.extend(['-b:v',  f'{codec.video_bitrate // 1000}k'])
+            ffmpeg_cmd.extend(['-b:a',  f'{codec.audio_bitrate // 1000}k'])
+
+    else:
+        ffmpeg_cmd.extend(['-c', 'copy'])
+
+    # Ultrafast preset always or fast for gpu
+    if not USE_GPU:
+        ffmpeg_cmd.extend(['-preset', FFMPEG_DEFAULT_PRESET])
+    else:
+        ffmpeg_cmd.extend(['-preset', 'fast'])
+
+    # Use shortest input path for video and audios
+    if not video_audio_same_duration:
+        logging.info("[red]Use shortest input.")
+        ffmpeg_cmd.extend(['-shortest', '-strict', 'experimental'])
+
+    # Overwrite
+    ffmpeg_cmd += [out_path, "-y"]
+
+    # Run join
+    if DEBUG_MODE:
+        subprocess.run(ffmpeg_cmd, check=True)
+    else:
+
+        if TQDM_USE_LARGE_BAR:
+            capture_ffmpeg_real_time(ffmpeg_cmd, "[cyan]Join audio")
+            print()
+
+        else:
+            console.log(f"[purple]FFmpeg [white][[cyan]Join audio[white]] ...")
+            with suppress_output():
+                capture_ffmpeg_real_time(ffmpeg_cmd, "[cyan]Join audio")
+                print()
+
+    time.sleep(0.5)
+    if not os_manager.check_file(out_path):
+        logging.error("Missing output video for ffmpeg conversion audio.")
+        sys.exit(0)
+
+
+def join_subtitle(video_path: str, subtitles_list: List[Dict[str, str]], out_path: str):
+    """
+    Joins subtitles with a video file using FFmpeg.
+    
+    Parameters:
+        - video (str): The path to the video file.
+        - subtitles_list (list[dict[str, str]]): A list of dictionaries containing information about subtitles.
+            Each dictionary should contain the 'path' key with the path to the subtitle file and the 'name' key with the name of the subtitle.
+        - out_path (str): The path to save the output file.
+    """
+
+    if not os_manager.check_file(video_path):
+        logging.error("Missing input video for ffmpeg conversion.")
+        sys.exit(0)
+
+    # Start command
+    ffmpeg_cmd = ["ffmpeg", "-i", video_path]
+
+    # Add subtitle input files first
+    for subtitle in subtitles_list:
+        if os_manager.check_file(subtitle.get('path')):
+            ffmpeg_cmd += ["-i", subtitle['path']]
+        else:
+            logging.error(f"Skip subtitle join: {subtitle.get('path')} doesn't exist")
+
+    # Add maps for video and audio streams
+    ffmpeg_cmd += ["-map", "0:v", "-map", "0:a"]
+
+    # Add subtitle maps and metadata
+    for idx, subtitle in enumerate(subtitles_list):
+        ffmpeg_cmd += ["-map", f"{idx + 1}:s"]
+        ffmpeg_cmd += ["-metadata:s:s:{}".format(idx), "title={}".format(subtitle['language'])]
+
+    # Add output Parameters
+    if USE_CODEC:
+        ffmpeg_cmd.extend(['-c:v', 'copy', '-c:a', 'copy', '-c:s', 'mov_text'])
+    else:
+        ffmpeg_cmd.extend(['-c', 'copy', '-c:s', 'mov_text'])
+
+    # Overwrite
+    ffmpeg_cmd += [out_path, "-y"]
+    logging.info(f"FFmpeg command: {ffmpeg_cmd}")
+
+
+    # Run join
+    if DEBUG_MODE:
+        subprocess.run(ffmpeg_cmd, check=True)
+    else:
+
+        if TQDM_USE_LARGE_BAR:
+            capture_ffmpeg_real_time(ffmpeg_cmd, "[cyan]Join subtitle")
+            print()
+
+        else:
+            console.log(f"[purple]FFmpeg [white][[cyan]Join subtitle[white]] ...")
+            with suppress_output():
+                capture_ffmpeg_real_time(ffmpeg_cmd, "[cyan]Join subtitle")
+                print()
+
+    time.sleep(0.5)
+    if not os_manager.check_file(out_path):
+        logging.error("Missing output video for ffmpeg conversion subtitle.")
+        sys.exit(0)

StreamingCommunity/Src/Lib/FFmpeg/util.py

@@ -0,0 +1,242 @@
+# 16.04.24
+
+import os
+import sys
+import json
+import subprocess
+import logging
+from typing import Tuple
+
+
+# Internal utilities
+from StreamingCommunity.Src.Util.console import console
+
+
+def has_audio_stream(video_path: str) -> bool:
+    """
+    Check if the input video has an audio stream.
+
+    Parameters:
+        - video_path (str): Path to the input video file.
+
+    Returns:
+        has_audio (bool): True if the input video has an audio stream, False otherwise.
+    """
+    try:
+        ffprobe_cmd = ['ffprobe', '-v', 'error', '-print_format', 'json', '-select_streams', 'a', '-show_streams', video_path]
+        logging.info(f"FFmpeg command: {ffprobe_cmd}")
+
+        with subprocess.Popen(ffprobe_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) as proc:
+            stdout, stderr = proc.communicate()
+            if stderr:
+                logging.error(f"Error: {stderr}")
+            else:
+                probe_result = json.loads(stdout)
+                return bool(probe_result.get('streams', []))
+            
+    except Exception as e:
+        logging.error(f"Error: {e}")
+        return False
+
+
+def get_video_duration(file_path: str) -> float:
+    """
+    Get the duration of a video file.
+
+    Parameters:
+        - file_path (str): The path to the video file.
+
+    Returns:
+        (float): The duration of the video in seconds if successful, 
+        None if there's an error.
+    """
+
+    try:
+        ffprobe_cmd = ['ffprobe', '-v', 'error', '-show_format', '-print_format', 'json', file_path]
+        logging.info(f"FFmpeg command: {ffprobe_cmd}")
+
+        # Use a with statement to ensure the subprocess is cleaned up properly
+        with subprocess.Popen(ffprobe_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) as proc:
+            stdout, stderr = proc.communicate()
+            
+            if proc.returncode != 0:
+                logging.error(f"Error: {stderr}")
+                return None
+            
+            # Parse JSON output
+            probe_result = json.loads(stdout)
+
+            # Extract duration from the video information
+            try:
+                return float(probe_result['format']['duration'])
+            except:
+                logging.error("Cant get duration.")
+                return 1
+
+    except Exception as e:
+        logging.error(f"Error get video duration: {e}")
+        sys.exit(0)
+
+def get_video_duration_s(filename):
+    """
+    Get the duration of a video file using ffprobe.
+
+    Parameters:
+    - filename (str): Path to the video file (e.g., 'sim.mp4')
+
+    Returns:
+    - duration (float): Duration of the video in seconds, or None if an error occurs.
+    """
+    ffprobe_cmd = ['ffprobe', '-v', 'error', '-show_entries', 'format=duration', '-of', 'default=noprint_wrappers=1:nokey=1', filename]
+
+    try:
+        
+        # Run ffprobe command and capture output
+        result = subprocess.run(ffprobe_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True, text=True)
+        
+        # Extract duration from the output
+        duration_str = result.stdout.strip()
+        duration = float(duration_str)  # Convert duration to float
+        
+        return int(duration)
+    
+    except subprocess.CalledProcessError as e:
+        print(f"Error running ffprobe: {e}")
+        return None
+    except ValueError as e:
+        print(f"Error converting duration to float: {e}")
+        return None
+
+
+def format_duration(seconds: float) -> Tuple[int, int, int]:
+    """
+    Format duration in seconds into hours, minutes, and seconds.
+
+    Parameters:
+        - seconds (float): Duration in seconds.
+
+    Returns:
+        list[int, int, int]: List containing hours, minutes, and seconds.
+    """
+
+    hours, remainder = divmod(seconds, 3600)
+    minutes, seconds = divmod(remainder, 60)
+
+    return int(hours), int(minutes), int(seconds)
+
+
+def print_duration_table(file_path: str, description: str = "Duration", return_string: bool = False):
+    """
+    Print the duration of a video file in hours, minutes, and seconds, or return it as a formatted string.
+
+    Parameters:
+        - file_path (str): The path to the video file.
+        - description (str): Optional description to be included in the output. Defaults to "Duration". If not provided, the duration will not be printed.
+        - return_string (bool): If True, returns the formatted duration string. If False, returns a dictionary with hours, minutes, and seconds.
+
+    Returns:
+        - str: The formatted duration string if return_string is True.
+        - dict: A dictionary with keys 'h', 'm', 's' representing hours, minutes, and seconds if return_string is False.
+    """
+
+    video_duration = get_video_duration(file_path)
+
+    if video_duration is not None:
+        hours, minutes, seconds = format_duration(video_duration)
+        formatted_duration = f"[yellow]{int(hours)}[red]h [yellow]{int(minutes)}[red]m [yellow]{int(seconds)}[red]s"
+        duration_dict = {'h': hours, 'm': minutes, 's': seconds}
+
+        if description:
+            console.print(f"[cyan]{description} for [white]([green]{os.path.basename(file_path)}[white]): {formatted_duration}")
+        else:
+            if return_string:
+                return formatted_duration
+            else:
+                return duration_dict
+
+
+def get_ffprobe_info(file_path):
+    """
+    Get format and codec information for a media file using ffprobe.
+
+    Parameters:
+        file_path (str): Path to the media file.
+
+    Returns:
+        dict: A dictionary containing the format name and a list of codec names.
+    """
+    try:
+        result = subprocess.run(
+            ['ffprobe', '-v', 'error', '-show_format', '-show_streams', '-print_format', 'json', file_path],
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=True
+        )
+        output = result.stdout
+        info = json.loads(output)
+        
+        format_name = info['format']['format_name'] if 'format' in info else None
+        codec_names = [stream['codec_name'] for stream in info['streams']] if 'streams' in info else []
+        
+        return {
+            'format_name': format_name,
+            'codec_names': codec_names
+        }
+    
+    except subprocess.CalledProcessError as e:
+        logging.error(f"ffprobe failed for file {file_path}: {e}")
+        return None
+    
+    except json.JSONDecodeError as e:
+        logging.error(f"Failed to parse JSON output from ffprobe for file {file_path}: {e}")
+        return None
+
+
+def is_png_format_or_codec(file_info):
+    """
+    Check if the format is 'png_pipe' or if any codec is 'png'.
+
+    Parameters:
+        file_info (dict): The dictionary containing file information.
+
+    Returns:
+        bool: True if the format is 'png_pipe' or any codec is 'png', otherwise False.
+    """
+    if not file_info:
+        return False
+    return file_info['format_name'] == 'png_pipe' or 'png' in file_info['codec_names']
+
+
+def need_to_force_to_ts(file_path):
+    """
+    Get if a file to TS format if it is in PNG format or contains a PNG codec.
+
+    Parameters:
+        file_path (str): Path to the input media file.
+    """
+    logging.info(f"Processing file: {file_path}")
+    file_info = get_ffprobe_info(file_path)
+
+    if is_png_format_or_codec(file_info):
+       return True
+    return False
+
+
+def check_duration_v_a(video_path, audio_path):
+    """
+    Check if the duration of the video and audio matches.
+
+    Parameters:
+    - video_path (str): Path to the video file.
+    - audio_path (str): Path to the audio file.
+
+    Returns:
+    - bool: True if the duration of the video and audio matches, False otherwise.
+    """
+    
+    # Ottieni la durata del video
+    video_duration = get_video_duration(video_path)
+    
+    # Ottieni la durata dell'audio
+    audio_duration = get_video_duration(audio_path)
+
+    # Verifica se le durate corrispondono
+    return video_duration == audio_duration

StreamingCommunity/Src/Lib/M3U8/__init__.py

@@ -0,0 +1,6 @@
+# 02.04.24
+
+from .decryptor import M3U8_Decryption
+from .estimator import M3U8_Ts_Estimator
+from .parser import M3U8_Parser, M3U8_Codec
+from .url_fixer import M3U8_UrlFix

StreamingCommunity/Src/Lib/M3U8/decryptor.py

@@ -0,0 +1,129 @@
+# 03.04.24
+
+import sys
+import logging
+import subprocess
+import importlib.util
+
+
+# Internal utilities
+from StreamingCommunity.Src.Util.console import console
+
+
+# Check if Crypto module is installed
+crypto_spec = importlib.util.find_spec("Crypto")
+crypto_installed = crypto_spec is not None
+
+
+if crypto_installed:
+    logging.info("Decrypy use: Crypto")
+    from Crypto.Cipher import AES # type: ignore
+    from Crypto.Util.Padding import unpad # type: ignore
+
+    class M3U8_Decryption:
+        """
+        Class for decrypting M3U8 playlist content using AES encryption when the Crypto module is available.
+        """
+        def __init__(self, key: bytes, iv: bytes, method: str) -> None:
+            """
+            Initialize the M3U8_Decryption object.
+
+            Parameters:
+                - key (bytes): The encryption key.
+                - iv (bytes): The initialization vector (IV).
+                - method (str): The encryption method.
+            """
+            self.key = key
+            if "0x" in str(iv):
+                self.iv = bytes.fromhex(iv.replace("0x", ""))
+            else:
+                self.iv = iv
+            self.method = method
+            logging.info(f"Decrypt add: ('key': {self.key}, 'iv': {self.iv}, 'method': {self.method})")
+
+        def decrypt(self, ciphertext: bytes) -> bytes:
+            """
+            Decrypt the ciphertext using the specified encryption method.
+
+            Parameters:
+                - ciphertext (bytes): The encrypted content to decrypt.
+
+            Returns:
+                bytes: The decrypted content.
+            """
+            if self.method == "AES":
+                cipher = AES.new(self.key, AES.MODE_ECB)
+                decrypted_data = cipher.decrypt(ciphertext)
+                return unpad(decrypted_data, AES.block_size)
+
+            elif self.method == "AES-128":
+                cipher = AES.new(self.key[:16], AES.MODE_CBC, iv=self.iv)
+                decrypted_data = cipher.decrypt(ciphertext)
+                return unpad(decrypted_data, AES.block_size)
+
+            elif self.method == "AES-128-CTR":
+                cipher = AES.new(self.key[:16], AES.MODE_CTR, nonce=self.iv)
+                return cipher.decrypt(ciphertext)
+
+            else:
+                raise ValueError("Invalid or unsupported method")
+
+else:
+
+    # Check if openssl command is available
+    try:
+        openssl_available = subprocess.run(["openssl", "version"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL).returncode == 0
+        logging.info("Decrypy use: OPENSSL")
+    except:
+        openssl_available = False
+
+    if not openssl_available:
+        console.log("[red]Neither python library: pycryptodome nor openssl software is installed. Please install either one of them. Read readme.md [Requirement].")
+        sys.exit(0)
+
+    class M3U8_Decryption:
+        """
+        Class for decrypting M3U8 playlist content using OpenSSL when the Crypto module is not available.
+        """
+        def __init__(self, key: bytes, iv: bytes, method: str) -> None:
+            """
+            Initialize the M3U8_Decryption object.
+
+            Parameters:
+                - key (bytes): The encryption key.
+                - iv (bytes): The initialization vector (IV).
+                - method (str): The encryption method.
+            """
+            self.key = key
+            if "0x" in str(iv):
+                self.iv = bytes.fromhex(iv.replace("0x", ""))
+            else:
+                self.iv = iv
+            self.method = method
+            logging.info(f"Decrypt add: ('key': {self.key}, 'iv': {self.iv}, 'method': {self.method})")
+
+        def decrypt(self, ciphertext: bytes) -> bytes:
+            """
+            Decrypt the ciphertext using the specified encryption method.
+
+            Parameters:
+                - ciphertext (bytes): The encrypted content to decrypt.
+
+            Returns:
+                bytes: The decrypted content.
+            """
+            if self.method == "AES":
+                openssl_cmd = f'openssl enc -d -aes-256-ecb -K {self.key.hex()} -nosalt'
+            elif self.method == "AES-128":
+                openssl_cmd = f'openssl enc -d -aes-128-cbc -K {self.key[:16].hex()} -iv {self.iv.hex()}'
+            elif self.method == "AES-128-CTR":
+                openssl_cmd = f'openssl enc -d -aes-128-ctr -K {self.key[:16].hex()} -iv {self.iv.hex()}'
+            else:
+                raise ValueError("Invalid or unsupported method")
+
+            try:
+                decrypted_data = subprocess.check_output(openssl_cmd.split(), input=ciphertext, stderr=subprocess.STDOUT)
+            except subprocess.CalledProcessError as e:
+                raise ValueError(f"Decryption failed: {e.output.decode()}")
+
+            return decrypted_data