initial commit

Author: HeavyHorst

.gitignore

@@ -0,0 +1 @@
+/albums

LICENCE

@@ -0,0 +1,19 @@
+Copyright (c) 2017 Rene Kaufmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

confirm.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"log"
+	"os"
+	"strings"
+)
+
+// askForConfirmation asks the user for confirmation. A user must type in "yes" or "no" and
+// then press enter. It has fuzzy matching, so "y", "Y", "yes", "YES", and "Yes" all count as
+// confirmations. If the input is not recognized, it will ask again. The function does not return
+// until it gets a valid response from the user.
+func askForConfirmation(s string) bool {
+	reader := bufio.NewReader(os.Stdin)
+
+	for {
+		fmt.Printf("%s [y/n]: ", s)
+
+		response, err := reader.ReadString('\n')
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		response = strings.ToLower(strings.TrimSpace(response))
+
+		if response == "y" || response == "yes" {
+			return true
+		} else if response == "n" || response == "no" {
+			return false
+		}
+	}
+}

ffmpeg.go

@@ -0,0 +1,128 @@
+package main
+
+import (
+	"fmt"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	"github.com/bogem/id3v2"
+	"github.com/cheggaaa/pb"
+	"github.com/michiwend/gomusicbrainz"
+	"github.com/pkg/errors"
+)
+
+var errInvalidInput = errors.New("invalid duration")
+
+func getLength(inputFile string) (int, error) {
+	re := regexp.MustCompile("Duration: [0-9]+:[0-9]+:[0-9]+")
+
+	cmd := exec.Command("ffmpeg", "-i", inputFile)
+	stdoutStderr, err := cmd.CombinedOutput()
+	if err != nil && err.Error() != "exit status 1" {
+		return 0, err
+	}
+
+	return durToSec(strings.TrimPrefix(re.FindString(string(stdoutStderr)), "Duration: "))
+}
+
+func transcode(inputFile, outputFile string, start, length float64) error {
+	cmd := exec.Command("ffmpeg", "-y", "-i", inputFile, "-ss", fmt.Sprintf("%.0f", start),
+		"-t", fmt.Sprintf("%.0f", length),
+		"-codec:a", "libmp3lame", "-qscale:a", "3",
+		outputFile)
+	return cmd.Run()
+}
+
+func convertTrack(inputFile string, mbr musicBrainzRecording, dlFolder string) error {
+	l, err := getLength(inputFile)
+	if err != nil {
+		return errors.Wrap(err, "getLength failed")
+	}
+
+	trackName := fmt.Sprintf("%.2d %s - %s", mbr.trackNum, mbr.artist, mbr.trackTitle)
+	trackFullPath := filepath.Join(dlFolder, trackName) + "." + "mp3"
+
+	if err := transcode(inputFile, trackFullPath, 0.0, float64(l)); err != nil {
+		return errors.Wrap(err, "transcode failed")
+	}
+
+	err = tagFile(trackFullPath, mbr.artist, mbr.trackTitle, mbr.year, mbr.albumTitle, int(mbr.trackNum), int(mbr.trackCount), mbr.cdNum)
+	if err != nil {
+		return errors.Wrap(err, "tagFile failed")
+	}
+	return nil
+}
+
+func extractTracks(inputFile, year, album string, tracks []float64, trackInfo []*gomusicbrainz.Track, dlFolder string) error {
+	l, err := getLength(inputFile)
+	if err != nil {
+		return errors.Wrap(err, "getLength failed")
+	}
+
+	tracks = append(tracks, float64(l))
+
+	bar := pb.StartNew(len(trackInfo))
+	defer bar.Finish()
+
+	for i := 0; i < len(tracks)-1; i++ {
+		if len(trackInfo) > i {
+
+			artist := trackInfo[i].Recording.ArtistCredit.NameCredits[0].Artist.Name
+			title := trackInfo[i].Recording.Title
+
+			trackName := fmt.Sprintf("%.2d %s - %s", i+1, artist, title)
+			trackFullPath := filepath.Join(dlFolder, trackName) + "." + "mp3"
+			start := tracks[i]
+			end := tracks[i+1]
+			length := end - start
+
+			if err := transcode(inputFile, trackFullPath, start, length); err != nil {
+				return errors.Wrap(err, "transcode failed")
+			}
+
+			err = tagFile(trackFullPath, artist, title, year, album, i+1, len(trackInfo), -1)
+			if err != nil {
+				return errors.Wrap(err, "tagFile failed")
+			}
+
+			bar.Increment()
+		}
+	}
+	return nil
+}
+
+func tagFile(path string, artist, title, year, album string, trackNum, tracksTotal int, cdNum int64) error {
+	tag, err := id3v2.Open(path, id3v2.Options{Parse: true})
+	if err != nil {
+		return errors.Wrap(err, "id3v2 open failed")
+	}
+	defer tag.Close()
+
+	tag.SetArtist(artist)
+	tag.SetTitle(title)
+	tag.SetYear(year)
+	tag.SetAlbum(album)
+
+	trckFrame := id3v2.TextFrame{
+		Encoding: id3v2.ENUTF8,
+		Text:     fmt.Sprintf("%d/%d", trackNum, tracksTotal),
+	}
+	tag.AddFrame(tag.CommonID("TRCK"), trckFrame)
+
+	if cdNum >= 0 {
+		tposFrame := id3v2.TextFrame{
+			Encoding: id3v2.ENUTF8,
+			Text:     fmt.Sprintf("%d", cdNum),
+		}
+		tag.AddFrame(tag.CommonID("TPOS"), tposFrame)
+	}
+
+	// Write it to file.
+	if err = tag.Save(); err != nil {
+		return errors.Wrap(err, "tag save failed")
+	}
+
+	return nil
+}

