HwCodecDetect 0.2.2__tar.gz → 0.2.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: HwCodecDetect
-Version: 0.2.2
+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
@@ -59,8 +59,8 @@ The script automatically detect and reports on the following major hardware enco
 | Media Foundation               	       | H.264、H.265、AV1                          |
 | D3D12VA (Direct3D 12 Video Acceleration) | H.264、H.265、AV1                          |
 | VAAPI (Video Acceleration API) 	       | H.264、H.265、AV1、MJPEG、MPEG-2、VP8、VP9  |
-| Vulkan                         	       | H.264、H.265                               |
-| Apple VideoToolbox               	       | H.264、H.265                               |
+| Vulkan                         	       | H.264、H.265、AV1                          |
+| Apple VideoToolbox               	       | H.264、H.265、ProRes                       |
 
 ### Decoders
 The script automatically detect and reports on the following major hardware decoders and their supported formats:
@@ -72,7 +72,7 @@ The script automatically detect and reports on the following major hardware deco
 | 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    |
 | Vulkan                                  	| H.264、H.265、AV1                                            |
-| Apple VideoToolbox                    	| H.264、H.265、MPEG-2、MPEG-4                                 |
+| Apple VideoToolbox                    	| H.264、H.265、MPEG-2、MPEG-4、ProRes                          |
 
 ### Bit-depth and Chroma Subsampling Detection
 In addition to resolution-based testing, the tool now includes comprehensive bit-depth and chroma subsampling detection. This feature tests hardware codec support for different pixel formats, helping you understand the full capabilities of your hardware encoders and decoders.

{hwcodecdetect-0.2.2 → hwcodecdetect-0.2.4}/README.md

@@ -33,8 +33,8 @@ The script automatically detect and reports on the following major hardware enco
 | Media Foundation               	       | H.264、H.265、AV1                          |
 | D3D12VA (Direct3D 12 Video Acceleration) | H.264、H.265、AV1                          |
 | VAAPI (Video Acceleration API) 	       | H.264、H.265、AV1、MJPEG、MPEG-2、VP8、VP9  |
-| Vulkan                         	       | H.264、H.265                               |
-| Apple VideoToolbox               	       | H.264、H.265                               |
+| Vulkan                         	       | H.264、H.265、AV1                          |
+| Apple VideoToolbox               	       | H.264、H.265、ProRes                       |
 
 ### Decoders
 The script automatically detect and reports on the following major hardware decoders and their supported formats:
@@ -46,7 +46,7 @@ The script automatically detect and reports on the following major hardware deco
 | 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    |
 | Vulkan                                  	| H.264、H.265、AV1                                            |
-| Apple VideoToolbox                    	| H.264、H.265、MPEG-2、MPEG-4                                 |
+| Apple VideoToolbox                    	| H.264、H.265、MPEG-2、MPEG-4、ProRes                          |
 
 ### Bit-depth and Chroma Subsampling Detection
 In addition to resolution-based testing, the tool now includes comprehensive bit-depth and chroma subsampling detection. This feature tests hardware codec support for different pixel formats, helping you understand the full capabilities of your hardware encoders and decoders.

hwcodecdetect-0.2.4/VERSION

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

{hwcodecdetect-0.2.2 → 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)
 
@@ -58,8 +59,10 @@ ENCODER_TITLES = {
     ("vp9_vaapi", "vp9"): "Video Acceleration VP9 Encoder(VAAPI)",
     ("h264_vulkan", "h264"): "Vulkan Hardware H264 Encoder(Vulkan)",
     ("hevc_vulkan", "h265"): "Vulkan Hardware H265 Encoder(Vulkan)",
+    ("av1_vulkan", "av1"): "Vulkan Hardware AV1 Encoder(Vulkan)",
     ("h264_videotoolbox", "h264"): "MacOS Hardware H264 Encoder(VideoToolbox)",
     ("hevc_videotoolbox", "h265"): "MacOS Hardware H265 Encoder(VideoToolbox)",
+    ("prores_videotoolbox", "prores"): "MacOS Hardware ProRes Encoder(VideoToolbox)",
 }
 
 # Decoder titles (same as main module)
