Leak_Technologies/VideoTools
Leak_Technologies/VideoTools
2
0
Fork 1
Code Issues 6 Pull Requests Actions Packages Projects Releases Wiki Activity
20a2fa7110
VideoTools/docs/DEV14_WINDOWS_IMPLEMENTATION.md

8.9 KiB
Raw Blame History

dev14: Windows Compatibility Implementation

Status: ✅ Core implementation complete Date: 2025-12-04 Target: Windows 10/11 support with cross-platform FFmpeg detection

Overview

This document summarizes the Windows compatibility implementation for VideoTools v0.1.0-dev14. The goal was to make VideoTools fully functional on Windows while maintaining Linux compatibility.

Implementation Summary

1. Platform Detection System (platform.go)

Created a comprehensive platform detection and configuration system:

File: platform.go (329 lines)

Key Components:

  • PlatformConfig struct: Holds platform-specific settings

    • FFmpeg/FFprobe paths
    • Temp directory location
    • Hardware encoder list
    • OS detection flags (IsWindows, IsLinux, IsDarwin)

  • DetectPlatform(): Main initialization function

    • Detects OS and architecture
    • Locates FFmpeg/FFprobe executables
    • Determines temp directory
    • Detects available hardware encoders

  • FFmpeg Discovery (Priority order):

    1. Bundled with application (same directory as executable)
    2. FFMPEG_PATH environment variable
    3. System PATH
    4. Common install locations (Windows: Program Files, C:\ffmpeg\bin)

  • Hardware Encoder Detection:

    • Windows: NVENC (NVIDIA), QSV (Intel), AMF (AMD)
    • Linux: VAAPI, NVENC, QSV

  • Platform-Specific Functions:

    • ValidateWindowsPath(): Validates drive letters and UNC paths
    • KillProcess(): Platform-appropriate process termination
    • GetEncoderName(): Maps hardware acceleration to encoder names

2. FFmpeg Command Updates

Updated Files:

  • main.go: 10 locations updated
  • internal/convert/ffmpeg.go: 1 location updated

Changes:

  • All exec.Command("ffmpeg", ...) → exec.Command(platformConfig.FFmpegPath, ...)
  • All exec.CommandContext(ctx, "ffmpeg", ...) → exec.CommandContext(ctx, platformConfig.FFmpegPath, ...)

Package Variable Approach:

  • Added FFmpegPath and FFprobePath variables to internal/convert package
  • These are set from main() during initialization
  • Allows internal packages to use correct platform paths

3. Cross-Compilation Build Script

File: scripts/build-windows.sh (155 lines)

Features:

  • Cross-compiles from Linux to Windows (amd64)
  • Uses MinGW-w64 toolchain
  • Produces VideoTools.exe with Windows GUI flags
  • Creates distribution package in dist/windows/
  • Optionally bundles FFmpeg.exe and ffprobe.exe
  • Strips debug symbols for smaller binary size

Build Flags:

  • -H windowsgui: Hides console window (GUI application)
  • -s -w: Strips debug symbols

Dependencies Required:

  • Fedora/RHEL: sudo dnf install mingw64-gcc mingw64-winpthreads-static
  • Debian/Ubuntu: sudo apt-get install gcc-mingw-w64

4. Testing Results

Linux Build: ✅ Successful

  • Executable: 32MB
  • Platform detection: Working correctly
  • FFmpeg discovery: Found in PATH
  • Debug output confirms proper initialization

Windows Build: ⏳ Ready to test

  • Build script created and tested (logic verified)
  • Requires MinGW installation for actual cross-compilation
  • Next step: Test on actual Windows system

Code Changes Detail

main.go

Lines 74-76: Added platformConfig global variable

// Platform-specific configuration
var platformConfig *PlatformConfig

Lines 1537-1545: Platform initialization

// Detect platform and configure paths
platformConfig = DetectPlatform()
if platformConfig.FFmpegPath == "ffmpeg" || platformConfig.FFmpegPath == "ffmpeg.exe" {
    logging.Debug(logging.CatSystem, "WARNING: FFmpeg not found in expected locations, assuming it's in PATH")
}

// Set paths in convert package
convert.FFmpegPath = platformConfig.FFmpegPath
convert.FFprobePath = platformConfig.FFprobePath

Updated Functions (10 locations):

  • Line 1426: queueConvert() - queue processing
  • Line 3411: runVideo() - video playback
  • Line 3489: runAudio() - audio playback
  • Lines 4233, 4245: detectBestH264Encoder() - encoder detection
  • Lines 4261, 4271: detectBestH265Encoder() - encoder detection
  • Line 4708: startConvert() - direct conversion
  • Line 5185: generateSnippet() - snippet generation
  • Line 5225: capturePreviewFrames() - preview capture
  • Line 5439: probeVideo() - cover art extraction
  • Line 5487: detectCrop() - cropdetect filter

