Add Whisper GPU support via Vulkan backend

- Modified build.sh to build whispercpp with Vulkan support
- Added --audio-vulkan-device argument to specify GPU device for Whisper
- Added Vulkan detection and logging for Whisper transcription
- Set GGML_VULKAN_DEVICE environment variable for GPU selection

build.sh

@@ -135,6 +135,73 @@ elif [ "$BACKEND" = "vulkan" ]; then
     echo -e "${YELLOW}Installing Vulkan-specific requirements...${NC}"
     pip install -r requirements-vulkan.txt
     
+    # Build whispercpp Python package with Vulkan support for GPU-accelerated audio transcription
+    echo -e "${YELLOW}Building whispercpp with Vulkan support for GPU-accelerated transcription...${NC}"
+    
+    # First, uninstall any existing whispercpp (pip version doesn't have Vulkan)
+    pip uninstall -y whispercpp 2>/dev/null || true
+    
+    # Clone and build whisper.cpp with Vulkan for Python bindings
+    WHISPERCPP_DIR="$HOME/whisper.cpp"
+    if [ ! -d "$WHISPERCPP_DIR" ]; then
+        echo "Cloning whisper.cpp..."
+        git clone --depth 1 https://github.com/ggerganov/whisper.cpp "$WHISPERCPP_DIR" 2>/dev/null || {
+            echo -e "${YELLOW}Warning: Could not clone whisper.cpp${NC}"
+        }
+    fi
+    
+    if [ -d "$WHISPERCPP_DIR/bindings/python" ]; then
+        cd "$WHISPERCPP_DIR/bindings/python"
+        
+        # Build with Vulkan support
+        # Set CMAKE_ARGS to enable Vulkan for ggml (whisper uses ggml library internally)
+        CMAKE_ARGS="-DWHISPER_VULKAN=ON -DGGML_VULKAN=ON" pip install . --no-cache-dir --force-reinstall 2>/dev/null || {
+            # If Vulkan build fails, try without (will fall back to CPU)
+            echo -e "${YELLOW}Warning: whispercpp Vulkan build failed, will use CPU${NC}"
+            pip install . --no-cache-dir --force-reinstall 2>/dev/null || {
+                echo -e "${YELLOW}Warning: Could not install whispercpp at all${NC}"
+            }
+        }
+        cd "$OLDPWD"
+        echo -e "${GREEN}✓ whispercpp with Vulkan support installed!${NC}"
+    else
+        echo -e "${YELLOW}Warning: whisper.cpp Python bindings not found${NC}"
+    fi
+    
+    # Also build the main whisper.cpp C++ with Vulkan for standalone usage
+    echo -e "${YELLOW}Building whisper.cpp C++ with Vulkan support (optional)...${NC}"
+    WHISPER_DIR="$HOME/whisper.cpp"
+    if [ -d "$WHISPER_DIR" ]; then
+        echo "Using existing whisper.cpp installation"
+    else
+        echo "Cloning whisper.cpp..."
+        git clone https://github.com/ggerganov/whisper.cpp "$WHISPER_DIR" 2>/dev/null || {
+            echo -e "${YELLOW}Warning: Could not clone whisper.cpp. Audio transcription will use CPU.${NC}"
+        }
+    fi
+    
+    if [ -d "$WHISPER_DIR" ]; then
+        cd "$WHISPER_DIR"
+        mkdir -p build 2>/dev/null
+        cd build
+        cmake -DGGML_VULKAN=ON .. >/dev/null 2>&1 || {
+            echo -e "${YELLOW}Warning: Vulkan build failed, building with OpenBLAS${NC}"
+            cmake -DBUILD_SHARED_LIBS=ON .. >/dev/null 2>&1
+        }
+        make -j$(nproc) >/dev/null 2>&1 || {
+            echo -e "${YELLOW}Warning: Build failed. Audio transcription will use CPU.${NC}"
+        }
+        cd "$OLDPWD"
+        
+        if [ ! -f "$WHISPER_DIR/models/ggml-base.bin" ]; then
+            echo "Downloading Whisper base model..."
+            bash "$WHISPER_DIR/models/download-ggml-model.sh" base 2>/dev/null || {
+                echo -e "${YELLOW}Warning: Could not download Whisper model.${NC}"
+            }
+        fi
+        echo -e "${GREEN}✓ whisper.cpp ready for audio transcription!${NC}"
+    fi
+    
     echo ""
     echo -e "${GREEN}========================================${NC}"
     echo -e "${GREEN}  Vulkan build complete!${NC}"
@@ -179,6 +246,22 @@ elif [ "$BACKEND" = "vulkan-nvidia" ]; then
     echo -e "${YELLOW}Installing Vulkan-specific requirements...${NC}"
     pip install -r requirements-vulkan.txt
     
