HwCodecDetect 0.2.3__tar.gz → 0.2.4__tar.gz

{hwcodecdetect-0.2.3/src/HwCodecDetect.egg-info → hwcodecdetect-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: HwCodecDetect
-Version: 0.2.3
+Version: 0.2.4
 Summary: A cross-platform tool to automatically detect and test hardware video decoders/encoders using FFmpeg.
 Home-page: https://github.com/whyb/HwCodecDetect
 Author: whyb

hwcodecdetect-0.2.4/VERSION

@@ -0,0 +1 @@
+0.2.4

{hwcodecdetect-0.2.3 → hwcodecdetect-0.2.4}/src/HwCodecDetect/bitdepth_chroma_detect.py

@@ -12,6 +12,7 @@ from collections import defaultdict
 from colorama import init, Fore, Style
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from tqdm import tqdm
+from .utils import check_codec_support
 
 init(autoreset=True)
 
@@ -152,13 +153,19 @@ def _run_ffmpeg_command(command, verbose):
 
 def _run_encoder_bitdepth_test(test_data):
     """Tests encoder support for a specific pixel format."""
-    codec, encoder, pix_fmt, bit_depth, chroma, test_dir, verbose = test_data
+    codec, encoder, pix_fmt, bit_depth, chroma, test_dir, verbose, unsupported_encoders = test_data
+
+    # Skip unsupported encoders
+    if encoder in unsupported_encoders:
+        title = ENCODER_TITLES.get((encoder, codec), f"{encoder.upper()} Encoder:")
+        return title, pix_fmt, bit_depth, chroma, "skipped"
+
     if codec == "prores":
         file_ext = ".mov"
     else:
         file_ext = ".webm" if codec in ["vp8", "vp9"] else ".mp4"
     output_file = os.path.join(test_dir, f"{encoder}_{pix_fmt}{file_ext}")
-    
+
     # Determine pixel format for output based on input format
     if bit_depth == 8:
         if chroma == "4:2:0":
@@ -270,17 +277,20 @@ def _run_encoder_bitdepth_test(test_data):
     return title, pix_fmt, bit_depth, chroma, status
 
 
-def _run_encoder_bitdepth_tests(test_dir, max_workers, verbose):
+def _run_encoder_bitdepth_tests(test_dir, max_workers, verbose, unsupported_encoders=None):
     """Tests encoder support for various pixel formats."""
     results = defaultdict(dict)
 
+    if unsupported_encoders is None:
+        unsupported_encoders = set()
+
     print("\n--- Running Bit-depth/Chroma Encoder Tests ---")
 
     tasks = []
     for codec, info in ENCODERS.items():
         for encoder in info['hw_encoders']:
             for pix_fmt, bit_depth, chroma, desc in PIXEL_FORMATS:
-                tasks.append((codec, encoder, pix_fmt, bit_depth, chroma, test_dir, verbose))
+                tasks.append((codec, encoder, pix_fmt, bit_depth, chroma, test_dir, verbose, unsupported_encoders))
 
     with ThreadPoolExecutor(max_workers=max_workers) as executor:
         futures = [executor.submit(_run_encoder_bitdepth_test, task) for task in tasks]
@@ -297,7 +307,13 @@ def _run_encoder_bitdepth_tests(test_dir, max_workers, verbose):
 
 def _run_decoder_bitdepth_test(test_data):
     """Tests decoder support for a specific pixel format."""
-    codec, hw_decoder, pix_fmt, bit_depth, chroma, test_dir, verbose = test_data
+    codec, hw_decoder, pix_fmt, bit_depth, chroma, test_dir, verbose, unsupported_decoders = test_data
+
+    # Skip unsupported decoders
+    if hw_decoder in unsupported_decoders:
+        title = DECODER_TITLES.get((hw_decoder, codec), f"{hw_decoder.upper()} Decoder:")
+        return title, pix_fmt, bit_depth, chroma, "skipped"
+
     if codec == "prores":
         file_ext = ".mov"
     else:
@@ -383,17 +399,20 @@ def _run_decoder_bitdepth_test(test_data):
     return title, pix_fmt, bit_depth, chroma, status
 
 
-def _run_decoder_bitdepth_tests(test_dir, max_workers, verbose):
+def _run_decoder_bitdepth_tests(test_dir, max_workers, verbose, unsupported_decoders=None):
     """Tests decoder support for various pixel formats."""
     results = defaultdict(dict)
 
+    if unsupported_decoders is None:
+        unsupported_decoders = set()
+
     print("\n--- Running Bit-depth/Chroma Decoder Tests ---")
 
     tasks = []
     for codec, info in DECODERS.items():
         for hw_decoder in info['hw_decoders']:
             for pix_fmt, bit_depth, chroma, desc in PIXEL_FORMATS:
-                tasks.append((codec, hw_decoder, pix_fmt, bit_depth, chroma, test_dir, verbose))
+                tasks.append((codec, hw_decoder, pix_fmt, bit_depth, chroma, test_dir, verbose, unsupported_decoders))
 
     with ThreadPoolExecutor(max_workers=max_workers) as executor:
         futures = [executor.submit(_run_decoder_bitdepth_test, task) for task in tasks]
@@ -463,13 +482,24 @@ def _print_bitdepth_chroma_table(results, table_type="Encoder"):
 def run_bitdepth_chroma_tests(encoder_count, decoder_count, verbose):
     """Run all bit-depth and chroma tests and return results."""
     import shutil
-    temp_dir = os.path.join(tempfile.gettempdir(), "HwCodecDetect_BitDepth")
+    #temp_dir = os.path.join(tempfile.gettempdir(), "HwCodecDetect_BitDepth")
+    from .utils import get_temp_path
+    temp_dir = os.path.join(get_temp_path(), "HwCodecDetect_BitDepth")
     if os.path.exists(temp_dir):
         shutil.rmtree(temp_dir)
-    os.makedirs(temp_dir)
+    os.makedirs(temp_dir, exist_ok=True)
+
+    # Check codec support before running tests
+    print("\nChecking FFmpeg codec support for bit-depth/chroma tests...")
+    unsupported_encoders, unsupported_decoders = check_codec_support(ENCODERS, DECODERS)
+    if unsupported_encoders or unsupported_decoders:
+        print(f"\nFound {len(unsupported_encoders)} unsupported encoder(s) and {len(unsupported_decoders)} unsupported decoder(s).")
+        print("These codecs will be marked as unavailable '-' in the results.\n")
+    else:
+        print("All defined hardware codecs are supported.\n")
 
-    encoder_results = _run_encoder_bitdepth_tests(temp_dir, encoder_count, verbose)
-    decoder_results = _run_decoder_bitdepth_tests(temp_dir, decoder_count, verbose)
+    encoder_results = _run_encoder_bitdepth_tests(temp_dir, encoder_count, verbose, unsupported_encoders)
+    decoder_results = _run_decoder_bitdepth_tests(temp_dir, decoder_count, verbose, unsupported_decoders)
 
     # Clean up
     shutil.rmtree(temp_dir)

{hwcodecdetect-0.2.3 → hwcodecdetect-0.2.4}/src/HwCodecDetect/run_tests.py

@@ -10,6 +10,7 @@ import argparse
 from collections import defaultdict
 from .install_ffmpeg_if_needed import install_ffmpeg_if_needed
 from .bitdepth_chroma_detect import run_bitdepth_chroma_tests, print_bitdepth_chroma_results
+from .utils import check_codec_support
 from colorama import init, Fore, Style
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from tqdm import tqdm
@@ -263,7 +264,13 @@ def _run_ffmpeg_command(command, verbose):
 
 def _run_encoder_test_single(test_data):
     """Runs a single encoder test and returns the result."""
-    codec, encoder, res_name, res_size, test_dir, verbose = test_data
+    codec, encoder, res_name, res_size, test_dir, verbose, unsupported_encoders = test_data
+
+    # Skip unsupported encoders
+    if encoder in unsupported_encoders:
+        title = ENCODER_TITLES.get((encoder, codec), f"{encoder.upper()} Encoder:")
+        return title, res_name, "skipped"
+
     if codec == "prores":
         file_ext = ".mov"
     else:
@@ -358,17 +365,20 @@ def _run_encoder_test_single(test_data):
     return title, res_name, status
 
 
-def _run_encoder_tests(test_dir, max_workers, verbose):
+def _run_encoder_tests(test_dir, max_workers, verbose, unsupported_encoders=None):
     """Runs hardware encoder tests using a thread pool."""
     results = defaultdict(dict)
-    
+
+    if unsupported_encoders is None:
+        unsupported_encoders = set()
+
     print("\n--- Running Encoder Tests ---")
-    
+
     tasks = []
     for codec, info in ENCODERS.items():
         for encoder in info['hw_encoders']:
             for res_name, res_size in RESOLUTIONS.items():
-                tasks.append((codec, encoder, res_name, res_size, test_dir, verbose))
+                tasks.append((codec, encoder, res_name, res_size, test_dir, verbose, unsupported_encoders))
 
     with ThreadPoolExecutor(max_workers=max_workers) as executor:
         futures = [executor.submit(_run_encoder_test_single, task) for task in tasks]
@@ -381,7 +391,13 @@ def _run_encoder_tests(test_dir, max_workers, verbose):
 
 def _run_decoder_test_single(test_data):
     """Runs a single decoder test and returns the result."""
-    codec, hw_decoder, res_name, res_size, test_dir, verbose = test_data
+    codec, hw_decoder, res_name, res_size, test_dir, verbose, unsupported_decoders = test_data
+
+    # Skip unsupported decoders
+    if hw_decoder in unsupported_decoders:
+        title = DECODER_TITLES.get((hw_decoder, codec), f"{hw_decoder.upper()} Decoder:")
+        return title, res_name, "skipped"
+
     if codec == "prores":
         file_ext = ".mov"
     else:
@@ -476,17 +492,20 @@ def _run_decoder_test_single(test_data):
     return title, res_name, status
 
 
-def _run_decoder_tests(test_dir, max_workers, verbose):
+def _run_decoder_tests(test_dir, max_workers, verbose, unsupported_decoders=None):
     """Runs hardware decoder tests using a thread pool."""
     results = defaultdict(dict)
 
+    if unsupported_decoders is None:
+        unsupported_decoders = set()
+
     print("\n--- Running Decoder Tests ---")
 
     tasks = []
     for codec, info in DECODERS.items():
         for hw_decoder in info['hw_decoders']:
             for res_name, res_size in RESOLUTIONS.items():
-                tasks.append((codec, hw_decoder, res_name, res_size, test_dir, verbose))
+                tasks.append((codec, hw_decoder, res_name, res_size, test_dir, verbose, unsupported_decoders))
 
     with ThreadPoolExecutor(max_workers=max_workers) as executor:
         futures = [executor.submit(_run_decoder_test_single, task) for task in tasks]
@@ -575,14 +594,25 @@ def run_all_tests(args):
         print("Error: FFmpeg dependency not met. Please check installation.", file=sys.stderr)
         return -1
 
-    temp_dir = os.path.join(tempfile.gettempdir(), "HwCodecDetect")
+    # Check codec support before running tests
+    print("\nChecking FFmpeg codec support...")
+    unsupported_encoders, unsupported_decoders = check_codec_support(ENCODERS, DECODERS)
+    if unsupported_encoders or unsupported_decoders:
+        print(f"\nFound {len(unsupported_encoders)} unsupported encoder(s) and {len(unsupported_decoders)} unsupported decoder(s).")
+        print("These codecs will be marked as unavailable '-' in the results.\n")
+    else:
+        print("All defined hardware codecs are supported.\n")
+
+    #temp_dir = os.path.join(tempfile.gettempdir(), "HwCodecDetect")
+    from .utils import get_temp_path
+    temp_dir = os.path.join(get_temp_path(), "HwCodecDetect_cli")
     if os.path.exists(temp_dir):
         # Clear previous run data to ensure a fresh test
         shutil.rmtree(temp_dir)
-    os.makedirs(temp_dir)
+    os.makedirs(temp_dir, exist_ok=True)
         
-    encoder_results = _run_encoder_tests(temp_dir, args.encoder_count, args.verbose)
-    decoder_results = _run_decoder_tests(temp_dir, args.decoder_count, args.verbose)
+    encoder_results = _run_encoder_tests(temp_dir, args.encoder_count, args.verbose, unsupported_encoders)
+    decoder_results = _run_decoder_tests(temp_dir, args.decoder_count, args.verbose, unsupported_decoders)
 
     all_results = {}
     all_results.update(encoder_results)

hwcodecdetect-0.2.4/src/HwCodecDetect/utils.py

@@ -0,0 +1,166 @@
+import os
+import os.path
+import tempfile
+import sys
+import re
+import subprocess
+from pathlib import Path
+
+def get_temp_path():
+    app_id = "HwCodecDetect"
+    
+    candidates = []
+
+    candidates.append(os.path.join(tempfile.gettempdir(), app_id))
+
+    if sys.platform == "win32":
+        local_appdata = os.getenv("LOCALAPPDATA")
+        if local_appdata:
+            candidates.append(os.path.join(local_appdata, app_id))
+    elif sys.platform == "darwin":
+        candidates.append(os.path.expanduser(f"~/Library/Caches/{app_id}"))
+    elif sys.platform.startswith("linux"):
+        xdg_cache = os.getenv("XDG_CACHE_HOME", os.path.expanduser("~/.cache"))
+        candidates.append(os.path.join(xdg_cache, app_id))
+
+    candidates.append(os.path.expanduser(f"~/.{app_id}"))
+
+    for path in candidates:
+        if not path:
+            continue
+        
+        try:
+            os.makedirs(path, mode=0o755, exist_ok=True)
+            test_file = os.path.join(path, ".perm_test")
+            with open(test_file, 'w', encoding='utf-8') as f:
+                f.write("test")
+            
+            if os.path.exists(test_file):
+                os.remove(test_file)
+                return path
+        except Exception as e:
+            print(f"Warning: Attempting path {path} failed: {e}")
+            continue
+
+    return os.getcwd()
+
+
+def get_local_version():
+    if getattr(sys, 'frozen', False):
+        base_path = sys._MEIPASS
+    else:
+        base_path = os.path.dirname(os.path.abspath(__file__))
+
+    v_path = os.path.join(base_path, "VERSION")
+
+    if not os.path.exists(v_path):
+        v_path = os.path.join(base_path, "..", "..", "VERSION")
+
+    try:
+        with open(v_path, "r", encoding="utf-8") as f:
+            return f.read().strip()
+    except FileNotFoundError:
+        return "Unknown Version"
+
+
+def get_ffmpeg_supported_codecs():
+    """Get supported encoders, decoders and hwaccels from ffmpeg.
+
+    Returns:
+        tuple: (supported_encoders, supported_decoders) - two sets containing:
+            - supported_encoders: set of supported encoder names and hwaccel methods
+            - supported_decoders: set of supported decoder names and hwaccel methods
+    """
+    supported_encoders = set()
+    supported_decoders = set()
+
+    try:
+        # Get encoders
+        result = subprocess.run(
+            ["ffmpeg", "-hide_banner", "-encoders"],
+            capture_output=True,
+            text=True,
+            encoding='utf-8',
+            errors='ignore'
+        )
+        if result.returncode == 0:
+            for line in result.stdout.split('\n'):
+                # Parse lines like:  V....D av1_nvenc          NVIDIA NVENC av1 encoder (codec av1)
+                # Format: [VSA][6 chars of flags] [codec name] [description]
+                match = re.search(r'^\s*[VSA].{6}\s*(\S+)', line)
+                if match:
+                    supported_encoders.add(match.group(1))
+
+        # Get decoders
+        result = subprocess.run(
+            ["ffmpeg", "-hide_banner", "-decoders"],
+            capture_output=True,
+            text=True,
+            encoding='utf-8',
+            errors='ignore'
+        )
+        if result.returncode == 0:
+            for line in result.stdout.split('\n'):
+                # Parse lines like:  V..... av1_cuvid          Nvidia CUVID AV1 decoder (codec av1)
+                match = re.search(r'^\s*[VSA].{6}\s*(\S+)', line)
+                if match:
+                    supported_decoders.add(match.group(1))
+
+        # Get hardware acceleration methods
+        result = subprocess.run(
+            ["ffmpeg", "-hide_banner", "-hwaccels"],
+            capture_output=True,
+            text=True,
+            encoding='utf-8',
+            errors='ignore'
+        )
+        if result.returncode == 0:
+            lines = result.stdout.split('\n')
+            for line in lines:
+                line = line.strip()
+                # Skip empty lines and header
+                if not line or line.startswith('Hardware acceleration'):
+                    continue
+                # Add hwaccel methods to both encoders and decoders
+                supported_encoders.add(line)
+                supported_decoders.add(line)
+
+    except Exception as e:
+        print(f"Warning: Failed to get ffmpeg codecs: {e}", file=sys.stderr)
+
+    return supported_encoders, supported_decoders
+
+
+def check_codec_support(encoders_dict, decoders_dict):
+    """Check which hardware codecs are supported by current ffmpeg version.
+
+    Args:
+        encoders_dict: Dictionary of encoder definitions (like ENCODERS)
+        decoders_dict: Dictionary of decoder definitions (like DECODERS)
+
+    Returns:
+        tuple: (unsupported_encoders, unsupported_decoders) - two sets containing
+               the names of unsupported encoders and decoders
+    """
+    from colorama import Fore, Style
+
+    supported_encoders, supported_decoders = get_ffmpeg_supported_codecs()
+
+    unsupported_encoders = set()
+    unsupported_decoders = set()
+
+    # Check encoders
+    for codec, info in encoders_dict.items():
+        for encoder in info.get('hw_encoders', []):
+            if encoder not in supported_encoders:
+                unsupported_encoders.add(encoder)
+                print(f"{Fore.YELLOW}Warning: Encoder '{encoder}' is not supported by current FFmpeg version{Style.RESET_ALL}")
+
+    # Check decoders
+    for codec, info in decoders_dict.items():
+        for decoder in info.get('hw_decoders', []):
+            if decoder not in supported_decoders:
+                unsupported_decoders.add(decoder)
+                print(f"{Fore.YELLOW}Warning: Decoder '{decoder}' is not supported by current FFmpeg version{Style.RESET_ALL}")
+
+    return unsupported_encoders, unsupported_decoders

hwcodecdetect-0.2.4/src/HwCodecDetect/version.py

@@ -0,0 +1 @@
+__version__ = "0.2.4"

{hwcodecdetect-0.2.3 → hwcodecdetect-0.2.4/src/HwCodecDetect.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: HwCodecDetect
-Version: 0.2.3
+Version: 0.2.4
 Summary: A cross-platform tool to automatically detect and test hardware video decoders/encoders using FFmpeg.
 Home-page: https://github.com/whyb/HwCodecDetect
 Author: whyb

{hwcodecdetect-0.2.3 → hwcodecdetect-0.2.4}/src/HwCodecDetect.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ src/HwCodecDetect/__init__.py
 src/HwCodecDetect/bitdepth_chroma_detect.py
 src/HwCodecDetect/install_ffmpeg_if_needed.py
 src/HwCodecDetect/run_tests.py
+src/HwCodecDetect/utils.py
 src/HwCodecDetect/version.py
 src/HwCodecDetect.egg-info/PKG-INFO
 src/HwCodecDetect.egg-info/SOURCES.txt

hwcodecdetect-0.2.3/VERSION

@@ -1 +0,0 @@
-0.2.3

hwcodecdetect-0.2.3/src/HwCodecDetect/version.py

@@ -1 +0,0 @@
-__version__ = "0.2.3"