plex-generate-previews 2.4.1.dev0__tar.gz → 2.5.1.dev0__tar.gz

{plex_generate_previews-2.4.1.dev0 → plex_generate_previews-2.5.1.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plex-generate-previews
-Version: 2.4.1.dev0
+Version: 2.5.1.dev0
 Summary: Generate video preview thumbnails for Plex Media Server
 Author-email: stevezau <stevezau@example.com>
 License-Expression: MIT
@@ -123,7 +123,7 @@ plex-generate-previews \
 
 ## Features
 
-- **Multi-GPU Support**: NVIDIA, AMD, Intel, and WSL2 GPUs
+- **Multi-GPU Support**: NVIDIA, AMD, Intel, and Windows GPUs
 - **Parallel Processing**: Configurable GPU and CPU worker threads
 - **Hardware Acceleration**: CUDA, VAAPI, and D3D11VA
 - **Library Filtering**: Process specific Plex libraries
@@ -144,7 +144,6 @@ plex-generate-previews \
 |----------|---------|-------|
 | **Linux** | ✅ Full | GPU + CPU support (CUDA, VAAPI, etc.) |
 | **Docker** | ✅ Full | GPU + CPU support (Recommended) |
-| **WSL2** | ✅ Full | GPU + CPU support (D3D11VA, VAAPI) |
 | **macOS** | ✅ Full | VideoToolbox + CPU support |
 | **Windows** | ✅ Full | D3D11VA GPU + CPU support |
 
@@ -158,7 +157,6 @@ plex-generate-previews \
 - **NVIDIA**: CUDA-compatible GPU + NVIDIA drivers
 - **AMD**: ROCm-compatible GPU + amdgpu drivers  
 - **Intel**: VAAPI-compatible iGPU/dGPU
-- **WSL2**: D3D11VA-compatible GPU (Intel Arc, etc.)
 
 ## Installation Options
 
@@ -197,7 +195,6 @@ docker run --rm --gpus all \
 **GPU Requirements:**
 - **NVIDIA**: Install [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html)
 - **AMD/Intel**: Mount `/dev/dri` with `--device /dev/dri:/dev/dri` (see [Troubleshooting](#troubleshooting) if you get permission errors)
-- **WSL2**: No special configuration needed - automatically detects WSL2 GPUs
 
 ### Pip Installation
 
@@ -519,8 +516,7 @@ The tool automatically detects and supports multiple GPU types with hardware acc
 | **AMD** | VAAPI | amdgpu drivers + ROCm | ✅ ROCm Docker support |
 | **Intel** | VAAPI | Intel drivers + VA-API | ✅ Device access |
 | **Apple Silicon** | VideoToolbox | macOS with FFmpeg + mediainfo | ❌ Native macOS only |
-| **WSL2 (NVIDIA)** | D3D11VA | WSL2 + /dev/dxg + mesa-utils | ✅ Native WSL2 |
-| **WSL2 (AMD)** | VAAPI | WSL2 + ROCm + /dev/dri devices | ✅ Native WSL2 |
+| **Windows** | D3D11VA | Windows with FFmpeg + latest GPU drivers | ❌ Native Windows only |
 
 ### GPU Detection
 
@@ -554,12 +550,10 @@ plex-generate-previews --gpu-selection "0"
 ### Hardware Acceleration Methods
 
 - **NVIDIA**: Uses CUDA for maximum performance
-- **AMD**: Uses VAAPI with ROCm drivers (native Linux and WSL2)
+- **AMD**: Uses VAAPI with ROCm drivers (native Linux)
 - **Intel**: Uses VAAPI (Video Acceleration API)
 - **Apple Silicon**: Uses VideoToolbox (M1/M2/M3/M4 chips on macOS)
-- **WSL2**: Automatically detects GPU type and uses appropriate acceleration:
-  - **NVIDIA GPUs**: D3D11VA via `/dev/dxg`
-  - **AMD GPUs**: VAAPI via `/dev/dri` with ROCm support
+- **Windows**: Uses D3D11VA (DirectX 11 Video Acceleration) for universal GPU support
 
 ### Docker GPU Requirements
 
@@ -582,25 +576,6 @@ services:
       - /dev/dri:/dev/dri
 ```
 
-#### WSL2
-GPU support in WSL2 uses a hybrid detection approach:
-
-**Primary Method (All Vendors):**
-- Uses DirectX acceleration (D3D11VA) via `/dev/dxg`
-- Works universally for NVIDIA, AMD, and Intel GPUs
-- No special configuration needed
-
-**Alternative Method (AMD/Intel):**
-- If Linux drivers are properly loaded, may use VAAPI via `/dev/dri`
-- Requires proper driver configuration in WSL2
-- May offer better performance but is less reliable
-
-**Important Notes:**
-- AMD GPU support in WSL2 is still evolving
-- ROCm support is limited and not officially supported by AMD in WSL2
-- The script automatically detects and uses the best available method
-- If VAAPI fails, automatically falls back to D3D11VA
-
 ## Usage Examples
 
 ### Docker Compose Examples
@@ -808,7 +783,7 @@ plex-generate-previews --log-level DEBUG
 ### General Questions
 
 **Q: What's new in version 2.0.0?**
-A: Version 2.0.0 introduces multi-GPU support, improved CLI interface, better error handling, WSL2 support, and a complete rewrite with modern Python practices.
+A: Version 2.0.0 introduces multi-GPU support, improved CLI interface, better error handling, and a complete rewrite with modern Python practices.
 
 **Q: Does this work on Windows?**
 A: Yes! Windows fully supports GPU acceleration via D3D11VA, which works with NVIDIA, AMD, and Intel GPUs. Install the latest GPU drivers and the tool will automatically detect and use your GPU for faster processing. 

{plex_generate_previews-2.4.1.dev0 → plex_generate_previews-2.5.1.dev0}/README.md

@@ -78,7 +78,7 @@ plex-generate-previews \
 
 ## Features
 
-- **Multi-GPU Support**: NVIDIA, AMD, Intel, and WSL2 GPUs
+- **Multi-GPU Support**: NVIDIA, AMD, Intel, and Windows GPUs
 - **Parallel Processing**: Configurable GPU and CPU worker threads
 - **Hardware Acceleration**: CUDA, VAAPI, and D3D11VA
 - **Library Filtering**: Process specific Plex libraries
@@ -99,7 +99,6 @@ plex-generate-previews \
 |----------|---------|-------|
 | **Linux** | ✅ Full | GPU + CPU support (CUDA, VAAPI, etc.) |
 | **Docker** | ✅ Full | GPU + CPU support (Recommended) |
-| **WSL2** | ✅ Full | GPU + CPU support (D3D11VA, VAAPI) |
 | **macOS** | ✅ Full | VideoToolbox + CPU support |
 | **Windows** | ✅ Full | D3D11VA GPU + CPU support |
 
@@ -113,7 +112,6 @@ plex-generate-previews \
 - **NVIDIA**: CUDA-compatible GPU + NVIDIA drivers
 - **AMD**: ROCm-compatible GPU + amdgpu drivers  
 - **Intel**: VAAPI-compatible iGPU/dGPU
-- **WSL2**: D3D11VA-compatible GPU (Intel Arc, etc.)
 
 ## Installation Options
 
@@ -152,7 +150,6 @@ docker run --rm --gpus all \
 **GPU Requirements:**
 - **NVIDIA**: Install [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html)
 - **AMD/Intel**: Mount `/dev/dri` with `--device /dev/dri:/dev/dri` (see [Troubleshooting](#troubleshooting) if you get permission errors)
-- **WSL2**: No special configuration needed - automatically detects WSL2 GPUs
 
 ### Pip Installation
 
@@ -474,8 +471,7 @@ The tool automatically detects and supports multiple GPU types with hardware acc
 | **AMD** | VAAPI | amdgpu drivers + ROCm | ✅ ROCm Docker support |
 | **Intel** | VAAPI | Intel drivers + VA-API | ✅ Device access |
 | **Apple Silicon** | VideoToolbox | macOS with FFmpeg + mediainfo | ❌ Native macOS only |
-| **WSL2 (NVIDIA)** | D3D11VA | WSL2 + /dev/dxg + mesa-utils | ✅ Native WSL2 |
-| **WSL2 (AMD)** | VAAPI | WSL2 + ROCm + /dev/dri devices | ✅ Native WSL2 |
+| **Windows** | D3D11VA | Windows with FFmpeg + latest GPU drivers | ❌ Native Windows only |
 
 ### GPU Detection
 
@@ -509,12 +505,10 @@ plex-generate-previews --gpu-selection "0"
 ### Hardware Acceleration Methods
 
 - **NVIDIA**: Uses CUDA for maximum performance
-- **AMD**: Uses VAAPI with ROCm drivers (native Linux and WSL2)
+- **AMD**: Uses VAAPI with ROCm drivers (native Linux)
 - **Intel**: Uses VAAPI (Video Acceleration API)
 - **Apple Silicon**: Uses VideoToolbox (M1/M2/M3/M4 chips on macOS)
-- **WSL2**: Automatically detects GPU type and uses appropriate acceleration:
-  - **NVIDIA GPUs**: D3D11VA via `/dev/dxg`
-  - **AMD GPUs**: VAAPI via `/dev/dri` with ROCm support
+- **Windows**: Uses D3D11VA (DirectX 11 Video Acceleration) for universal GPU support
 
 ### Docker GPU Requirements
 
@@ -537,25 +531,6 @@ services:
       - /dev/dri:/dev/dri
 ```
 
-#### WSL2
-GPU support in WSL2 uses a hybrid detection approach:
-
-**Primary Method (All Vendors):**
-- Uses DirectX acceleration (D3D11VA) via `/dev/dxg`
-- Works universally for NVIDIA, AMD, and Intel GPUs
-- No special configuration needed
-
-**Alternative Method (AMD/Intel):**
-- If Linux drivers are properly loaded, may use VAAPI via `/dev/dri`
-- Requires proper driver configuration in WSL2
-- May offer better performance but is less reliable
-
-**Important Notes:**
-- AMD GPU support in WSL2 is still evolving
-- ROCm support is limited and not officially supported by AMD in WSL2
-- The script automatically detects and uses the best available method
-- If VAAPI fails, automatically falls back to D3D11VA
-
 ## Usage Examples
 
 ### Docker Compose Examples
@@ -763,7 +738,7 @@ plex-generate-previews --log-level DEBUG
 ### General Questions
 
 **Q: What's new in version 2.0.0?**
-A: Version 2.0.0 introduces multi-GPU support, improved CLI interface, better error handling, WSL2 support, and a complete rewrite with modern Python practices.
+A: Version 2.0.0 introduces multi-GPU support, improved CLI interface, better error handling, and a complete rewrite with modern Python practices.
 
 **Q: Does this work on Windows?**
 A: Yes! Windows fully supports GPU acceleration via D3D11VA, which works with NVIDIA, AMD, and Intel GPUs. Install the latest GPU drivers and the tool will automatically detect and use your GPU for faster processing. 

{plex_generate_previews-2.4.1.dev0 → plex_generate_previews-2.5.1.dev0}/plex_generate_previews/__init__.py

@@ -2,7 +2,7 @@
 Plex Video Preview Generator
 
 A tool for generating video preview thumbnails for Plex Media Server.
-Supports GPU acceleration (NVIDIA, AMD, Intel, WSL2) and CPU processing.
+Supports GPU acceleration (NVIDIA, AMD, Intel, Windows) and CPU processing.
 """
 
 import os

{plex_generate_previews-2.4.1.dev0 → plex_generate_previews-2.5.1.dev0}/plex_generate_previews/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.4.1.dev0'
-__version_tuple__ = version_tuple = (2, 4, 1, 'dev0')
+__version__ = version = '2.5.1.dev0'
+__version_tuple__ = version_tuple = (2, 5, 1, 'dev0')
 
-__commit_id__ = commit_id = 'g54c2ef484'
+__commit_id__ = commit_id = 'g5762a5480'

{plex_generate_previews-2.4.1.dev0 → plex_generate_previews-2.5.1.dev0}/plex_generate_previews/gpu_detection.py

@@ -2,7 +2,7 @@
 GPU detection for video processing acceleration.
 
 Detects available GPU hardware and returns appropriate configuration
-for FFmpeg hardware acceleration. Supports NVIDIA, AMD, Intel, Apple (macOS), and WSL2 GPUs.
+for FFmpeg hardware acceleration. Supports NVIDIA, AMD, Intel, Apple (macOS), and Windows GPUs.
 """
 
 import os
@@ -54,12 +54,6 @@ GPU_ACCELERATION_MAP = {
         'requires_runtime': False,
         'test_encoder': None  # Use hwaccel test instead
     },
-    'WSL2': {
-        'primary': 'D3D11VA',
-        'fallback': None,
-        'requires_runtime': False,
-        'test_encoder': None  # Use hwaccel test instead
-    },
     'WINDOWS_GPU': {
         'primary': 'D3D11VA',
         'fallback': None,
@@ -377,31 +371,6 @@ def _test_hwaccel_functionality(hwaccel: str, device_path: Optional[str] = None)
         return False
 
 
-def _is_wsl2() -> bool:
-    """
-    Detect if running in WSL2 by checking for /dev/dxg device.
-    
-    Per Microsoft's documentation, /dev/dxg is the WSL2 GPU passthrough device
-    exposed by the dxgkrnl driver.
-    
-    Reference: https://devblogs.microsoft.com/directx/directx-heart-linux/
-    
-    Returns:
-        bool: True if running in WSL2 with GPU support
-    """
-    return os.path.exists('/dev/dxg')
-
-
-def _detect_rocm_gpu() -> bool:
-    """
-    Detect if ROCm (AMD GPU runtime) is available in WSL2.
-    
-    Checks for /dev/kfd (Kernel Fusion Driver) which is the ROCm device.
-    
-    Returns:
-        bool: True if ROCm device is available
-    """
-    return os.path.exists('/dev/kfd')
 
 
 def _is_macos() -> bool:
@@ -416,7 +385,7 @@ def _is_macos() -> bool:
 
 def _is_windows() -> bool:
     """
-    Detect if running on native Windows (not WSL2).
+    Detect if running on native Windows.
     
     Returns:
         bool: True if running on Windows
@@ -444,8 +413,7 @@ def _detect_windows_d3d11va() -> Optional[Tuple[str, str, Dict[str, Any]]]:
         gpu_info = {
             'name': 'Windows GPU',
             'acceleration': 'D3D11VA',
-            'device_path': 'd3d11va',
-            'wsl2': False
+            'device_path': 'd3d11va'
         }
         logger.debug("✓ Windows D3D11VA hardware acceleration is working")
         return ('WINDOWS_GPU', 'd3d11va', gpu_info)
@@ -554,58 +522,6 @@ def _get_gpu_devices() -> List[Tuple[str, str, str]]:
     return devices
 
 
-def _get_wsl2_render_devices() -> List[Tuple[str, str, str]]:
-    """
-    Fallback GPU detection for WSL2 when /sys/class/drm enumeration fails.
-    
-    In WSL2, especially with AMD GPUs, /sys/class/drm may not properly enumerate
-    devices, but render devices might still exist in /dev/dri. This function
-    directly checks for render devices and attempts to identify their vendor.
-    
-    Returns:
-        List[Tuple[str, str, str]]: List of (card_name, render_device, driver) tuples
-    """
-    devices = []
-    dri_dir = "/dev/dri"
-    
-    if not os.path.exists(dri_dir):
-        logger.debug(f"DRI directory {dri_dir} does not exist")
-        return devices
-    
-    try:
-        entries = os.listdir(dri_dir)
-        render_devices = [e for e in entries if e.startswith("renderD")]
-        
-        if not render_devices:
-            logger.debug("No render devices found in /dev/dri")
-            return devices
-        
-        logger.debug(f"Found render devices in WSL2: {render_devices}")
-        
-        for render_device_name in sorted(render_devices):
-            render_device_path = f"/dev/dri/{render_device_name}"
-            
-            # Try to determine vendor using lspci
-            vendor = _detect_gpu_type_from_lspci()
-            if vendor == 'UNKNOWN':
-                # Check if ROCm is available (indicates AMD GPU)
-                if _detect_rocm_gpu():
-                    vendor = 'AMD'
-                    logger.debug(f"Detected AMD GPU via ROCm for {render_device_path}")
-                else:
-                    vendor = 'amdgpu'  # fallback to amdgpu driver name
-            
-            # Create a synthetic card name
-            card_name = f"wsl2-{render_device_name}"
-            driver = vendor.lower()
-            
-            devices.append((card_name, render_device_path, driver))
-            logger.debug(f"WSL2 GPU detected: {card_name} -> {render_device_path} (driver: {driver})")
-    
-    except Exception as e:
-        logger.debug(f"Error detecting WSL2 render devices: {e}")
-    
-    return devices
 
 
 def _get_gpu_vendor_from_driver(driver_name: str) -> str:
@@ -734,10 +650,6 @@ def _log_system_info() -> None:
     logger.debug(f"Python version: {platform.python_version()}")
     logger.debug(f"FFmpeg path: {os.environ.get('FFMPEG_PATH', 'ffmpeg')}")
     
-    # Check for WSL2
-    if _is_wsl2():
-        logger.debug("Running in WSL2 (detected /dev/dxg device)")
-    
     # Check FFmpeg version
     _check_ffmpeg_version()
     
@@ -793,7 +705,7 @@ def get_gpu_name(gpu_type: str, gpu_device: str) -> str:
     Extract GPU model name from system.
     
     Args:
-        gpu_type: Type of GPU ('NVIDIA', 'AMD', 'INTEL', 'WSL2', 'APPLE')
+        gpu_type: Type of GPU ('NVIDIA', 'AMD', 'INTEL', 'APPLE')
         gpu_device: GPU device path or info string
         
     Returns:
@@ -810,12 +722,12 @@ def get_gpu_name(gpu_type: str, gpu_device: str) -> str:
                     return gpu_names[0]  # Return first GPU name
             return "NVIDIA GPU"
             
-        elif gpu_type == 'WSL2':
-            return "WSL2 GPU"
-            
         elif gpu_type == 'APPLE':
             return _get_apple_gpu_name()
             
+        elif gpu_type == 'WINDOWS_GPU':
+            return "Windows GPU"
+            
         elif gpu_type in ('AMD', 'INTEL') and gpu_device.startswith('/dev/dri/'):
             # Try to get GPU info from lspci
             gpu_name = _parse_lspci_gpu_name(gpu_type)
@@ -851,8 +763,6 @@ def format_gpu_info(gpu_type: str, gpu_device: str, gpu_name: str, acceleration:
     # Fallback to old logic for backward compatibility
     if gpu_type == 'NVIDIA':
         return f"{gpu_name} (CUDA)"
-    elif gpu_type == 'WSL2':
-        return f"{gpu_name} (D3D11VA)"
     elif gpu_type == 'WINDOWS_GPU':
         return f"{gpu_name} (D3D11VA - Universal Windows GPU)"
     elif gpu_type == 'APPLE':
@@ -865,7 +775,7 @@ def format_gpu_info(gpu_type: str, gpu_device: str, gpu_name: str, acceleration:
         return f"{gpu_name} ({gpu_type})"
 
 
-def _test_acceleration_method(vendor: str, acceleration: str, device_path: Optional[str] = None, is_wsl2: bool = False) -> bool:
+def _test_acceleration_method(vendor: str, acceleration: str, device_path: Optional[str] = None) -> bool:
     """
     Test if a specific acceleration method works for a GPU vendor.
     
@@ -873,7 +783,6 @@ def _test_acceleration_method(vendor: str, acceleration: str, device_path: Optio
         vendor: GPU vendor ('NVIDIA', 'AMD', 'INTEL', etc.)
         acceleration: Acceleration method ('CUDA', 'VAAPI', 'D3D11VA', etc.)
         device_path: Device path for VAAPI (e.g., '/dev/dri/renderD128'), or 'cuda' for NVIDIA
-        is_wsl2: Whether running in WSL2 environment
         
     Returns:
         bool: True if acceleration method works
@@ -908,16 +817,12 @@ def _test_acceleration_method(vendor: str, acceleration: str, device_path: Optio
         logger.debug(f"Unknown acceleration method: {acceleration}")
         return False
     
-    # In WSL2, be more lenient with test failures
-    if test_passed or is_wsl2:
-        if test_passed:
-            logger.debug(f"✓ {vendor} {acceleration} hardware acceleration test passed")
-        else:
-            logger.debug(f"✓ {vendor} {acceleration} available in WSL2 (functionality test skipped)")
-        return True
+    # Return test result
+    if test_passed:
+        logger.debug(f"✓ {vendor} {acceleration} hardware acceleration test passed")
     else:
         logger.debug(f"✗ {vendor} {acceleration} functionality test failed")
-        return False
+    return test_passed
 
 
 def detect_all_gpus() -> List[Tuple[str, str, dict]]:
@@ -929,7 +834,7 @@ def detect_all_gpus() -> List[Tuple[str, str, dict]]:
     
     Returns:
         List[Tuple[str, str, dict]]: List of (gpu_type, gpu_device, gpu_info_dict)
-            - gpu_type: 'NVIDIA', 'AMD', 'INTEL', 'WSL2'
+            - gpu_type: 'NVIDIA', 'AMD', 'INTEL', 'APPLE', 'WINDOWS_GPU'
             - gpu_device: Device path or info string
             - gpu_info_dict: Dictionary with GPU details (name, vram, etc.)
     """
@@ -939,11 +844,6 @@ def detect_all_gpus() -> List[Tuple[str, str, dict]]:
     detected_gpus = []
     detected_vendors = set()  # Track which vendors we've already detected
     
-    # Detect if running in WSL2 - makes detection more lenient
-    is_wsl2 = _is_wsl2()
-    if is_wsl2:
-        logger.debug("Detected WSL2 environment (/dev/dxg present) - GPU functionality tests may be skipped")
-    
     # Step 1: Enumerate physical GPUs from /dev/dri (Linux only)
     logger.debug("=== Enumerating Physical GPUs ===")
     physical_gpus = _get_gpu_devices()  # Returns: [(card_name, render_device, driver)]
@@ -952,14 +852,6 @@ def detect_all_gpus() -> List[Tuple[str, str, dict]]:
     if platform.system() == 'Linux':
         if not physical_gpus:
             logger.debug("No physical GPUs found in /dev/dri")
-            # In WSL2, try fallback detection for render devices
-            if is_wsl2:
-                logger.debug("WSL2 detected - trying fallback render device detection")
-                physical_gpus = _get_wsl2_render_devices()
-                if physical_gpus:
-                    logger.debug(f"Found {len(physical_gpus)} GPU(s) via WSL2 fallback detection")
-                    for card_name, render_device, driver in physical_gpus:
-                        logger.debug(f"  {card_name}: {render_device} (driver: {driver})")
         else:
             logger.debug(f"Found {len(physical_gpus)} physical GPU(s) in /dev/dri")
             for card_name, render_device, driver in physical_gpus:
@@ -992,14 +884,13 @@ def detect_all_gpus() -> List[Tuple[str, str, dict]]:
         # Test primary acceleration method
         logger.debug(f"  Testing primary method: {primary_method}")
         logger.info(f"    Testing {primary_method} acceleration...")
-        if _test_acceleration_method(vendor, primary_method, device_path, is_wsl2):
+        if _test_acceleration_method(vendor, primary_method, device_path):
             gpu_name = get_gpu_name(vendor, device_path)
             gpu_info = {
                 'name': gpu_name,
                 'acceleration': primary_method,
                 'device_path': device_path,
                 'render_device': render_device,  # Store the actual /dev/dri device
-                'wsl2': is_wsl2,
                 'card': card_name,
                 'driver': driver
             }
@@ -1023,14 +914,13 @@ def detect_all_gpus() -> List[Tuple[str, str, dict]]:
             logger.info(f"    Testing fallback {fallback_method} acceleration...")
             fallback_device_path = render_device if fallback_method == 'VAAPI' else device_path
             
-            if _test_acceleration_method(vendor, fallback_method, fallback_device_path, is_wsl2):
+            if _test_acceleration_method(vendor, fallback_method, fallback_device_path):
                 gpu_name = get_gpu_name(vendor, fallback_device_path)
                 gpu_info = {
                     'name': gpu_name,
                     'acceleration': fallback_method,
                     'device_path': fallback_device_path,
                     'render_device': render_device,
-                    'wsl2': is_wsl2,
                     'card': card_name,
                     'driver': driver
                 }
@@ -1042,47 +932,21 @@ def detect_all_gpus() -> List[Tuple[str, str, dict]]:
         else:
             logger.warning(f"  ❌ {card_name}: No fallback available, GPU unusable")
     
-    # Step 3: Check for WSL2 D3D11VA (doesn't show up as physical GPU)
-    if is_wsl2:
-        logger.debug("Testing WSL2 D3D11VA acceleration...")
-        logger.info("  Checking WSL2 GPU...")
-        logger.info("    Testing D3D11VA acceleration...")
-        if _test_acceleration_method('WSL2', 'D3D11VA', 'd3d11va', is_wsl2):
-            # Try to identify actual GPU for better naming
-            gpu_vendor = _detect_gpu_type_from_lspci()
-            if gpu_vendor != 'UNKNOWN':
-                gpu_name = f"{gpu_vendor} GPU (WSL2 DirectX)"
-            else:
-                gpu_name = "WSL2 GPU (DirectX)"
-            
-            gpu_info = {
-                'name': gpu_name,
-                'acceleration': 'D3D11VA',
-                'device_path': 'd3d11va',
-                'wsl2': is_wsl2
-            }
-            detected_gpus.append(('WSL2', 'd3d11va', gpu_info))
-            logger.info(f"  ✅ {gpu_name} working")
-            logger.info("  💡 Using DirectX acceleration (universal WSL2 method)")
-            if gpu_vendor == 'AMD':
-                logger.info("  💡 Note: AMD GPUs in WSL2 may have better performance with native Linux drivers")
-                logger.info("      if properly configured, but DirectX acceleration is working.")
-    
-    # Native Windows: try D3D11VA if ffmpeg reports it, even without /dev/dxg
+    # Step 3: Native Windows - try D3D11VA if ffmpeg reports it
     if platform.system() == 'Windows':
         hwaccels = _get_ffmpeg_hwaccels()
         logger.debug(f"Windows platform detected; FFmpeg hwaccels: {hwaccels}")
         if 'd3d11va' in hwaccels:
             logger.info("  Checking Windows D3D11VA GPU...")
             logger.info("    Testing D3D11VA acceleration...")
-            if _test_acceleration_method('WSL2', 'D3D11VA', 'd3d11va', False):
+            if _test_acceleration_method('WINDOWS_GPU', 'D3D11VA', 'd3d11va'):
                 gpu_name = "Windows GPU"
                 gpu_info = {
                     'name': gpu_name,
                     'acceleration': 'D3D11VA',
                     'device_path': 'd3d11va',
                 }
-                detected_gpus.append(('WSL2', 'd3d11va', gpu_info))
+                detected_gpus.append(('WINDOWS_GPU', 'd3d11va', gpu_info))
                 logger.info("  ✅ Windows D3D11VA working")
         else:
             logger.debug("d3d11va not reported by FFmpeg; skipping Windows D3D11VA probe")
@@ -1092,13 +956,12 @@ def detect_all_gpus() -> List[Tuple[str, str, dict]]:
         logger.debug("Detected macOS platform, testing VideoToolbox acceleration...")
         logger.info("  Checking Apple GPU...")
         logger.info("    Testing VideoToolbox acceleration...")
-        if _test_acceleration_method('APPLE', 'VIDEOTOOLBOX', 'videotoolbox', False):
+        if _test_acceleration_method('APPLE', 'VIDEOTOOLBOX', 'videotoolbox'):
             gpu_name = get_gpu_name('APPLE', 'videotoolbox')
             gpu_info = {
                 'name': gpu_name,
                 'acceleration': 'VIDEOTOOLBOX',
-                'device_path': 'videotoolbox',
-                'wsl2': False
+                'device_path': 'videotoolbox'
             }
             detected_gpus.append(('APPLE', 'videotoolbox', gpu_info))
             logger.info("  ✅ Apple VideoToolbox working")

{plex_generate_previews-2.4.1.dev0 → plex_generate_previews-2.5.1.dev0}/plex_generate_previews/media_processing.py

@@ -153,7 +153,7 @@ def generate_images(video_file: str, output_folder: str, gpu: Optional[str],
     Args:
         video_file: Path to input video file
         output_folder: Directory where thumbnail images will be written
-        gpu: GPU type ('NVIDIA', 'AMD', 'INTEL', 'WSL2', 'APPLE', or None)
+        gpu: GPU type ('NVIDIA', 'AMD', 'INTEL', 'WINDOWS_GPU', 'APPLE', or None)
         gpu_device_path: GPU device path (e.g., '/dev/dri/renderD128' for VAAPI)
         config: Configuration object
         progress_callback: Optional progress callback for UI updates
@@ -194,7 +194,7 @@ def generate_images(video_file: str, output_folder: str, gpu: Optional[str],
             hw_local = True
             if gpu == 'NVIDIA':
                 args += ["-hwaccel", "cuda"]
-            elif gpu == 'WSL2' or gpu == 'WINDOWS_GPU':
+            elif gpu == 'WINDOWS_GPU':
                 args += ["-hwaccel", "d3d11va"]
             elif gpu == 'APPLE':
                 args += ["-hwaccel", "videotoolbox"]

{plex_generate_previews-2.4.1.dev0 → plex_generate_previews-2.5.1.dev0}/plex_generate_previews.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plex-generate-previews
-Version: 2.4.1.dev0
+Version: 2.5.1.dev0
 Summary: Generate video preview thumbnails for Plex Media Server
 Author-email: stevezau <stevezau@example.com>
 License-Expression: MIT
@@ -123,7 +123,7 @@ plex-generate-previews \
 
 ## Features
 
-- **Multi-GPU Support**: NVIDIA, AMD, Intel, and WSL2 GPUs
+- **Multi-GPU Support**: NVIDIA, AMD, Intel, and Windows GPUs
 - **Parallel Processing**: Configurable GPU and CPU worker threads
 - **Hardware Acceleration**: CUDA, VAAPI, and D3D11VA
 - **Library Filtering**: Process specific Plex libraries
@@ -144,7 +144,6 @@ plex-generate-previews \
 |----------|---------|-------|
 | **Linux** | ✅ Full | GPU + CPU support (CUDA, VAAPI, etc.) |
 | **Docker** | ✅ Full | GPU + CPU support (Recommended) |
-| **WSL2** | ✅ Full | GPU + CPU support (D3D11VA, VAAPI) |
 | **macOS** | ✅ Full | VideoToolbox + CPU support |
 | **Windows** | ✅ Full | D3D11VA GPU + CPU support |
 
@@ -158,7 +157,6 @@ plex-generate-previews \
 - **NVIDIA**: CUDA-compatible GPU + NVIDIA drivers
 - **AMD**: ROCm-compatible GPU + amdgpu drivers  
 - **Intel**: VAAPI-compatible iGPU/dGPU
-- **WSL2**: D3D11VA-compatible GPU (Intel Arc, etc.)
 
 ## Installation Options
 
@@ -197,7 +195,6 @@ docker run --rm --gpus all \
 **GPU Requirements:**
 - **NVIDIA**: Install [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html)
 - **AMD/Intel**: Mount `/dev/dri` with `--device /dev/dri:/dev/dri` (see [Troubleshooting](#troubleshooting) if you get permission errors)
-- **WSL2**: No special configuration needed - automatically detects WSL2 GPUs
 
 ### Pip Installation
 
@@ -519,8 +516,7 @@ The tool automatically detects and supports multiple GPU types with hardware acc
 | **AMD** | VAAPI | amdgpu drivers + ROCm | ✅ ROCm Docker support |
 | **Intel** | VAAPI | Intel drivers + VA-API | ✅ Device access |
 | **Apple Silicon** | VideoToolbox | macOS with FFmpeg + mediainfo | ❌ Native macOS only |
-| **WSL2 (NVIDIA)** | D3D11VA | WSL2 + /dev/dxg + mesa-utils | ✅ Native WSL2 |
-| **WSL2 (AMD)** | VAAPI | WSL2 + ROCm + /dev/dri devices | ✅ Native WSL2 |
+| **Windows** | D3D11VA | Windows with FFmpeg + latest GPU drivers | ❌ Native Windows only |
 
 ### GPU Detection
 
@@ -554,12 +550,10 @@ plex-generate-previews --gpu-selection "0"
 ### Hardware Acceleration Methods
 
 - **NVIDIA**: Uses CUDA for maximum performance
-- **AMD**: Uses VAAPI with ROCm drivers (native Linux and WSL2)
+- **AMD**: Uses VAAPI with ROCm drivers (native Linux)
 - **Intel**: Uses VAAPI (Video Acceleration API)
 - **Apple Silicon**: Uses VideoToolbox (M1/M2/M3/M4 chips on macOS)
-- **WSL2**: Automatically detects GPU type and uses appropriate acceleration:
-  - **NVIDIA GPUs**: D3D11VA via `/dev/dxg`
-  - **AMD GPUs**: VAAPI via `/dev/dri` with ROCm support
+- **Windows**: Uses D3D11VA (DirectX 11 Video Acceleration) for universal GPU support
 
 ### Docker GPU Requirements
 
@@ -582,25 +576,6 @@ services:
       - /dev/dri:/dev/dri
 ```
 
-#### WSL2
-GPU support in WSL2 uses a hybrid detection approach:
-
-**Primary Method (All Vendors):**
-- Uses DirectX acceleration (D3D11VA) via `/dev/dxg`
-- Works universally for NVIDIA, AMD, and Intel GPUs
-- No special configuration needed
-
-**Alternative Method (AMD/Intel):**
-- If Linux drivers are properly loaded, may use VAAPI via `/dev/dri`
-- Requires proper driver configuration in WSL2
-- May offer better performance but is less reliable
-
-**Important Notes:**
-- AMD GPU support in WSL2 is still evolving
-- ROCm support is limited and not officially supported by AMD in WSL2
-- The script automatically detects and uses the best available method
-- If VAAPI fails, automatically falls back to D3D11VA
-
 ## Usage Examples
 
 ### Docker Compose Examples
@@ -808,7 +783,7 @@ plex-generate-previews --log-level DEBUG
 ### General Questions
 
 **Q: What's new in version 2.0.0?**
-A: Version 2.0.0 introduces multi-GPU support, improved CLI interface, better error handling, WSL2 support, and a complete rewrite with modern Python practices.
+A: Version 2.0.0 introduces multi-GPU support, improved CLI interface, better error handling, and a complete rewrite with modern Python practices.
 
 **Q: Does this work on Windows?**
 A: Yes! Windows fully supports GPU acceleration via D3D11VA, which works with NVIDIA, AMD, and Intel GPUs. Install the latest GPU drivers and the tool will automatically detect and use your GPU for faster processing. 

{plex_generate_previews-2.4.1.dev0 → plex_generate_previews-2.5.1.dev0}/tests/test_gpu_detection_extended.py

@@ -15,9 +15,7 @@ from plex_generate_previews.gpu_detection import (
     _get_gpu_devices,
     _determine_vaapi_gpu_type,
     get_gpu_name,
-    _get_ffmpeg_hwaccels,
-    _get_wsl2_render_devices,
-    _detect_rocm_gpu
+    _get_ffmpeg_hwaccels
 )
 
 
@@ -80,9 +78,8 @@ class TestDetectAllGPUs:
     def test_detect_all_gpus_none(self, mock_devices):
         """Test when no GPUs are detected."""
         mock_devices.return_value = []
-        # Ensure platform-specific paths (macOS/WSL2) are not taken in this test
+        # Ensure platform-specific paths (macOS) are not taken in this test
         with patch('plex_generate_previews.gpu_detection._is_macos', return_value=False), \
-             patch('plex_generate_previews.gpu_detection._is_wsl2', return_value=False), \
              patch('plex_generate_previews.gpu_detection._get_ffmpeg_hwaccels', return_value=[]):
             gpus = detect_all_gpus()
         
@@ -394,11 +391,11 @@ class TestGetGPUName:
         assert 'NVIDIA' in name
         assert 'GPU' in name
     
-    def test_get_gpu_name_wsl2(self):
-        """Test WSL2 GPU name."""
-        name = get_gpu_name('WSL2', 'd3d11va')
+    def test_get_gpu_name_windows(self):
+        """Test Windows GPU name."""
+        name = get_gpu_name('WINDOWS_GPU', 'd3d11va')
         
-        assert 'WSL2' in name
+        assert 'Windows' in name
         assert 'GPU' in name
     
     @patch('subprocess.run')
@@ -457,113 +454,6 @@ d3d11va
         assert hwaccels == []
 
 
-class TestWSL2AMDGPUDetection:
-    """Test WSL2 AMD GPU detection functionality."""
-    
-    @patch('os.path.exists')
-    def test_detect_rocm_gpu_available(self, mock_exists):
-        """Test ROCm GPU detection when /dev/kfd exists."""
-        mock_exists.return_value = True
-        
-        result = _detect_rocm_gpu()
-        
-        assert result is True
-        mock_exists.assert_called_with('/dev/kfd')
-    
-    @patch('os.path.exists')
-    def test_detect_rocm_gpu_not_available(self, mock_exists):
-        """Test ROCm GPU detection when /dev/kfd doesn't exist."""
-        mock_exists.return_value = False
-        
-        result = _detect_rocm_gpu()
-        
-        assert result is False
-        mock_exists.assert_called_with('/dev/kfd')
-    
-    @patch('plex_generate_previews.gpu_detection._detect_gpu_type_from_lspci')
-    @patch('plex_generate_previews.gpu_detection._detect_rocm_gpu')
-    @patch('os.listdir')
-    @patch('os.path.exists')
-    def test_get_wsl2_render_devices_amd_with_rocm(self, mock_exists, mock_listdir, 
-                                                     mock_rocm, mock_lspci):
-        """Test WSL2 render device detection with AMD GPU and ROCm."""
-        mock_exists.return_value = True
-        mock_listdir.return_value = ['renderD128', 'card0']
-        mock_lspci.return_value = 'UNKNOWN'
-        mock_rocm.return_value = True
-        
-        devices = _get_wsl2_render_devices()
-        
-        assert len(devices) == 1
-        assert devices[0][0] == 'wsl2-renderD128'
-        assert devices[0][1] == '/dev/dri/renderD128'
-        assert devices[0][2] == 'amd'
-    
-    @patch('plex_generate_previews.gpu_detection._detect_gpu_type_from_lspci')
-    @patch('plex_generate_previews.gpu_detection._detect_rocm_gpu')
-    @patch('os.listdir')
-    @patch('os.path.exists')
-    def test_get_wsl2_render_devices_amd_via_lspci(self, mock_exists, mock_listdir, 
-                                                     mock_rocm, mock_lspci):
-        """Test WSL2 render device detection with AMD GPU detected via lspci."""
-        mock_exists.return_value = True
-        mock_listdir.return_value = ['renderD128']
-        mock_lspci.return_value = 'AMD'
-        mock_rocm.return_value = False
-        
-        devices = _get_wsl2_render_devices()
-        
-        assert len(devices) == 1
-        assert devices[0][0] == 'wsl2-renderD128'
-        assert devices[0][1] == '/dev/dri/renderD128'
-        assert devices[0][2] == 'amd'
-    
-    @patch('os.path.exists')
-    def test_get_wsl2_render_devices_no_dri(self, mock_exists):
-        """Test WSL2 render device detection when /dev/dri doesn't exist."""
-        mock_exists.return_value = False
-        
-        devices = _get_wsl2_render_devices()
-        
-        assert devices == []
-    
-    @patch('os.listdir')
-    @patch('os.path.exists')
-    def test_get_wsl2_render_devices_no_render_devices(self, mock_exists, mock_listdir):
-        """Test WSL2 render device detection when no render devices exist."""
-        mock_exists.return_value = True
-        mock_listdir.return_value = ['card0', 'card1']
-        
-        devices = _get_wsl2_render_devices()
-        
-        assert devices == []
-    
-    @patch('plex_generate_previews.gpu_detection._get_wsl2_render_devices')
-    @patch('plex_generate_previews.gpu_detection._test_acceleration_method')
-    @patch('plex_generate_previews.gpu_detection._get_gpu_devices')
-    @patch('plex_generate_previews.gpu_detection._is_wsl2')
-    @patch('plex_generate_previews.gpu_detection.get_gpu_name')
-    def test_detect_all_gpus_wsl2_amd_fallback(self, mock_name, mock_wsl2, 
-                                                 mock_devices, mock_test, mock_wsl2_devices):
-        """Test full GPU detection in WSL2 with AMD GPU using fallback detection."""
-        # Simulate WSL2 environment with no /sys/class/drm enumeration
-        mock_wsl2.return_value = True
-        mock_devices.return_value = []  # No devices from standard enumeration
-        mock_wsl2_devices.return_value = [('wsl2-renderD128', '/dev/dri/renderD128', 'amdgpu')]
-        mock_test.return_value = True
-        mock_name.return_value = 'AMD Radeon RX 7900 XT'
-        # Force Linux path so fallback WSL2 detection is exercised
-        with patch('plex_generate_previews.gpu_detection.platform.system', return_value='Linux'):
-            gpus = detect_all_gpus()
-        
-        # Should detect AMD GPU via WSL2 fallback
-        amd_gpus = [g for g in gpus if g[0] == 'AMD']
-        assert len(amd_gpus) > 0
-        assert 'RX 7900 XT' in amd_gpus[0][2]['name']
-        assert amd_gpus[0][2]['acceleration'] == 'VAAPI'
-        assert amd_gpus[0][1] == '/dev/dri/renderD128'
-
-
 class TestFFmpegVersion:
     """Test FFmpeg version detection."""
     
@@ -811,7 +701,7 @@ class TestAccelerationMethodTesting:
         
         mock_test.return_value = False
         
-        result = _test_acceleration_method('nvidia', 'CUDA', None, False)
+        result = _test_acceleration_method('nvidia', 'CUDA', None)
         assert result is False
     
     @patch('plex_generate_previews.gpu_detection._test_hwaccel_functionality')
@@ -821,7 +711,7 @@ class TestAccelerationMethodTesting:
         
         mock_test.return_value = False
         
-        result = _test_acceleration_method('amd', 'VAAPI', '/dev/dri/renderD128', False)
+        result = _test_acceleration_method('amd', 'VAAPI', '/dev/dri/renderD128')
         assert result is False
 
 
@@ -854,7 +744,7 @@ class TestDetectAllGPUsEdgeCases:
         mock_is_macos.return_value = False
         mock_devices.return_value = [('card0', '/dev/dri/renderD128', 'nvidia')]
         
-        def test_side_effect(vendor, accel, device, is_wsl2):
+        def test_side_effect(vendor, accel, device):
             if accel == 'CUDA':
                 return True
             elif accel == 'NVENC':