+    # Build whispercpp Python package with Vulkan support for GPU-accelerated audio transcription
+    echo -e "${YELLOW}Building whispercpp with Vulkan support for GPU-accelerated transcription...${NC}"
+    pip uninstall -y whispercpp 2>/dev/null || true
+    WHISPERCPP_DIR="$HOME/whisper.cpp"
+    if [ ! -d "$WHISPERCPP_DIR" ]; then
+        git clone --depth 1 https://github.com/ggerganov/whisper.cpp "$WHISPERCPP_DIR" 2>/dev/null || true
+    fi
+    if [ -d "$WHISPERCPP_DIR/bindings/python" ]; then
+        cd "$WHISPERCPP_DIR/bindings/python"
+        CMAKE_ARGS="-DWHISPER_VULKAN=ON -DGGML_VULKAN=ON" pip install . --no-cache-dir --force-reinstall 2>/dev/null || {
+            pip install . --no-cache-dir --force-reinstall 2>/dev/null || true
+        }
+        cd "$OLDPWD"
+        echo -e "${GREEN}✓ whispercpp with Vulkan support installed!${NC}"
+    fi
+    
     echo ""
     echo -e "${GREEN}========================================${NC}"
     echo -e "${GREEN}  Vulkan (NVIDIA-only) build complete!${NC}"

coderai

@@ -2372,6 +2372,23 @@ async def create_transcription(
         # Use configured audio model
         model_to_use = audio_model
     
+    # Check if Vulkan is available for whispercpp
+    whisper_vulkan_available = False
+    whisper_vulkan_device = os.environ.get('GGML_VULKAN_DEVICE', '0')
+    try:
+        # Check if whispercpp is installed and has Vulkan support
+        import whispercpp
+        # Try to detect Vulkan support by checking if we can list devices
+        # whispercpp doesn't have a direct Vulkan check, but we can verify by environment
+        if os.environ.get('GGML_VULKAN_DEVICE') or os.environ.get('VK_DEVICE_SELECT_DEVICE'):
+            whisper_vulkan_available = True
+            print(f"Whisper Vulkan: Using GPU device {whisper_vulkan_device}")
+        elif os.path.exists('/dev/dri'):  # Linux DRM devices exist = AMD/Intel GPU
+            whisper_vulkan_available = True
+            print(f"Whisper Vulkan: Auto-detected GPU, using device {whisper_vulkan_device}")
+    except ImportError:
+        pass
+    
     # Read file content
     file_content = await file.read()
     
@@ -2506,6 +2523,8 @@ async def create_transcription(
                 
                 if whisper_model is None:
                     print(f"Loading whispercpp model: {model_to_use}")
+                    if whisper_vulkan_available:
+                        print(f"  -> Using Vulkan GPU acceleration (device {whisper_vulkan_device})")
                     
                     # Check if model_to_use is a URL - download it (with caching)
                     model_path = None
@@ -3552,6 +3571,12 @@ def parse_args():
         default=None,
         help="Audio model GPU offload percentage (0-100). If not set, uses CPU",
     )
+    parser.add_argument(
+        "--audio-vulkan-device",
+        type=int,
+        default=0,
+        help="Vulkan GPU device ID to use for Whisper audio transcription (default: 0). Only used when using Vulkan backend.",
+    )
     parser.add_argument(
         "--vision-ctx",
         type=int,
@@ -3753,6 +3778,11 @@ def main():
     # Set up audio model if specified (with pre-loading if in loadall/loadswap mode)
     if args.audio_model:
         print(f"\nAudio transcription model: {args.audio_model}")
+        
+        # Set up Vulkan device for Whisper if using Vulkan backend
+        if hasattr(args, 'audio_vulkan_device') and args.audio_vulkan_device is not None:
+            os.environ['GGML_VULKAN_DEVICE'] = str(args.audio_vulkan_device)
+            print(f"  Using Vulkan device: {args.audio_vulkan_device}")
         multi_model_manager.set_audio_model(args.audio_model, {
             'ctx': args.audio_ctx,
             'offload': args.audio_offload,
@@ -3830,6 +3860,21 @@ def main():
             if faster_whisper_failed:
                 # Check if model is a GGUF file - whispercpp can handle those
                 model_is_gguf = model_to_use.endswith('.gguf') or (model_path and model_path.endswith('.gguf'))
+                
+                # Check if Vulkan is available for whispercpp
+                whisper_vulkan_available = False
+                whisper_vulkan_device = os.environ.get('GGML_VULKAN_DEVICE', '0')
+                try:
+                    import whispercpp
+                    if os.environ.get('GGML_VULKAN_DEVICE') or os.environ.get('VK_DEVICE_SELECT_DEVICE'):
+                        whisper_vulkan_available = True
+                        print(f"Whisper Vulkan: Will use GPU device {whisper_vulkan_device}")
+                    elif os.path.exists('/dev/dri'):
+                        whisper_vulkan_available = True
+                        print(f"Whisper Vulkan: Auto-detected GPU, will use device {whisper_vulkan_device}")
+                except ImportError:
+                    pass
+                
                 try:
                     import whispercpp
                     
@@ -3879,6 +3924,8 @@ def main():
                             model_key = f"audio:{args.audio_model}"
                             multi_model_manager.add_model(model_key, whisper_model)
                             print(f"Audio model loaded successfully (whispercpp)")
+                            if whisper_vulkan_available:
+                                print(f"  -> Using Vulkan GPU acceleration (device {whisper_vulkan_device})")
                         except Exception as e:
                             error_msg = str(e).lower()
                             if 'not a valid preconverted model' in error_msg: