HwCodecDetect 0.0.1__py3-none-any.whl

HwCodecDetect/__init__.py

@@ -0,0 +1,6 @@
+# HwCodecDetect/__init__.py
+
+from .install_ffmpeg_if_needed import install_ffmpeg_if_needed
+
+__version__ = "0.0.1"
+__author__ = "whyb"

HwCodecDetect/install_ffmpeg_if_needed.py

@@ -0,0 +1,189 @@
+import os
+import sys
+import platform
+import subprocess
+import shutil
+import urllib.request
+import zipfile
+import tempfile
+
+def install_ffmpeg_if_needed():
+    """
+    Checks for FFmpeg and installs it if not found.
+    """
+    print("Checking for FFmpeg...")
+
+    # Step 1: Check if FFmpeg is already in PATH
+    if shutil.which("ffmpeg"):
+        print("FFmpeg is already installed and in PATH.")
+        return 0
+
+    # Step 2: Install based on OS
+    os_name = platform.system()
+
+    if os_name == "Windows":
+        return install_on_windows()
+    elif os_name == "Linux":
+        return install_on_linux()
+    elif os_name == "Darwin":  # 'Darwin' is the system name for macOS
+        return install_on_macos()
+    else:
+        print(f"Unsupported OS: {os_name}", file=sys.stderr)
+        return -1
+
+def install_on_windows():
+    """
+    Tries to install FFmpeg on Windows using a cascade of package managers,
+    falling back to a manual download if all else fails.
+    """
+    print("FFmpeg not found. Attempting to install for Windows...")
+
+    # Method 1: Try Winget (Windows Package Manager)
+    if shutil.which("winget"):
+        print("Trying to install FFmpeg using Winget...")
+        try:
+            # Use the official ID for FFmpeg from Winget
+            subprocess.run(["winget", "install", "--id", "Gyan.FFmpeg", "-e", "--accept-package-agreements", "--accept-source-agreements"], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            print("FFmpeg installation complete via Winget.")
+            return 0
+        except subprocess.CalledProcessError:
+            print("Winget installation failed. Trying next method.", file=sys.stderr)
+            pass
+    
+    # Method 2: Try Chocolatey
+    if shutil.which("choco"):
+        print("Trying to install FFmpeg using Chocolatey...")
+        try:
+            subprocess.run(["choco", "install", "ffmpeg", "-y"], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            print("FFmpeg installation complete via Chocolatey.")
+            return 0
+        except subprocess.CalledProcessError:
+            print("Chocolatey installation failed. Trying next method.", file=sys.stderr)
+            pass
+
+    # Method 3: Try Scoop
+    if shutil.which("scoop"):
+        print("Trying to install FFmpeg using Scoop...")
+        try:
+            subprocess.run(["scoop", "install", "ffmpeg"], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            print("FFmpeg installation complete via Scoop.")
+            return 0
+        except subprocess.CalledProcessError:
+            print("Scoop installation failed. Trying next method.", file=sys.stderr)
+            pass
+
+    # Method 4: Manual Download (Fallback)
+    print("All package manager installations failed. Falling back to manual download.")
+    ffmpeg_url = "https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-master-latest-win64-gpl-shared.zip"
+    
+    try:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            zip_file_path = os.path.join(temp_dir, "ffmpeg_temp.zip")
+            
+            urllib.request.urlretrieve(ffmpeg_url, zip_file_path)
+            print("Download complete. Extracting...")
+            
+            with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:
+                zip_ref.extractall(temp_dir)
+            
+            bin_source_path = os.path.join(temp_dir, "ffmpeg-master-latest-win64-gpl-shared", "bin")
+            
+            try:
+                for item in os.listdir(bin_source_path):
+                    shutil.move(os.path.join(bin_source_path, item), os.getcwd())
+                print("FFmpeg files moved to the current directory.")
+            except Exception as e:
+                print(f"Error moving files to the current directory: {e}", file=sys.stderr)
+                print("Adding FFmpeg's bin directory to PATH instead.")
+                os.environ["PATH"] += os.pathsep + bin_source_path
+                print(f"Added {bin_source_path} to PATH.")
+            
+            return 0
+
+    except Exception as e:
+        print(f"An unexpected error occurred during manual installation: {e}", file=sys.stderr)
+        return -1
+
+def install_on_linux():
+    """
+    Installs FFmpeg using package managers for various Linux distributions.
+    """
+    print("FFmpeg not found. Attempting to install via package manager...")
+    
+    distro = get_linux_distro()
+    
+    if "arch" in distro:
+        command = ["sudo", "pacman", "-S", "--noconfirm", "ffmpeg"]
+        package_manager_name = "pacman"
+    elif "ubuntu" in distro or "debian" in distro:
+        command = ["sudo", "apt-get", "install", "-y", "ffmpeg"]
+        package_manager_name = "apt-get"
+    elif "centos" in distro or "redhat" in distro or "fedora" in distro:
+        command = ["sudo", "yum", "install", "-y", "ffmpeg"]
+        package_manager_name = "yum"
+    else:
+        print("Unsupported Linux distribution. Please install FFmpeg manually.", file=sys.stderr)
+        return -1
+    
+    try:
+        print(f"Attempting to install FFmpeg using {package_manager_name}...")
+        subprocess.run(command, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        print("FFmpeg installation complete.")
+        return 0
+    except subprocess.CalledProcessError as e:
+        print(f"Error installing FFmpeg with {package_manager_name}: {e}", file=sys.stderr)
+        return -1
+    except FileNotFoundError:
+        print(f"Package manager '{package_manager_name}' not found. Please install FFmpeg manually.", file=sys.stderr)
+        return -1
+
+def install_on_macos():
+    """
+    Installs FFmpeg using Homebrew for macOS.
+    """
+    print("FFmpeg not found. Attempting to install via Homebrew...")
+
+    if not shutil.which("brew"):
+        print("Homebrew not found. Please install Homebrew first by running:", file=sys.stderr)
+        print('/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"', file=sys.stderr)
+        return -1
+
+    try:
+        print("Attempting to install FFmpeg using brew...")
+        subprocess.run(["brew", "install", "ffmpeg"], check=True)
+        print("FFmpeg installation complete.")
+        return 0
+    except subprocess.CalledProcessError as e:
+        print(f"Error installing FFmpeg with Homebrew: {e}", file=sys.stderr)
+        return -1
+
+def get_linux_distro():
+    """
+    A simplified way to detect Linux distributions.
+    """
+    if os.path.exists('/etc/os-release'):
+        with open('/etc/os-release') as f:
+            content = f.read()
+            if "ID=arch" in content:
+                return "arch"
+            elif "ID=ubuntu" in content:
+                return "ubuntu"
+            elif "ID=debian" in content:
+                return "debian"
+            elif "ID_LIKE=centos" in content or "ID=centos" in content:
+                return "centos"
+            elif "ID=fedora" in content:
+                return "fedora"
+    
+    if os.path.exists('/etc/arch-release'):
+        return "arch"
+    if os.path.exists('/etc/debian_version'):
+        return "debian"
+    if os.path.exists('/etc/redhat-release'):
+        return "redhat"
+        
+    return "unknown"
+
+if __name__ == "__main__":
+    exit_code = install_ffmpeg_if_needed()
+    sys.exit(exit_code)

HwCodecDetect/run_tests.py

@@ -0,0 +1,352 @@
+import os
+import re
+import sys
+import subprocess
+import shutil
+import tempfile
+from collections import defaultdict
+from .install_ffmpeg_if_needed import install_ffmpeg_if_needed
+
+# Step 0: Define the data for codecs and resolutions
+# This approach avoids massive code duplication.
+RESOLUTIONS = {
+    "240p": "426x240",
+    "360p": "640x360",
+    "480p": "854x480",
+    "720p": "1280x720",
+    "1080p": "1920x1080",
+    "2K": "2560x1440",
+    "4K": "3840x2160",
+    "8K": "7680x4320",
+}
+
+# Mapping of a decoder's ffmpeg name and codec to its descriptive title
+DECODER_TITLES = {
+    ("h264_cuvid", "h264"): "NVIDIA CUDA H264 Decoder(NVDEC)",
+    ("h264_qsv", "h264"): "Intel Quick Sync Video H264 Decoder(QSV)",
+    ("hevc_cuvid", "h265"): "NVIDIA CUDA H265 Decoder(NVDEC)",
+    ("hevc_qsv", "h265"): "Intel Quick Sync Video H265 Decoder(QSV)",
+    ("av1_cuvid", "av1"): "NVIDIA CUDA AV1 Decoder(NVDEC)",
+    ("av1_qsv", "av1"): "Intel Quick Sync Video AV1 Decoder(QSV)",
+    ("mjpeg_cuvid", "mjpeg"): "NVIDIA CUDA MJPEG Decoder(NVDEC)",
+    ("mjpeg_qsv", "mjpeg"): "Intel Quick Sync Video MJPEG Decoder(QSV)",
+    ("mpeg1_cuvid", "mpeg1"): "NVIDIA CUDA MPEG-1 Decoder(NVDEC)",
+    ("mpeg2_cuvid", "mpeg2"): "NVIDIA CUDA MPEG-2 Decoder(NVDEC)",
+    ("mpeg2_qsv", "mpeg2"): "Intel Quick Sync Video MPEG-2 Decoder(QSV)",
+    ("mpeg4_cuvid", "mpeg4"): "NVIDIA CUDA MPEG-4 Decoder(NVDEC)",
+    ("vp8_cuvid", "vp8"): "NVIDIA CUDA VP8 Decoder(NVDEC)",
+    ("vp8_qsv", "vp8"): "Intel Quick Sync Video VP8 Decoder(QSV)",
+    ("vp9_cuvid", "vp9"): "NVIDIA CUDA VP9 Decoder(NVDEC)",
+    ("vp9_qsv", "vp9"): "Intel Quick Sync Video VP9 Decoder(QSV)",
+    ("dxva2", "h264"): "Microsoft DirectX Video Acceleration H264 Decoder(DXVA2)",
+    ("dxva2", "h265"): "Microsoft DirectX Video Acceleration H265 Decoder(DXVA2)",
+    ("dxva2", "av1"): "Microsoft DirectX Video Acceleration AV1 Decoder(DXVA2)",
+    ("dxva2", "mjpeg"): "Microsoft DirectX Video Acceleration MJPEG Decoder(DXVA2)",
+    ("dxva2", "mpeg1"): "Microsoft DirectX Video Acceleration MPEG-1 Decoder(DXVA2)",
+    ("dxva2", "mpeg2"): "Microsoft DirectX Video Acceleration MPEG-2 Decoder(DXVA2)",
+    ("dxva2", "mpeg4"): "Microsoft DirectX Video Acceleration MPEG-4 Decoder(DXVA2)",
+    ("dxva2", "vp8"): "Microsoft DirectX Video Acceleration VP8 Decoder(DXVA2)",
+    ("dxva2", "vp9"): "Microsoft DirectX Video Acceleration VP9 Decoder(DXVA2)",
+    ("d3d11va", "h264"): "Direct3D 11 Video Acceleration H264 Decoder(D3D11VA)",
+    ("d3d11va", "h265"): "Direct3D 11 Video Acceleration H265 Decoder(D3D11VA)",
+    ("d3d11va", "av1"): "Direct3D 11 Video Acceleration AV1 Decoder(D3D11VA)",
+    ("d3d11va", "mjpeg"): "Direct3D 11 Video Acceleration MJPEG Decoder(D3D11VA)",
+    ("d3d11va", "mpeg1"): "Direct3D 11 Video Acceleration MPEG-1 Decoder(D3D11VA)",
+    ("d3d11va", "mpeg2"): "Direct3D 11 Video Acceleration MPEG-2 Decoder(D3D11VA)",
+    ("d3d11va", "mpeg4"): "Direct3D 11 Video Acceleration MPEG-4 Decoder(D3D11VA)",
+    ("d3d11va", "vp8"): "Direct3D 11 Video Acceleration VP8 Decoder(D3D11VA)",
+    ("d3d11va", "vp9"): "Direct3D 11 Video Acceleration VP9 Decoder(D3D11VA)",
+}
+
+DECODERS = {
+    "h264": {"lib": "libx264", "hw_decoders": ["h264_cuvid", "h264_qsv", "dxva2", "d3d11va"]},
+    "h265": {"lib": "libx265", "hw_decoders": ["hevc_cuvid", "hevc_qsv", "d3d11va"]},
+    "av1": {"lib": "librav1e", "hw_decoders": ["av1_cuvid", "av1_qsv", "dxva2", "d3d11va"]},
+    "mjpeg": {"lib": "mjpeg", "hw_decoders": ["mjpeg_cuvid", "mjpeg_qsv", "dxva2", "d3d11va"]},
+    "mpeg1": {"lib": "mpeg1video", "hw_decoders": ["mpeg1_cuvid", "dxva2", "d3d11va"]},
+    "mpeg2": {"lib": "mpeg2video", "hw_decoders": ["mpeg2_cuvid", "mpeg2_qsv", "dxva2", "d3d11va"]},
+    "mpeg4": {"lib": "mpeg4", "hw_decoders": ["mpeg4_cuvid", "dxva2", "d3d11va"]},
+    "vp8": {"lib": "libvpx", "hw_decoders": ["vp8_cuvid", "vp8_qsv", "dxva2", "d3d11va"]},
+    "vp9": {"lib": "libvpx-vp9", "hw_decoders": ["vp9_cuvid", "vp9_qsv", "dxva2", "d3d11va"]},
+}
+
+# --- Encoder Definitions ---
+ENCODER_TITLES = {
+    ("h264_nvenc", "h264"): "NVIDIA Hardware H264 Encoder(NVEnc)",
+    ("hevc_nvenc", "h265"): "NVIDIA Hardware H265 Encoder(NVEnc)",
+    ("av1_nvenc", "av1"): "NVIDIA Hardware AV1 Encoder(NVEnc)",
+    ("h264_qsv", "h264"): "Intel Hardware H264 Encoder(QSV)",
+    ("hevc_qsv", "h265"): "Intel Hardware H265 Encoder(QSV)",
+    ("av1_qsv", "av1"): "Intel Hardware AV1 Encoder(QSV)",
+    ("mjpeg_qsv", "mjpeg"): "Intel Hardware MJPEG Encoder(QSV)",
+    ("mpeg2_qsv", "mpeg2"): "Intel Hardware MPEG-2 Encoder(QSV)",
+    ("vp9_qsv", "vp9"): "Intel Hardware VP9 Encoder(QSV)",
+    ("h264_amf", "h264"): "AMD Hardware H264 Encoder(AMF)",
+    ("hevc_amf", "h265"): "AMD Hardware H265 Encoder(AMF)",
+    ("av1_amf", "av1"): "AMD Hardware AV1 Encoder(AMF)",
+    ("h264_mf", "h264"): "Microsoft Hardware H264 Encoder(MediaFoundation)",
+    ("hevc_mf", "h265"): "Microsoft Hardware H265 Encoder(MediaFoundation)",
+    ("h264_vaapi", "h264"): "Video Acceleration H264 Encoder(VAAPI)",
+    ("hevc_vaapi", "h265"): "Video Acceleration H265 Encoder(VAAPI)",
+    ("av1_vaapi", "av1"): "Video Acceleration AV1 Encoder(VAAPI)",
+    ("mjpeg_vaapi", "mjpeg"): "Video Acceleration MJPEG Encoder(VAAPI)",
+    ("mpeg2_vaapi", "mpeg2"): "Video Acceleration MPEG-2 Encoder(VAAPI)",
+    ("vp8_vaapi", "vp8"): "Video Acceleration VP8 Encoder(VAAPI)",
+    ("vp9_vaapi", "vp9"): "Video Acceleration VP9 Encoder(VAAPI)",
+    ("h264_vulkan", "h264"): "Vulkan Hardware H264 Encoder",
+    ("hevc_vulkan", "h265"): "Vulkan Hardware H265 Encoder",
+}
+
+ENCODERS = {
+    "h264": {"lib": "libx264", "hw_encoders": ["h264_nvenc", "h264_qsv", "h264_amf", "h264_mf", "h264_vaapi", "h264_vulkan"]},
+    "h265": {"lib": "libx265", "hw_encoders": ["hevc_nvenc", "hevc_qsv", "hevc_amf", "hevc_mf", "hevc_vaapi", "hevc_vulkan"]},
+    "av1": {"lib": "librav1e", "hw_encoders": ["av1_nvenc", "av1_qsv", "av1_amf", "av1_vaapi"]},
+    "mjpeg": {"lib": "mjpeg", "hw_encoders": ["mjpeg_qsv", "mjpeg_vaapi"]},
+    "mpeg2": {"lib": "mpeg2video", "hw_encoders": ["mpeg2_qsv", "mpeg2_vaapi"]},
+    "vp8": {"lib": "libvpx", "hw_encoders": ["vp8_vaapi"]},
+    "vp9": {"lib": "libvpx-vp9", "hw_encoders": ["vp9_qsv", "vp9_vaapi"]},
+}
+
+# Combine both decoder and encoder data into a single structure
+# This makes it easier to work with all codecs and their associated CPU libs
+ALL_CODECS = {
+    **DECODERS,
+    **{k: v for k, v in ENCODERS.items() if k not in DECODERS}
+}
+
+def _run_ffmpeg_command(command):
+    """Executes an FFmpeg command and returns True on success, False on failure."""
+    try:
+        result = subprocess.run(
+            command,
+            check=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        return result.returncode == 0
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+def _run_encoder_tests(test_dir):
+    """Runs hardware encoder tests and returns a structured dictionary of results."""
+    results = defaultdict(dict)
+    
+    GREEN = "\033[92m"
+    RED = "\033[91m"
+    RESET = "\033[0m"
+    
+    print("\n--- Running Encoder Tests ---")
+
+    for codec, info in ENCODERS.items():
+        for encoder in info['hw_encoders']:
+            title = ENCODER_TITLES.get((encoder, codec), f"{encoder.upper()} Encoder:")
+            print(f"\n{title}")
+
+            for res_name, res_size in RESOLUTIONS.items():
+                # Encoder tests generate the output file
+                file_ext = ".webm" if codec in ["vp8", "vp9"] else ".mp4"
+                output_file = os.path.join(test_dir, f"{encoder}_{res_name}{file_ext}")
+
+                command = [
+                    "ffmpeg",
+                    "-loglevel", "quiet",
+                    "-hide_banner",
+                    "-y",
+                    "-f", "lavfi",
+                    "-i", f"color=white:s={res_size}:d=1",
+                    "-frames:v", "1",
+                    "-c:v", encoder,
+                    "-pixel_format", "yuv420p",
+                    output_file,
+                ]
+
+                # Specific flags for QSV encoders from the bat file
+                if "qsv" in encoder:
+                    command.insert(9, "-dual_gfx")
+                    command.insert(10, "0")
+
+                status = "succeeded" if _run_ffmpeg_command(command) else "failed"
+                results[title][res_name] = status
+                
+                color_code = GREEN if status == "succeeded" else RED
+                print(f"  {res_name}: {color_code}{status}{RESET}")
+
+    return results
+
+def _run_decoder_tests(test_dir):
+    """
+    Runs hardware decoder tests and returns a structured dictionary of results.
+    It checks for existing files first and generates new ones if needed.
+    """
+    results = defaultdict(dict)
+    
+    GREEN = "\033[92m"
+    RED = "\033[91m"
+    RESET = "\033[0m"
+
+    print("\n--- Running Decoder Tests ---")
+
+    for codec, info in DECODERS.items():
+        for hw_decoder in info['hw_decoders']:
+            title = DECODER_TITLES.get((hw_decoder, codec), f"{hw_decoder.upper()} Decoder:")
+            print(f"\n{title}")
+
+            for res_name, res_size in RESOLUTIONS.items():
+                file_ext = ".webm" if codec in ["vp8", "vp9"] else ".mp4"
+                
+                # We need to find *any* existing file for this codec/resolution combo
+                # A simple approach is to check if a file with the correct codec and resolution exists
+                found_file = False
+                test_file_path = os.path.join(test_dir, f"{codec}_{res_name}{file_ext}")
+                
+                # Try to use any file already generated from encoder tests
+                for filename in os.listdir(test_dir):
+                    if filename.startswith(f"{codec}_") and f"_{res_name}" in filename:
+                         test_file_path = os.path.join(test_dir, filename)
+                         found_file = True
+                         break
+                
+                # If no file found, generate one using CPU encoder
+                if not found_file:
+                    cpu_lib = ALL_CODECS[codec]["lib"]
+                    command = [
+                        "ffmpeg", "-loglevel", "quiet", "-hide_banner", "-y",
+                        "-f", "lavfi", "-i", f"color=white:s={res_size}:d=1",
+                        "-frames:v", "1", "-c:v", cpu_lib, "-pixel_format", "yuv420p",
+                        test_file_path,
+                    ]
+                    if not _run_ffmpeg_command(command):
+                         results[title][res_name] = "skipped"
+                         print(f"  {res_name}: {RED}skipped (failed to generate temp file){RESET}")
+                         continue
+
+                # Run the actual decoder test
+                if hw_decoder in ["dxva2", "d3d11va"] and codec in ["h264", "h265", "vp8"]:
+                    command = [
+                        "ffmpeg", "-loglevel", "quiet", "-hide_banner", "-y",
+                        "-hwaccel", hw_decoder, "-i", test_file_path,
+                        "-c:v", "libx264", "-preset", "ultrafast",
+                        "-f", "null", "null",
+                    ]
+                else:
+                    command = [
+                        "ffmpeg", "-loglevel", "quiet", "-hide_banner", "-y",
+                        "-c:v", hw_decoder, "-i", test_file_path,
+                        "-c:v", "libx264", "-preset", "ultrafast",
+                        "-f", "null", "null",
+                    ]
+                
+                status = "succeeded" if _run_ffmpeg_command(command) else "failed"
+                results[title][res_name] = status
+                
+                color_code = GREEN if status == "succeeded" else RED
+                print(f"  {res_name}: {color_code}{status}{RESET}")
+
+    return results
+
+def _get_display_width(s):
+    """
+    Calculates the display width of a string, ignoring ANSI escape codes.
+    """
+    ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
+    return len(ansi_escape.sub('', s))
+
+def _print_summary_table(results):
+    """Prints a formatted summary table of all test results."""
+    GREEN_CHECK = "\033[92m✓\033[0m"
+    RED_X = "\033[91m×\033[0m"
+    GRAY_DASH = "\033[90m—\033[0m"
+    
+    # Get column headers (resolutions) and row headers (decoder titles)
+    resolutions = list(RESOLUTIONS.keys())
+    
+    # Use different headers for decoders and encoders
+    decoder_titles = sorted([t for t in results.keys() if "Decoder" in t])
+    encoder_titles = sorted([t for t in results.keys() if "Encoder" in t])
+
+    # Calculate column widths based on display width
+    res_width = max(len(res) for res in resolutions)
+    row_header_width = max([_get_display_width(t) for t in results.keys()] + [20, _get_display_width("Decoder"), _get_display_width("Encoder")])
+    
+    # Print Decoder Table
+    if decoder_titles:
+        print("\n" + "-" * (row_header_width + 3 + (res_width + 3) * len(resolutions)))
+        header_text = "Decoder"
+        padding_left = (row_header_width - _get_display_width(header_text)) // 2
+        padding_right = row_header_width - _get_display_width(header_text) - padding_left
+        header_row = f"| {' ' * padding_left}{header_text}{' ' * padding_right} |"
+        for res in resolutions:
+            header_row += f" {res.center(res_width)} |"
+        print(header_row)
+        print("-" * (row_header_width + 3 + (res_width + 3) * len(resolutions)))
+        
+        for title in decoder_titles:
+            padding_needed = row_header_width - _get_display_width(title)
+            row_string = f"| {title}{' ' * padding_needed} |"
+            for res in resolutions:
+                status = results.get(title, {}).get(res, "skipped")
+                symbol = GREEN_CHECK if status == "succeeded" else RED_X if status == "failed" else GRAY_DASH
+                symbol_width = _get_display_width(symbol)
+                padding_left = (res_width - symbol_width) // 2
+                padding_right = res_width - symbol_width - padding_left
+                row_string += f" {' ' * padding_left}{symbol}{' ' * padding_right} |"
+            print(row_string)
+        print("-" * (row_header_width + 3 + (res_width + 3) * len(resolutions)))
+
+    # Print Encoder Table
+    if encoder_titles:
+        print("\n" + "-" * (row_header_width + 3 + (res_width + 3) * len(resolutions)))
+        header_text = "Encoder"
+        padding_left = (row_header_width - _get_display_width(header_text)) // 2
+        padding_right = row_header_width - _get_display_width(header_text) - padding_left
+        header_row = f"| {' ' * padding_left}{header_text}{' ' * padding_right} |"
+        for res in resolutions:
+            header_row += f" {res.center(res_width)} |"
+        print(header_row)
+        print("-" * (row_header_width + 3 + (res_width + 3) * len(resolutions)))
+        
+        for title in encoder_titles:
+            padding_needed = row_header_width - _get_display_width(title)
+            row_string = f"| {title}{' ' * padding_needed} |"
+            for res in resolutions:
+                status = results.get(title, {}).get(res, "skipped")
+                symbol = GREEN_CHECK if status == "succeeded" else RED_X if status == "failed" else GRAY_DASH
+                symbol_width = _get_display_width(symbol)
+                padding_left = (res_width - symbol_width) // 2
+                padding_right = res_width - symbol_width - padding_left
+                row_string += f" {' ' * padding_left}{symbol}{' ' * padding_right} |"
+            print(row_string)
+        print("-" * (row_header_width + 3 + (res_width + 3) * len(resolutions)))
+
+
+def run_all_tests():
+    """Main function to run the entire test suite."""
+    print("Starting hardware codec detection test suite...")
+
+    if install_ffmpeg_if_needed() != 0:
+        print("Error: FFmpeg dependency not met. Please check installation.", file=sys.stderr)
+        return -1
+
+    temp_dir = os.path.join(tempfile.gettempdir(), "HwCodecDetect")
+    if os.path.exists(temp_dir):
+        # Clear previous run data to ensure a fresh test
+        shutil.rmtree(temp_dir)
+    os.makedirs(temp_dir)
+        
+    encoder_results = _run_encoder_tests(temp_dir)
+    decoder_results = _run_decoder_tests(temp_dir)
+
+    all_results = {}
+    all_results.update(encoder_results)
+    all_results.update(decoder_results)
+    
+    _print_summary_table(all_results)
+    
+    print("\nCleaning up temporary files...")
+    shutil.rmtree(temp_dir)
+    print("Cleanup complete.")
+
+    return all_results
+    
+if __name__ == "__main__":
+    run_all_tests()

hwcodecdetect-0.0.1.dist-info/METADATA

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: HwCodecDetect
+Version: 0.0.1
+Summary: A cross-platform tool to automatically detect and test hardware video decoders/encoders using FFmpeg.
+Author-email: whyb <whyber@outlook.com>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/whyb/HwCodecDetect
+Project-URL: Issues, https://github.com/whyb/HwCodecDetect/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: System :: Installation/Setup
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# FFmpeg 硬件编解码器测试脚本
+在今天的编解码硬件加速的生态中，视频编解码技术面临着一个“百家争鸣”的局面。为了利用 GPU 的强大算力，各家硬件厂商都推出了自己的加速框架或编码器标准，例如 NVIDIA 的 NVEnc/NVDec、Intel 的 QSV 和 AMD 的 AMF。此外，操作系统层也提供了通用的接口，如微软的 Media Foundation 和 DXAV 、 D3D12VA ，而开源社区则发展了跨平台的 VAAPI 和 Vulkan 等标准。
+
+这种多样性虽然带来了技术上的进步，但也给普通用户和开发者带来了挑战。由于历史遗留和兼容性问题，一个硬件可能支持多种编码器，但它们在性能、支持的格式和分辨率方面都有所不同。因此，在使用 FFmpeg 进行硬件加速时，很难直观地知道哪种编码器最适合自己的设备。
+
+本项目正是为了解决这一痛点而生。它是一个用于自动化检测系统硬件视频编码器功能的便捷工具。它利用 FFmpeg，通过生成不同分辨率（从 240p 到 8K）的单帧视频文件，并尝试使用各种硬件编码器进行处理，以此来快速判断哪些硬件编码器在您的系统上可用以及它们所支持的分辨率。
+
+## 主要功能
+### 编码器
+脚本会自动测试并报告以下主流硬件编码器及其支持的格式：
+| 编码器名称                     	 | 支持的视频编码格式                           |
+|-----------------------------------|------------------------------------------- |
+| NVEnc                          	| H.264、H.265、AV1                          |
+| QSV (Quick Sync Video)         	| H.264、H.265、AV1、MJPEG、MPEG-2、VP9       |
+| AMF (Advanced Media Framework)    | H.264、H.265、AV1                          |
+| Media Foundation               	| H.264、H.265                               |
+| VAAPI (Video Acceleration API) 	| H.264、H.265、AV1、MJPEG、MPEG-2、VP8、VP9  |
+| Vulkan                         	| H.264、H.265                               |
+
+### 解码器
+脚本会自动测试并报告以下主流硬件解码器及其支持的格式：
+| 编码器名称                                 | 支持的视频编码格式                                             |
+|------------------------------------------	|------------------------------------------------------------- |
+| NVDec (CUVID)                  	        | H.264、H.265、AV1、MJPEG、MPEG-1、MPEG-2、MPEG-4、VP8、VP9    |
+| QSV (Quick Sync Video)         	        | H.264、H.265、AV1、MJPEG、MPEG-2、VP8、VP9                    |
+| AMF (Advanced Media Framework)            | H.264、H.265、AV1                                            |
+| DXVA2 (DirectX Video Acceleration)        | H.264、H.265、MJPEG、MPEG-1、MPEG-2、MPEG-4、VP8              |
+| D3D11VA (Direct3D 11 Video Acceleration) 	| H.264、H.265、AV1、MJPEG、MPEG-1、MPEG-2、MPEG-4、VP8、VP9    |
+
+
+## 如何使用
+
+### 1. 克隆仓库
+首先，克隆此仓库到你的本地。
+```bash
+git clone https://github.com/whyb/HwCodecDetect.git
+cd HwCodecDetect
+```
+
+### 2. 运行测试
+```bash
+python -m HwCodecDetect.run_tests
+```
+
+
+## 效果展示
+下面是本地运行测试的可能的结果：
+
+![decoder test result](imgs/decoder.png)
+
+
+![encoder test result](imgs/encoder.png)

hwcodecdetect-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+HwCodecDetect/__init__.py,sha256=2ymTSqSTlUPK_QexrL4dxxL8N7tkqPdaWfFA56R83LY,134
+HwCodecDetect/install_ffmpeg_if_needed.py,sha256=y1T8hZ-_sPZdxEDIj3lYPsfk3mhlIc2pG58k3xiqw0Q,7312
+HwCodecDetect/run_tests.py,sha256=I3M9PNbkbo6cAiaPAp-tzG83X78fqJ1-IhX2ER-b4Kc,16619
+hwcodecdetect-0.0.1.dist-info/licenses/LICENSE,sha256=MbDIouN72hBze3wjpi9OjjvDtTpnF7HmRo3rJ3CQX0U,1496
+hwcodecdetect-0.0.1.dist-info/METADATA,sha256=1ETxxM8dkW_xfHGuE0oWwk5hg-sJlVV62P6UYah6xa4,4034
+hwcodecdetect-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+hwcodecdetect-0.0.1.dist-info/entry_points.txt,sha256=KdclE06P1pTzQLgtBWwsEkqNKf3dzvzPxUZDs19g0KQ,72
+hwcodecdetect-0.0.1.dist-info/top_level.txt,sha256=Vm6bhU7wKyxnNL_3ndZ7bHlt-shBFhfEPIeeBDKz_Ag,14
+hwcodecdetect-0.0.1.dist-info/RECORD,,

hwcodecdetect-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

hwcodecdetect-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+hwcodecdetect = HwCodecDetect.run_tests:run_all_tests

hwcodecdetect-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, 張小凡
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

hwcodecdetect-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+HwCodecDetect