main.go

@@ -0,0 +1,104 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"path/filepath"
+
+	"os"
+
+	"github.com/michiwend/gomusicbrainz"
+	homedir "github.com/mitchellh/go-homedir"
+	"github.com/otium/ytdl"
+	"github.com/pkg/errors"
+	"github.com/subosito/norma"
+)
+
+func handleError(err error) {
+	var e error
+	if err != nil {
+		if err != errNoRelease {
+			e = errors.WithStack(err)
+			fmt.Printf("%+v", e)
+		} else {
+			e = err
+			fmt.Printf("%s\n", e.Error())
+		}
+		os.Exit(1)
+	}
+}
+
+func dlRelease(library, url string, client *gomusicbrainz.WS2Client, vid *ytdl.VideoInfo) error {
+	mbr, err := getAlbumInfo(client, vid.Title)
+	handleError(err)
+
+	dlFolder := filepath.Join(library, norma.Sanitize(mbr.artist), norma.Sanitize(mbr.title))
+	dlFile := filepath.Join(dlFolder, norma.Sanitize(mbr.title))
+	defer os.Remove(dlFile)
+
+	tracks, err := getTracks(url)
+	handleError(err)
+
+	fmt.Println("\nDownloading Video:")
+	err = download(vid, dlFile)
+	handleError(err)
+
+	fmt.Println("\nExtracting tracks:")
+	return extractTracks(dlFile, mbr.year, mbr.title, tracks, mbr.tracks, dlFolder)
+}
+
+func dlRecord(library string, client *gomusicbrainz.WS2Client, vid *ytdl.VideoInfo) error {
+	mbr, err := getTrackInfo(client, vid.Title)
+	handleError(err)
+
+	dlFolder := filepath.Join(library, norma.Sanitize(mbr.artist), norma.Sanitize(mbr.albumTitle))
+	dlFile := filepath.Join(dlFolder, norma.Sanitize(mbr.trackTitle))
+	defer os.Remove(dlFile)
+
+	fmt.Println("\nDownloading Video:")
+	err = download(vid, dlFile)
+	handleError(err)
+
+	return convertTrack(dlFile, mbr, dlFolder)
+}
+
+const appName = "ymdl"
+const version = "0.0.1-beta"
+const contactURL = "github.com/HeavyHorst/ymdl"
+
+func main() {
+	var defaultLibraryPath string
+	homeDir, err := homedir.Dir()
+	if err != nil {
+		//couldn't find the home directory
+		defaultLibraryPath = "Music"
+	} else {
+		defaultLibraryPath = filepath.Join(homeDir, "Music")
+	}
+
+	dlTrack := flag.Bool("track", false, "download a single track from youtube")
+	dlAlbum := flag.Bool("album", true, "download a complete album from youtube")
+	printVersion := flag.Bool("version", false, "print the version and quit")
+	libraryPath := flag.String("lib", defaultLibraryPath, "the path to your music library")
+
+	flag.Parse()
+
+	if *printVersion {
+		fmt.Println(version)
+		os.Exit(0)
+	}
+
+	client, err := gomusicbrainz.NewWS2Client("https://musicbrainz.org/ws/2", appName, version, contactURL)
+	handleError(err)
+
+	for _, url := range flag.Args() {
+		vid, err := ytdl.GetVideoInfo(url)
+		handleError(err)
+
+		if *dlTrack {
+			handleError(dlRecord(*libraryPath, client, vid))
+		} else if *dlAlbum {
+			handleError(dlRelease(*libraryPath, url, client, vid))
+		}
+	}
+}