@@ -101,16 +104,18 @@ DECODER_TITLES = {
     ("videotoolbox", "h265"): "MacOS Hardware H265 Decoder(VideoToolbox)",
     ("videotoolbox", "mpeg2"): "MacOS Hardware MPEG-2 Decoder(VideoToolbox)",
     ("videotoolbox", "mpeg4"): "MacOS Hardware MPEG-4 Decoder(VideoToolbox)",
+    ("videotoolbox", "prores"): "MacOS Hardware ProRes Decoder(VideoToolbox)",
 }
 
 # Encoder definitions (same as main module)
 ENCODERS = {
     "h264": {"lib": "libx264", "hw_encoders": ["h264_nvenc", "h264_qsv", "h264_amf", "h264_mf", "h264_d3d12va", "h264_vaapi", "h264_vulkan", "h264_videotoolbox"]},
     "h265": {"lib": "libx265", "hw_encoders": ["hevc_nvenc", "hevc_qsv", "hevc_amf", "hevc_mf", "hevc_d3d12va", "hevc_vaapi", "hevc_vulkan", "hevc_videotoolbox"]},
-    "av1": {"lib": "librav1e", "hw_encoders": ["av1_nvenc", "av1_qsv", "av1_amf", "av1_mf", "av1_d3d12va", "av1_vaapi"]},
+    "av1": {"lib": "librav1e", "hw_encoders": ["av1_nvenc", "av1_qsv", "av1_amf", "av1_mf", "av1_d3d12va", "av1_vaapi", "av1_vulkan"]},
     "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"]},
+    "prores": {"lib": "prores", "hw_encoders": ["prores_videotoolbox"]},
 }
 
 # Decoder definitions (same as main module)
@@ -123,6 +128,7 @@ DECODERS = {
     "mpeg4": {"lib": "mpeg4", "hw_decoders": ["mpeg4_cuvid", "dxva2", "d3d11va", "videotoolbox"]},
     "vp8": {"lib": "libvpx", "hw_decoders": ["vp8_cuvid", "vp8_qsv", "dxva2", "d3d11va"]},
     "vp9": {"lib": "libvpx-vp9", "hw_decoders": ["vp9_cuvid", "vp9_qsv", "dxva2", "d3d11va"]},
+    "prores": {"lib": "prores", "hw_decoders": ["videotoolbox"]},
 }
 
 
@@ -147,11 +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
-    
-    file_ext = ".webm" if codec in ["vp8", "vp9"] else ".mp4"
+    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":
@@ -263,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]
@@ -290,9 +307,17 @@ 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
 
-    file_ext = ".webm" if codec in ["vp8", "vp9"] else ".mp4"
+    # 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:
+        file_ext = ".webm" if codec in ["vp8", "vp9"] else ".mp4"
     test_file = os.path.join(test_dir, f"{codec}_{pix_fmt}{file_ext}")
 
     # Create test file with specific pixel format if it doesn't exist
@@ -374,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]
@@ -454,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.2 → 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
@@ -78,6 +79,7 @@ DECODER_TITLES = {
     ("videotoolbox", "h265"): "MacOS Hardware H265 Decoder(VideoToolbox)",
     ("videotoolbox", "mpeg2"): "MacOS Hardware MPEG-2 Decoder(VideoToolbox)",
     ("videotoolbox", "mpeg4"): "MacOS Hardware MPEG-4 Decoder(VideoToolbox)",
+    ("videotoolbox", "prores"): "MacOS Hardware ProRes Decoder(VideoToolbox)",
 }
 
 DECODERS = {
@@ -90,6 +92,7 @@ DECODERS = {
     "mpeg4": {"lib": "mpeg4", "hw_decoders": ["mpeg4_cuvid", "dxva2", "d3d11va", "videotoolbox"]},
     "vp8": {"lib": "libvpx", "hw_decoders": ["vp8_cuvid", "vp8_qsv", "dxva2", "d3d11va"]},
     "vp9": {"lib": "libvpx-vp9", "hw_decoders": ["vp9_cuvid", "vp9_qsv", "dxva2", "d3d11va"]},
+    "prores": {"lib": "prores", "hw_decoders": ["videotoolbox"]},
 }
 
 # --- Encoder Definitions ---
@@ -121,18 +124,21 @@ ENCODER_TITLES = {
     ("vp9_vaapi", "vp9"): "Video Acceleration VP9 Encoder(VAAPI)",
     ("h264_vulkan", "h264"): "Vulkan Hardware H264 Encoder(Vulkan)",
     ("hevc_vulkan", "h265"): "Vulkan Hardware H265 Encoder(Vulkan)",
+    ("av1_vulkan", "av1"): "Vulkan Hardware AV1 Encoder(Vulkan)",
     ("h264_videotoolbox", "h264"): "MacOS Hardware H264 Encoder(VideoToolbox)",
     ("hevc_videotoolbox", "h265"): "MacOS Hardware H265 Encoder(VideoToolbox)",
+    ("prores_videotoolbox", "prores"): "MacOS Hardware ProRes Encoder(VideoToolbox)",
 }
 
 ENCODERS = {
     "h264": {"lib": "libx264", "hw_encoders": ["h264_nvenc", "h264_qsv", "h264_amf", "h264_mf", "h264_d3d12va", "h264_vaapi", "h264_vulkan", "h264_videotoolbox"]},
     "h265": {"lib": "libx265", "hw_encoders": ["hevc_nvenc", "hevc_qsv", "hevc_amf", "hevc_mf", "hevc_d3d12va", "hevc_vaapi", "hevc_vulkan", "hevc_videotoolbox"]},
-    "av1": {"lib": "librav1e", "hw_encoders": ["av1_nvenc", "av1_qsv", "av1_amf", "av1_mf", "av1_d3d12va", "av1_vaapi"]},
+    "av1": {"lib": "librav1e", "hw_encoders": ["av1_nvenc", "av1_qsv", "av1_amf", "av1_mf", "av1_d3d12va", "av1_vaapi", "av1_vulkan"]},
     "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"]},
