v7.1.4

2026-04-14 07:36:41 +07:00
parent 59a057b14a
commit 7346730be9
336 changed files with 13800 additions and 1142 deletions
@@ -83,6 +83,37 @@ func GetFFmpegDir() (string, error) {
 	return EnsureAppDir()
 }

+func resolveSystemExecutable(executableName string) string {
+	if runtime.GOOS == "darwin" {
+		candidates := []string{
+			"/opt/homebrew/bin/" + executableName,
+			"/usr/local/bin/" + executableName,
+		}
+		for _, candidate := range candidates {
+			if _, err := os.Stat(candidate); err == nil {
+				return candidate
+			}
+		}
+	}
+
+	if runtime.GOOS != "windows" {
+		path, err := exec.Command("which", executableName).Output()
+		if err == nil {
+			trimmed := strings.TrimSpace(string(path))
+			if trimmed != "" {
+				return trimmed
+			}
+		}
+	}
+
+	path, err := exec.LookPath(executableName)
+	if err == nil {
+		return path
+	}
+
+	return ""
+}
+
 func GetFFmpegPath() (string, error) {
 	ffmpegDir, err := GetFFmpegDir()
 	if err != nil {
@@ -94,38 +125,15 @@ func GetFFmpegPath() (string, error) {
 		ffmpegName = "ffmpeg.exe"
 	}

+	if path := resolveSystemExecutable(ffmpegName); path != "" {
+		return path, nil
+	}
+
 	localPath := filepath.Join(ffmpegDir, ffmpegName)
 	if _, err := os.Stat(localPath); err == nil {
 		return localPath, nil
 	}

-	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
-		homebrewPath := "/opt/homebrew/bin/" + ffmpegName
-		if _, err := os.Stat(homebrewPath); err == nil {
-			return homebrewPath, nil
-		}
-	} else if runtime.GOOS == "darwin" && runtime.GOARCH == "amd64" {
-		homebrewPath := "/usr/local/bin/" + ffmpegName
-		if _, err := os.Stat(homebrewPath); err == nil {
-			return homebrewPath, nil
-		}
-	}
-
-	if runtime.GOOS != "windows" {
-		path, err := exec.Command("which", ffmpegName).Output()
-		if err == nil {
-			trimmed := strings.TrimSpace(string(path))
-			if trimmed != "" {
-				return trimmed, nil
-			}
-		}
-	}
-
-	path, err := exec.LookPath(ffmpegName)
-	if err == nil {
-		return path, nil
-	}
-
 	return localPath, nil
 }

@@ -140,38 +148,15 @@ func GetFFprobePath() (string, error) {
 		ffprobeName = "ffprobe.exe"
 	}

+	if path := resolveSystemExecutable(ffprobeName); path != "" {
+		return path, nil
+	}
+
 	localPath := filepath.Join(ffmpegDir, ffprobeName)
 	if _, err := os.Stat(localPath); err == nil {
 		return localPath, nil
 	}

-	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
-		homebrewPath := "/opt/homebrew/bin/" + ffprobeName
-		if _, err := os.Stat(homebrewPath); err == nil {
-			return homebrewPath, nil
-		}
-	} else if runtime.GOOS == "darwin" && runtime.GOARCH == "amd64" {
-		homebrewPath := "/usr/local/bin/" + ffprobeName
-		if _, err := os.Stat(homebrewPath); err == nil {
-			return homebrewPath, nil
-		}
-	}
-
-	if runtime.GOOS != "windows" {
-		path, err := exec.Command("which", ffprobeName).Output()
-		if err == nil {
-			trimmed := strings.TrimSpace(string(path))
-			if trimmed != "" {
-				return trimmed, nil
-			}
-		}
-	}
-
-	path, err := exec.LookPath(ffprobeName)
-	if err == nil {
-		return path, nil
-	}
-
 	return localPath, fmt.Errorf("ffprobe not found in app directory or system path")
 }