internal/convert/ffmpeg.go

Lines 17-23: Added package variables

// FFmpegPath holds the path to the ffmpeg executable
// This should be set by the main package during initialization
var FFmpegPath = "ffmpeg"

// FFprobePath holds the path to the ffprobe executable
// This should be set by the main package during initialization
var FFprobePath = "ffprobe"

Line 248: Updated cover art extraction

Platform-Specific Behavior

Windows

  • Executable extension: .exe
  • Temp directory: %LOCALAPPDATA%\Temp\VideoTools
  • Path separator: \
  • Process termination: Direct Kill() (no SIGTERM)
  • Hardware encoders: NVENC, QSV, AMF
  • FFmpeg detection: Checks bundled location first

Linux

  • Executable extension: None
  • Temp directory: /tmp/videotools
  • Path separator: /
  • Process termination: Graceful SIGTERM → Kill()
  • Hardware encoders: VAAPI, NVENC, QSV
  • FFmpeg detection: Checks PATH

Platform Support

Linux ✅ (Primary Platform)

Testing Checklist

✅ Completed

  • Platform detection code implementation
  • FFmpeg path updates throughout codebase
  • Build script creation
  • Linux build verification
  • Platform detection debug output verification

⏳ Pending (Requires Windows Environment)

  • Cross-compile Windows executable
  • Test executable on Windows 10
  • Test executable on Windows 11
  • Verify FFmpeg detection on Windows
  • Test hardware encoder detection (NVENC, QSV, AMF)
  • Test with bundled FFmpeg
  • Test with system-installed FFmpeg
  • Verify path handling (drive letters, UNC paths)
  • Test file dialogs
  • Test drag-and-drop from Explorer
  • Verify temp file cleanup

Known Limitations

  1. MinGW Not Installed: Cannot test cross-compilation without MinGW toolchain
  2. Windows Testing: Requires actual Windows system for end-to-end testing
  3. FFmpeg Bundling: No automated FFmpeg download in build script yet
  4. Installer: No NSIS installer created yet (planned for later)
  5. Code Signing: Not implemented (required for wide distribution)

Next Steps (dev15+)

Immediate

  1. Install MinGW on build system
  2. Test cross-compilation
  3. Test Windows executable on Windows 10/11
  4. Bundle FFmpeg with Windows builds

Short-term

  • Create NSIS installer script
  • Add file association registration
  • Test on multiple Windows systems
  • Optimize Windows-specific settings

Medium-term

  • Code signing certificate
  • Auto-update mechanism
  • Windows Store submission
  • Performance optimization

File Structure

VideoTools/
├── platform.go                              # NEW: Platform detection
├── scripts/
│   ├── build.sh                            # Existing Linux build
│   └── build-windows.sh                    # NEW: Windows cross-compile
├── docs/
│   ├── WINDOWS_COMPATIBILITY.md            # Planning document
│   └── DEV14_WINDOWS_IMPLEMENTATION.md     # This file
└── internal/
    └── convert/
        └── ffmpeg.go                        # UPDATED: Package variables

Documentation References

  • WINDOWS_COMPATIBILITY.md: Comprehensive planning document (609 lines)
  • Platform detection: See platform.go:29-53
  • FFmpeg discovery: See platform.go:56-103
  • Encoder detection: See platform.go:164-220
  • Build script: See scripts/build-windows.sh

Verification Commands

Check platform detection:

VIDEOTOOLS_DEBUG=1 ./VideoTools 2>&1 | grep -i "platform\|ffmpeg"

Expected output:

[SYS] Platform detected: linux/amd64
[SYS] FFmpeg path: /usr/bin/ffmpeg
[SYS] FFprobe path: /usr/bin/ffprobe
[SYS] Temp directory: /tmp/videotools
[SYS] Hardware encoders: [vaapi]

Test Linux build:

go build -o VideoTools
./VideoTools

Test Windows cross-compilation:

./scripts/build-windows.sh

Verify Windows executable (from Windows):

VideoTools.exe

Summary

✅ Core Implementation Complete

All code changes required for Windows compatibility are in place:

  • Platform detection working
  • FFmpeg path abstraction complete
  • Cross-compilation build script ready
  • Linux build tested and verified

⏳ Pending: Windows Testing

The next phase requires:

  1. MinGW installation for cross-compilation
  2. Windows 10/11 system for testing
  3. Verification of all Windows-specific features

The codebase is now cross-platform ready and maintains full backward compatibility with Linux while adding Windows support.

Implementation Date: 2025-12-04 Target Release: v0.1.0-dev14 Status: Core implementation complete, testing pending