release v0.1.1

.gitignore

@@ -5,12 +5,13 @@
 *.so
 *.dylib
 
+*.syso
+
 # Test binary, built with `go test -c`
 *.test
 
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 
 bin/
-
-*.syso
+cmd/YouTubeDownloader/Downloads/

CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+All notable changes to this project (YouTubeDownloader) will be documented in this file.
+
+## [0.1.1] - 06/05/2021
+### Fixed:
+ - Windows: Unable to play videos due to the improper javascript string escaping
+ - Windows: Missing window title theme
+ - Can't move files across file systems
+ - Some downloaded formats were not being shown as downloaded
+
+### Changed:
+ - Dropped javascript special encoder and instead rely only on json's
+ - Video alerts are now dismissible
+
+### Added:
+ - FFmpeg check
+ - Audio only download option
+
+## [0.1.0] - 05/05/2021
+- Initial Release
+___
+Date format: DD/MM/YYYY

Makefile

@@ -2,6 +2,8 @@ PROJECT_NAME = YouTubeDownloader
 
 CMD_DIR = ./cmd/
 
+BIN_DIR = ./bin/
+
 BIN_DIR_MAC = ./bin/mac/
 BIN_DIR_LINUX = ./bin/linux/
 BIN_DIR_WINDOWS = ./bin/windows/
@@ -16,9 +18,7 @@ all: clean dep compile
 
 clean:
 	@echo -n "Cleaning: "
-	@rm -rf $(BIN_DIR_MAC)
-	@rm -rf $(BIN_DIR_LINUX)
-	@rm -rf $(BIN_DIR_WINDOWS)
+	@rm -rf $(BIN_DIR)
 	@echo "[OK]"
 
 dep:
@@ -29,17 +29,20 @@ dep:
 compile:
 	@echo "Compiling: "
 
-	# MacOS (64bit)
+	# macOS (64bit)
 	@mkdir -p $(BIN_DIR_MAC)
 	GOOS=darwin GOARCH=amd64 go build -ldflags $(LD_FLAGS_MAC) -o $(BIN_DIR_MAC)$(PROJECT_NAME) $(CMD_DIR)$(PROJECT_NAME)
+	@zip -j $(BIN_DIR)$(PROJECT_NAME)_$(GIT_TAG)_mac.zip $(BIN_DIR_MAC)$(PROJECT_NAME)
 
 	# Linux (64bit)
 	@mkdir -p $(BIN_DIR_LINUX)
 	GOOS=linux GOARCH=amd64 go build -ldflags $(LD_FLAGS_LINUX) -o $(BIN_DIR_LINUX)$(PROJECT_NAME) $(CMD_DIR)$(PROJECT_NAME)
+	@zip -j $(BIN_DIR)$(PROJECT_NAME)_$(GIT_TAG)_linux.zip $(BIN_DIR_LINUX)$(PROJECT_NAME)
 
 	# Windows (64bit)
 	@mkdir -p $(BIN_DIR_WINDOWS)
 	rsrc -arch amd64 -ico ico.ico -o $(CMD_DIR)$(PROJECT_NAME)/rsrc_windows_amd64.syso
 	GOOS=windows GOARCH=amd64 go build -ldflags $(LD_FLAGS_WINDOWS) -o $(BIN_DIR_WINDOWS)$(PROJECT_NAME).exe $(CMD_DIR)$(PROJECT_NAME)
+	@zip -j $(BIN_DIR)$(PROJECT_NAME)_$(GIT_TAG)_windows.zip $(BIN_DIR_WINDOWS)$(PROJECT_NAME).exe
 
 	@echo "[OK]"

README.md

@@ -1,5 +1,31 @@
 # YouTubeDownloader
 YouTubeDownloader is a simple cross-platform YouTube downloader.
 
+## Requirements
+
+##### Chrome/Chromium browser
+- Download from https://www.google.com/chrome/ (for Google Chrome)
+- Install the browser
+
+##### FFmpeg
+- Download from https://ffmpeg.org/download.html
+- Add ffmpeg to PATH
+
+Tutorial for Windows: https://www.wikihow.com/Install-FFmpeg-on-Windows
+
+## Usage
+- Navigate to https://github.com/s77rt/YouTubeDownloader/releases/latest
+- Download one of the compiled binaries (depending on your os)
+- Run the downloaded file
+
+## Known Issues
+- Some formats are slow to download, please report on [#1](https://github.com/s77rt/YouTubeDownloader/issues/1)
+
 ## TODO
-- Write a better README.md
+- Add FFmpeg (merging process) progress
+
+## Changelog
+Refer to [CHANGELOG.md](https://github.com/s77rt/YouTubeDownloader/blob/master/CHANGELOG.md)
+
+___
+[Report a bug / Request a feature](https://github.com/s77rt/YouTubeDownloader/issues/new)

binding.go

@@ -3,50 +3,66 @@ package YouTubeDownloader
 import (
 	"github.com/zserge/lorca"
 	D "github.com/s77rt/YouTubeDownloader/downloader"
+	M "github.com/s77rt/YouTubeDownloader/merger"
 )
 
 func BindUI(ui lorca.UI) {
 	ui.Bind("Ready", func() {
-		ui.Eval(`setVersion('`+EscapeJS(Version)+`');`)
+		ui.Eval(`setVersion(`+MarshalJSONS(Version)+`);`)
+		ui.Eval(`w_CheckFFmpeg();`)
+	})
+
+	ui.Bind("CheckFFmpeg", func() {
+		if exists := M.FFmpeg_exists(); !exists {
+			ui.Eval(`w_CheckFFmpeg__onerror("FFmpeg is not installed");`)
+		}
 	})
 
 	ui.Bind("GetVideo", func(url string) {
 		video, err := extractor.GetVideo(url)
 		if err != nil {
-			ui.Eval(`w_GetVideo__onerror('`+EscapeJS(err.Error())+`');`)
+			ui.Eval(`w_GetVideo__onerror(`+MarshalJSONS(err.Error())+`);`)
 		} else {
-			ui.Eval(`add_video(`+EscapeJS(MarshalJSONS(video))+`);`)
+			ui.Eval(`add_video(`+MarshalJSONS(video)+`);`)
 		}
 		ui.Eval(`h_unlock();`)
 	})
 
 	ui.Bind("GetVideos", func(url string) {
 		videos, err := extractor.GetVideos(url)
 		if err != nil {
-			ui.Eval(`w_GetVideo__onerror('`+EscapeJS(err.Error())+`');`)
+			ui.Eval(`w_GetVideo__onerror(`+MarshalJSONS(err.Error())+`);`)
 		} else {
 			for _, video := range videos {
-				ui.Eval(`add_video(`+EscapeJS(MarshalJSONS(video))+`);`)
+				ui.Eval(`add_video(`+MarshalJSONS(video)+`);`)
 			}
 		}
 		ui.Eval(`h_unlock();`)
 	})
 
-	ui.Bind("GetExistingVideo", func(uuid string, video interface{}, format interface{}) {
-		filename, err := getOutputFile(extractor, downloader, video, format)
-		if err != nil {
-			ui.Eval(`w_GetExistingVideo__onerror('`+EscapeJS(uuid)+`', '`+EscapeJS(err.Error())+`');`)
-		} else if FileExists(filename) {
-			ui.Eval(`update_video_success('`+EscapeJS(uuid)+`','`+EscapeJS(filename)+`');`)
-		} else {
-			ui.Eval(`w_GetExistingVideo__onerror('`+EscapeJS(uuid)+`', 'not available');`)
+	ui.Bind("GetExistingVideo", func(uuid string, video interface{}, formats []interface{}) {
+		found := false
+		for _, format := range(formats) {
+			filename, err := getOutputFile(extractor, downloader, video, format)
+			if err != nil {
+				ui.Eval(`w_GetExistingVideo__onerror(`+MarshalJSONS(uuid)+`, `+MarshalJSONS(err.Error())+`);`)
+				break
+			}
+			if FileExists(filename) {
+				found = true
+				ui.Eval(`update_video_success(`+MarshalJSONS(uuid)+`,`+MarshalJSONS(filename)+`);`)
+				break
+			}
+		}
+		if !found {
+			ui.Eval(`w_GetExistingVideo__onerror(`+MarshalJSONS(uuid)+`, "not available");`)
 		}
 	})
 
 	ui.Bind("DownloadVideo", func(uuid string, video interface{}, format interface{}) {
 		task := tasks.New(uuid)
 		filename, err := DownloadVideo(task.Context, task.Tmpdir, extractor, downloader, video, format, func(p1, p2 *D.Progress) {
-			ui.Eval(`update_video_progress('`+EscapeJS(uuid)+`',`+EscapeJS(MarshalJSONS(p1))+`,`+EscapeJS(MarshalJSONS(p2))+`);`)
+			ui.Eval(`update_video_progress(`+MarshalJSONS(uuid)+`,`+MarshalJSONS(p1)+`,`+MarshalJSONS(p2)+`);`)
 		})
 		if err != nil {
 			if task.Context.Err() != nil {
@@ -59,39 +75,39 @@ func BindUI(ui lorca.UI) {
 				this should be further investigated...
 				*/
 			} else {
-				ui.Eval(`w_DownloadVideo__onerror('`+EscapeJS(uuid)+`', '`+EscapeJS(err.Error())+`');`)
+				ui.Eval(`w_DownloadVideo__onerror(`+MarshalJSONS(uuid)+`, `+MarshalJSONS(err.Error())+`);`)
 			}
 		} else {
-			ui.Eval(`update_video_success('`+EscapeJS(uuid)+`','`+EscapeJS(filename)+`');`)
+			ui.Eval(`update_video_success(`+MarshalJSONS(uuid)+`,`+MarshalJSONS(filename)+`);`)
 		}
 		task.Done()
 	})
 
 	ui.Bind("CancelDownload", func(uuid string) {
 		err := tasks.Abort(uuid)
 		if err != nil {
-			ui.Eval(`w_CancelDownload__onerror('`+EscapeJS(uuid)+`', '`+EscapeJS(err.Error())+`');`)
+			ui.Eval(`w_CancelDownload__onerror(`+MarshalJSONS(uuid)+`, `+MarshalJSONS(err.Error())+`);`)
 		}
 	})
 
 	ui.Bind("PlayVideo", func(uuid string, video_filename string) {
 		err := RunFile(video_filename)
 		if err != nil {
-			ui.Eval(`w_PlayVideo__onerror('`+EscapeJS(uuid)+`', '`+EscapeJS(err.Error())+`');`)
+			ui.Eval(`w_PlayVideo__onerror(`+MarshalJSONS(uuid)+`, `+MarshalJSONS(err.Error())+`);`)
 		}
 	})
 
 	ui.Bind("OpenFolder", func(uuid string, video_filename string) {
 		err := OpenFolder(video_filename)
 		if err != nil {
-			ui.Eval(`w_OpenFolder__onerror('`+EscapeJS(uuid)+`', '`+EscapeJS(err.Error())+`');`)
+			ui.Eval(`w_OpenFolder__onerror(`+MarshalJSONS(uuid)+`, `+MarshalJSONS(err.Error())+`);`)
 		}
 	})
 
 	ui.Bind("DeleteVideo", func(uuid string, video_filename string) {
 		err := DeleteFile(video_filename)
 		if err != nil {
-			ui.Eval(`w_DeleteVideo__onerror('`+EscapeJS(uuid)+`', '`+EscapeJS(err.Error())+`');`)
+			ui.Eval(`w_DeleteVideo__onerror(`+MarshalJSONS(uuid)+`, `+MarshalJSONS(err.Error())+`);`)
 		}
 	})
 }

download.go

@@ -45,7 +45,6 @@ func DownloadVideo(ctx context.Context, tmpdir string, extractor E.Extractor, do
 	var progress_2 *D.Progress
 
 	if url_1 != "" && url_2 == "" {
-		// Video + Audio (one file)
 		progress_1 = &D.Progress{TimeUnit: timeunit}
 		progress_2 = progress_1
 
@@ -84,15 +83,14 @@ func DownloadVideo(ctx context.Context, tmpdir string, extractor E.Extractor, do
 		}
 		defer file.Close()
 
-		err = os.Rename(file_1.Name(), file.Name())
+		err = MoveFile(file_1.Name(), file.Name())
 		if err != nil {
 			return "", err
 		}
 
 		return file.Name(), nil
 
 	} else if url_1 != "" && url_2 != "" {
-		// Video + Audio (separated)
 		progress_1 = &D.Progress{TimeUnit: timeunit}
 		progress_2 = &D.Progress{TimeUnit: timeunit}
 

extractor/youtube/utils.go

@@ -9,11 +9,13 @@ import (
 // Rely on hardcoded canonical mime types, as the ones provided by Go aren't exhaustive [1].
 // This seems to be a recurring problem for youtube downloaders, see [2].
 // The implementation is based on mozilla's list [3], IANA [4] and Youtube's support [5].
+// Edit: added audio formats [6]
 // [1] https://github.com/golang/go/blob/ed7888aea6021e25b0ea58bcad3f26da2b139432/src/mime/type.go#L60
 // [2] https://github.com/ZiTAL/youtube-dl/blob/master/mime.types
 // [3] https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types
 // [4] https://www.iana.org/assignments/media-types/media-types.xhtml#video
 // [5] https://support.google.com/youtube/troubleshooter/2888402?hl=en
+// [6] https://github.com/rello/audioplayer/wiki/audio-files-and-mime-types
 var canonicals = map[string]string{
 	"video/quicktime":  ".mov",
 	"video/x-msvideo":  ".avi",
@@ -26,6 +28,17 @@ var canonicals = map[string]string{
 	"video/mp4":        ".mp4",
 	"video/ogg":        ".ogv",
 	"video/mp2t":       ".ts",
+
+	"audio/flac":       ".flac",
+	"audio/mpegurl":    ".m3u8",
+	"audio/mp4":        ".m4a",
+	"audio/mpeg":       ".mp3",
+	"audio/ogg":        ".opus",
+	"audio/x-scpls":    ".pls",
+	"audio/wav":        ".wav",
+	"audio/aac":        ".aac",
+	"audio/webm":       ".webm",
+	"audio/x-ms-wma":   ".wma",
 }
 
 func pickIdealFileExtension(mediaType string) string {