@@ -205,7 +190,11 @@ func IsFFmpegInstalled() (bool, error) {

 	setHideWindow(cmd)
 	err = cmd.Run()
-	return err == nil, nil
+	if err != nil {
+		return false, nil
+	}
+
+	return IsFFprobeInstalled()
 }

 func GetBrewPath() string {
@@ -255,10 +244,38 @@ func InstallFFmpegWithBrew(progressCallback func(int, string)) error {
 	return nil
 }

-const (
-	ffmpegWindowsURL = "https://github.com/afkarxyz/ffmpeg-binaries/releases/download/v8.0/ffmpeg-windows-amd64.zip"
-	ffmpegLinuxURL   = "https://github.com/afkarxyz/ffmpeg-binaries/releases/download/v8.0/ffmpeg-linux-amd64.tar.xz"
-)
+const ffmpegReleaseBaseURL = "https://github.com/afkarxyz/ffmpeg-binaries/releases/download/v8.1"
+
+func buildFFmpegReleaseURL(assetName string) string {
+	return ffmpegReleaseBaseURL + "/" + assetName
+}
+
+func getFFmpegDownloadURLs() ([]string, []string, error) {
+	switch runtime.GOOS {
+	case "windows":
+		return []string{buildFFmpegReleaseURL("ffmpeg-windows.zip")}, []string{buildFFmpegReleaseURL("ffprobe-windows.zip")}, nil
+	case "linux":
+		switch runtime.GOARCH {
+		case "amd64":
+			return []string{buildFFmpegReleaseURL("ffmpeg-linux-amd64.zip")}, []string{buildFFmpegReleaseURL("ffprobe-linux-amd64.zip")}, nil
+		case "arm64":
+			return []string{buildFFmpegReleaseURL("ffmpeg-linux-arm64v8.zip")}, []string{buildFFmpegReleaseURL("ffprobe-linux-arm64v8.zip")}, nil
+		default:
+			return nil, nil, fmt.Errorf("unsupported Linux architecture: %s", runtime.GOARCH)
+		}
+	case "darwin":
+		switch runtime.GOARCH {
+		case "amd64":
+			return []string{buildFFmpegReleaseURL("ffmpeg-macos-amd64.zip")}, []string{buildFFmpegReleaseURL("ffprobe-macos-amd64.zip")}, nil
+		case "arm64":
+			return []string{buildFFmpegReleaseURL("ffmpeg-macos-arm64.zip")}, []string{buildFFmpegReleaseURL("ffprobe-macos-arm64.zip")}, nil
+		default:
+			return nil, nil, fmt.Errorf("unsupported macOS architecture: %s", runtime.GOARCH)
+		}
+	default:
+		return nil, nil, fmt.Errorf("unsupported operating system: %s", runtime.GOOS)
+	}
+}

 func DownloadFFmpeg(progressCallback func(int)) error {

@@ -276,57 +293,30 @@ func DownloadFFmpeg(progressCallback func(int)) error {
 		return fmt.Errorf("failed to create ffmpeg directory: %w", err)
 	}

-	if runtime.GOOS == "darwin" {
-		ffmpegInstalled, _ := IsFFmpegInstalled()
-		ffprobeInstalled, _ := IsFFprobeInstalled()
+	ffmpegInstalled, _ := IsFFmpegInstalled()
+	ffprobeInstalled, _ := IsFFprobeInstalled()

-		isARM := runtime.GOARCH == "arm64"
+	ffmpegURLs, ffprobeURLs, err := getFFmpegDownloadURLs()
+	if err != nil {
+		return err
+	}

-		var macFFmpegURLs []string
-		var macFFprobeURLs []string
-
-		if isARM {
-
-			macFFmpegURLs = []string{"https://github.com/afkarxyz/ffmpeg-binaries/releases/download/v8.0/ffmpeg-macos-arm64.zip"}
-			macFFprobeURLs = []string{"https://github.com/afkarxyz/ffmpeg-binaries/releases/download/v8.0/ffprobe-macos-arm64.zip"}
-		} else {
-
-			macFFmpegURLs = []string{"https://github.com/afkarxyz/ffmpeg-binaries/releases/download/v8.0/ffmpeg-macos-intel.zip"}
-			macFFprobeURLs = []string{"https://github.com/afkarxyz/ffmpeg-binaries/releases/download/v8.0/ffprobe-macos-intel.zip"}
+	if !ffmpegInstalled && !ffprobeInstalled {
+		if err := downloadWithFallback(ffmpegURLs, ffmpegDir, progressCallback, 0, 50); err != nil {
+			return err
 		}
-
-		if !ffmpegInstalled && !ffprobeInstalled {
-			if err := downloadWithFallback(macFFmpegURLs, ffmpegDir, progressCallback, 0, 50); err != nil {
-				return err
-			}
-			if err := downloadWithFallback(macFFprobeURLs, ffmpegDir, progressCallback, 50, 100); err != nil {
-				return err
-			}
-		} else if !ffmpegInstalled {
-			if err := downloadWithFallback(macFFmpegURLs, ffmpegDir, progressCallback, 0, 100); err != nil {
-				return err
-			}
-		} else if !ffprobeInstalled {
-			if err := downloadWithFallback(macFFprobeURLs, ffmpegDir, progressCallback, 0, 100); err != nil {
-				return err
-			}
+		if err := downloadWithFallback(ffprobeURLs, ffmpegDir, progressCallback, 50, 100); err != nil {
+			return err
 		}
 		return nil
 	}

-	var url string
-	switch runtime.GOOS {
-	case "windows":
-		url = ffmpegWindowsURL
-	case "linux":
-		url = ffmpegLinuxURL
-	default:
-		return fmt.Errorf("unsupported operating system: %s", runtime.GOOS)
+	if !ffmpegInstalled {
+		return downloadWithFallback(ffmpegURLs, ffmpegDir, progressCallback, 0, 100)
 	}

-	fmt.Printf("[FFmpeg] Downloading from: %s\n", url)
-	if err := downloadAndExtract(url, ffmpegDir, progressCallback, 0, 100); err != nil {
-		return err
+	if !ffprobeInstalled {
+		return downloadWithFallback(ffprobeURLs, ffmpegDir, progressCallback, 0, 100)
 	}

 	return nil
@@ -452,10 +442,13 @@ func downloadAndExtract(url, destDir string, progressCallback func(int), progres
 	}
 	fmt.Printf("[FFmpeg] Extracting...\n")

-	if strings.HasSuffix(url, ".tar.xz") || runtime.GOOS == "linux" {
+	if strings.HasSuffix(url, ".tar.xz") {
 		return extractTarXz(tmpFile.Name(), destDir)
 	}
-	return extractZip(tmpFile.Name(), destDir)
+	if strings.HasSuffix(url, ".zip") {
+		return extractZip(tmpFile.Name(), destDir)
+	}
+	return fmt.Errorf("unsupported archive format for %s", url)
 }

 func extractZip(zipPath, destDir string) error {