obs-virtual-camera-toggle.sh

#!/bin/bash
# Virtual Camera Toggle with RVM Background Removal
# Press Super+O to start/stop OBS virtual camera with AI background removal
#
# Flow: Webcam → RVM (background removal) → OBS (virtual cam output)

set -e

LOCK_FILE="/tmp/obs-virtual-camera.lock"
RVM_LOCK_FILE="/tmp/rvm-camera.lock"
NOTIFICATION_ICON="camera-web"

# RVM Camera settings (set RVM_CAMERA_SCRIPT env var to override)
RVM_SCRIPT="${RVM_CAMERA_SCRIPT:-rvm_camera.py}"
RVM_BACKGROUND="0,255,0"  # Chroma key green for OBS

# Function to show notification
notify() {
    local title="$1"
    local message="$2"
    local icon="${3:-$NOTIFICATION_ICON}"
    notify-send -i "$icon" "$title" "$message" 2>/dev/null || true
}

# Check if OBS is running
is_obs_running() {
    pgrep -x "obs" > /dev/null 2>&1
}

# Check if RVM camera is running
is_rvm_running() {
    pgrep -f "rvm_camera.py" > /dev/null 2>&1
}

# Check if virtual camera is active
is_virtual_camera_active() {
    fuser /dev/video10 2>/dev/null | grep -q "." 2>/dev/null
}

# Get OBS PID from lock file or pgrep
get_obs_pid() {
    if [ -f "$LOCK_FILE" ]; then
        cat "$LOCK_FILE"
    else
        pgrep -x "obs" | head -1
    fi
}

# Get RVM PID from lock file or pgrep
get_rvm_pid() {
    if [ -f "$RVM_LOCK_FILE" ]; then
        cat "$RVM_LOCK_FILE"
    else
        pgrep -f "rvm_camera.py" | head -1
    fi
}

# Start RVM camera (background removal)
start_rvm_camera() {
    echo "Starting RVM background removal..."

    # Start RVM camera in background
    python3 "$RVM_SCRIPT" --background "$RVM_BACKGROUND" > /tmp/rvm-camera.log 2>&1 &
    RVM_PID=$!

    # Save PID to lock file
    echo "$RVM_PID" > "$RVM_LOCK_FILE"

    # Wait for RVM to initialize (model loading takes ~2-3 seconds)
    echo "Waiting for RVM to initialize..."
    for i in {1..10}; do
        if is_virtual_camera_active; then
            echo "RVM camera ready (PID: $RVM_PID)"
            return 0
        fi
        sleep 0.5
    done

    echo "Warning: RVM camera may not be fully ready"
    return 0
}

# Stop RVM camera
stop_rvm_camera() {
    echo "Stopping RVM camera..."

    RVM_PID=$(get_rvm_pid)

    if [ -n "$RVM_PID" ]; then
        kill -15 "$RVM_PID" 2>/dev/null || true

        # Wait for graceful shutdown
        for i in {1..6}; do
            if ! kill -0 "$RVM_PID" 2>/dev/null; then
                break
            fi
            sleep 0.5
        done

        # Force kill if still running
        if kill -0 "$RVM_PID" 2>/dev/null; then
            kill -9 "$RVM_PID" 2>/dev/null || true
        fi
    fi

    # Also kill any orphaned RVM processes
    pkill -f "rvm_camera.py" 2>/dev/null || true

    rm -f "$RVM_LOCK_FILE"
    echo "RVM camera stopped"
}

# Start OBS with virtual camera
start_virtual_camera() {
    echo "Starting virtual camera system..."

    # First, start RVM for background removal
    start_rvm_camera

    # Give RVM a moment to fully initialize
    sleep 1

    # Start OBS minimized to tray with virtual camera enabled
    echo "Starting OBS..."
    /usr/bin/obs --startvirtualcam --minimize-to-tray &
    OBS_PID=$!

    # Save PID to lock file
    echo "$OBS_PID" > "$LOCK_FILE"

    # Wait a moment for OBS to start
    sleep 2

    notify "Virtual Camera Started" "RVM + OBS running (background removal active)"
    echo "Virtual camera started (OBS PID: $OBS_PID)"
}

# Stop OBS virtual camera
stop_virtual_camera() {
    echo "Stopping virtual camera system..."

    # Stop OBS first
    OBS_PID=$(get_obs_pid)

    if [ -n "$OBS_PID" ]; then
        # Send SIGTERM for graceful shutdown
        kill -15 "$OBS_PID" 2>/dev/null || true

        # Wait up to 3 seconds for graceful shutdown
        for i in {1..6}; do
            if ! kill -0 "$OBS_PID" 2>/dev/null; then
                break
            fi
            sleep 0.5
        done

        # Force kill if still running
        if kill -0 "$OBS_PID" 2>/dev/null; then
            echo "Force killing OBS..."
            kill -9 "$OBS_PID" 2>/dev/null || true
        fi
    fi

    rm -f "$LOCK_FILE"

    # Then stop RVM
    stop_rvm_camera

    notify "Virtual Camera Stopped" "RVM + OBS have been closed"
    echo "Virtual camera system stopped"
}

# Main toggle logic
main() {
    if is_obs_running || is_rvm_running; then
        # Something is running - stop everything
        stop_virtual_camera
    else
        # Nothing is running - start everything
        start_virtual_camera
    fi
}

# Run main function
main