+    "prores": {"lib": "prores", "hw_encoders": ["prores_videotoolbox"]},
 }
 
 # Combine both decoder and encoder data into a single structure
@@ -258,8 +264,17 @@ 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
-    file_ext = ".webm" if codec in ["vp8", "vp9"] else ".mp4"
+    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:
+        file_ext = ".webm" if codec in ["vp8", "vp9"] else ".mp4"
     output_file = os.path.join(test_dir, f"{encoder}_{res_name}{file_ext}")
     if "vulkan" in encoder:
         command = [
@@ -350,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]
@@ -373,8 +391,17 @@ 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
-    file_ext = ".webm" if codec in ["vp8", "vp9"] else ".mp4"
+    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:
+        file_ext = ".webm" if codec in ["vp8", "vp9"] else ".mp4"
     test_file_path = os.path.join(test_dir, f"{codec}_{res_name}{file_ext}")
 
     found_file = False
@@ -465,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]
@@ -564,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.2 → hwcodecdetect-0.2.4/src/HwCodecDetect.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: HwCodecDetect
-Version: 0.2.2
+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
@@ -59,8 +59,8 @@ The script automatically detect and reports on the following major hardware enco
 | Media Foundation               	       | H.264、H.265、AV1                          |
 | D3D12VA (Direct3D 12 Video Acceleration) | H.264、H.265、AV1                          |
 | VAAPI (Video Acceleration API) 	       | H.264、H.265、AV1、MJPEG、MPEG-2、VP8、VP9  |
-| Vulkan                         	       | H.264、H.265                               |
-| Apple VideoToolbox               	       | H.264、H.265                               |
+| Vulkan                         	       | H.264、H.265、AV1                          |
+| Apple VideoToolbox               	       | H.264、H.265、ProRes                       |
 
 ### Decoders
 The script automatically detect and reports on the following major hardware decoders and their supported formats:
@@ -72,7 +72,7 @@ The script automatically detect and reports on the following major hardware deco
 | 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    |
 | Vulkan                                  	| H.264、H.265、AV1                                            |
-| Apple VideoToolbox                    	| H.264、H.265、MPEG-2、MPEG-4                                 |
+| Apple VideoToolbox                    	| H.264、H.265、MPEG-2、MPEG-4、ProRes                          |
 
 ### Bit-depth and Chroma Subsampling Detection
 In addition to resolution-based testing, the tool now includes comprehensive bit-depth and chroma subsampling detection. This feature tests hardware codec support for different pixel formats, helping you understand the full capabilities of your hardware encoders and decoders.

{hwcodecdetect-0.2.2 → 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.2/VERSION

@@ -1 +0,0 @@
-0.2.2

hwcodecdetect-0.2.2/src/HwCodecDetect/version.py

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