コード例 #1
0
ファイル: virtualdj.go プロジェクト: Ruxton/tracklist_parsers
func ParseVirtualDJTracklist(bufReader *bufio.Reader) []Track {
	var list []Track

	for line, _, err := bufReader.ReadLine(); err != io.EOF; line, _, err = bufReader.ReadLine() {
		data := strings.SplitN(string(line), " : ", 2)
		trackdata := strings.SplitN(data[1], " - ", 2)
		if len(trackdata) != 2 {
			term.OutputError("Error parsing track " + string(data[1]))
			term.OutputMessage("Please enter an artist for this track: ")
			artist, err := term.STD_IN.ReadString('\n')
			if err != nil {
				term.OutputError("Incorrect artist entry.")
				os.Exit(2)
			}
			term.OutputMessage("Please enter a name for this track: ")
			track, err := term.STD_IN.ReadString('\n')
			if err != nil {
				term.OutputError("Incorrect track name entry.")
				os.Exit(2)
			}

			trackdata = []string{artist, track}
		}

		thistrack := new(Track)
		thistrack.Artist = trackdata[0]
		thistrack.Song = trackdata[1]

		list = append(list, *thistrack)
	}

	return list
}
コード例 #2
0
func getCoverUrl(db *bolt.DB, artist string, track string) string {
	term.OutputMessage(fmt.Sprintf(term.Green+"Searching for %s - %s.."+term.Reset, artist, track))

	cover_url := GetData(db, artist, track)
	if cover_url != "" {
		term.OutputMessage(term.Green + term.Bold + "DONE!\n" + term.Reset)
	} else {
		term.OutputMessage(term.Green + "." + term.Reset)
		cover_url = itunes.GetCoverFor(artist, track)
		if cover_url == "" {
			term.OutputMessage(term.Green + "." + term.Reset)
			cover_url = google.GetCoverFor(artist, track)
		}
		if cover_url == "" {
			term.OutputMessage(term.Green + ".\n" + term.Reset)
			term.OutputError(fmt.Sprintf("Unable to find a cover for %s - %s", artist, track))
			cover_url = getCoverUrlFromInput()
		}
		if cover_url != "" {
			term.OutputMessage(term.Green + term.Bold + "DONE!\n" + term.Reset)
			InsertData(db, artist, track, cover_url)
		}
	}

	return cover_url
}
コード例 #3
0
func maskImage(dst draw.Image, filename string) {
	infile, err := os.Open(filename)
	defer infile.Close()

	if err != nil {
		term.OutputError(fmt.Sprintf("Unable to open overlay image - %s", err.Error()))
	} else {
		overlay, _, err := image.Decode(infile)
		if err != nil {
			term.OutputError(fmt.Sprintf("Unable to decode image file - %s", err.Error()))
		} else {
			mask := image.NewUniform(color.Alpha{128})
			draw.DrawMask(dst, dst.Bounds(), imaging.Thumbnail(overlay, 480, 480, imaging.CatmullRom), image.Pt(0, 0), mask, image.Pt(0, 0), draw.Over)
		}
	}
}
コード例 #4
0
func getCoverUrlFromInput() string {
	term.OutputMessage("Enter a URL the cover image: ")
	cover_url, err := STD_IN.ReadString('\n')
	if err != nil {
		term.OutputError("Error accepting input.")
		os.Exit(2)
	}
	return strings.TrimRightFunc(cover_url, unicode.IsSpace)
}
コード例 #5
0
ファイル: google.go プロジェクト: Ruxton/mix_cover_builder
func GetPaginatedCoverFor(artist string, song string, start int) string {
	query := "site:bandcamp.com " + artist + " - " + song + " bandcamp cover art"

	cover_search_url := fmt.Sprintf(GOOGLE_URL, url.QueryEscape(query), start)

	request := BuildHttpRequest(cover_search_url, "GET")
	client := http.Client{}
	resp, doError := client.Do(request)
	defer resp.Body.Close()

	if doError != nil {
		term.OutputError("Error fetching artwork for " + artist + " - " + song + ": " + doError.Error())
	}

	var responseObj *Response = new(Response)

	err := json.NewDecoder(resp.Body).Decode(&responseObj)
	if err != nil {
		term.OutputError(err.Error())
		os.Exit(2)
	}

	var songObj *Result = new(Result)

	if responseObj.Status != 200 {
		term.OutputError(fmt.Sprintf("Error fetching artwork from google - %d", responseObj.Status))
	} else {
		for _, result := range responseObj.Data.Results {
			if strings.Contains(result.OriginalContextUrl, "bandcamp.com") &&
				(strings.Contains(result.ContentNoFormatting, "cover art") ||
					strings.Contains(result.ContentNoFormatting, song) ||
					strings.Contains(result.TitleNoFormatting, song)) ||
				(strings.HasPrefix(result.ContentNoFormatting, song[0:15])) {
				songObj = &result
				break
			}
		}
	}
	if songObj.Url == "" {
		term.OutputMessage(term.Green + "." + term.Reset)
	}
	return songObj.Url
}
コード例 #6
0
func parseTracklist(tracklist *string) []Track {
	var list []Track

	fin, err := os.Open(*tracklist)
	if err != nil {
		term.OutputError(fmt.Sprintf("The file %s does not exist!\n", *tracklist))
		os.Exit(1)
	}
	defer fin.Close()

	bufReader := bufio.NewReader(fin)

	for line, _, err := bufReader.ReadLine(); err != io.EOF; line, _, err = bufReader.ReadLine() {
		data := strings.SplitN(string(line), " : ", 2)
		trackdata := strings.SplitN(data[1], " - ", 2)
		if len(trackdata) != 2 {
			term.OutputError("Error parsing track " + string(data[1]))
			term.OutputMessage("Please enter an artist for this track: ")
			artist, err := STD_IN.ReadString('\n')
			if err != nil {
				term.OutputError("Incorrect artist entry.")
				os.Exit(2)
			}
			term.OutputMessage("Please enter a name for this track: ")
			track, err := STD_IN.ReadString('\n')
			if err != nil {
				term.OutputError("Incorrect track name entry.")
				os.Exit(2)
			}

			trackdata = []string{artist, track}
		}

		thistrack := new(Track)
		thistrack.Artist = trackdata[0]
		thistrack.Song = trackdata[1]

		list = append(list, *thistrack)
	}

	return list
}
コード例 #7
0
ファイル: itunes.go プロジェクト: Ruxton/mix_cover_builder
func GetCoverFor(artist string, song string) string {
	query := artist + " " + song

	cover_search_url := fmt.Sprintf(ITMS_URL, url.QueryEscape(query), "AU", "song")

	request := BuildHttpRequest(cover_search_url, "GET")
	client := http.Client{}
	resp, doError := client.Do(request)
	defer resp.Body.Close()

	if doError != nil {
		term.OutputError("Error fetching artwork for " + artist + " - " + song + ": " + doError.Error())
	}

	var responseObj *Response = new(Response)

	err := json.NewDecoder(resp.Body).Decode(&responseObj)
	if err != nil {
		term.OutputError(err.Error())
		os.Exit(2)
	}

	var songObj *Result = new(Result)
	var emptySongObj *Result = new(Result)

	if responseObj.Error != "" {
		fmt.Println(responseObj.Error)
	} else {
		for _, result := range responseObj.Results {
			if ((result.ArtistName == artist) && (result.TrackName == song)) ||
				strings.HasPrefix(result.TrackName, song) {
				songObj = &result
				break
			}
		}
	}
	if songObj != emptySongObj {
		return songObj.ArtworkUrl600()
	} else {
		return ""
	}
}
コード例 #8
0
ファイル: basic.go プロジェクト: Ruxton/tracklist_parsers
func ParseBasicTracklist(bufReader *bufio.Reader) []Track {
	var list []Track

	regex, err := regexp.Compile(`([0-9]+)(?:.{1}?\s)(.+)(?:\s-\s)(.+)`)
	if err != nil {
		term.OutputError("Error matching strings")
		os.Exit(2)
	}

	for line, _, err := bufReader.ReadLine(); err != io.EOF; line, _, err = bufReader.ReadLine() {

		trackdata := regex.FindAllStringSubmatch(string(line), 3)[0]
		// trackdata := strings.SplitN(data[1], " - ", 2)
		// t
		if len(trackdata) != 4 {
			term.OutputError("Error parsing track " + string(line))
			term.OutputMessage("Please enter an artist for this track: ")
			artist, err := term.STD_IN.ReadString('\n')
			if err != nil {
				term.OutputError("Incorrect artist entry.")
				os.Exit(2)
			}
			term.OutputMessage("Please enter a name for this track: ")
			track, err := term.STD_IN.ReadString('\n')
			if err != nil {
				term.OutputError("Incorrect track name entry.")
				os.Exit(2)
			}

			trackdata = []string{"0", artist, track}
		}

		thistrack := new(Track)
		thistrack.Artist = trackdata[2]
		thistrack.Song = trackdata[3]

		list = append(list, *thistrack)
	}

	return list
}
コード例 #9
0
func createImage(selection ArtistTrackList, output_filename string, overlay string) {
	if len(selection) != 9 {
		term.OutputError("Unable to find enough images to make cover")
	} else {
		term.OutputMessage(term.Yellow + "Generating image.." + term.Reset)
		xt := 3
		yt := 3
		width := xt * 160
		height := yt * 160

		dst := image.NewRGBA(image.Rect(0, 0, width, height))
		count := 0
		for y := 0; y < yt; y++ {
			for x := 0; x < xt; x++ {
				term.OutputMessage(term.Yellow + "." + term.Reset)
				src := selection[count].Tracks[0].CoverImage
				draw.Draw(dst, image.Rect(x*160, y*160, (x+1)*160, (y+1)*160), imaging.Thumbnail(src, 160, 160, imaging.CatmullRom), image.Pt(0, 0), draw.Src)
				count = count + 1
			}
		}

		if overlay != "" {
			term.OutputMessage(term.Yellow + "." + term.Reset)
			maskImage(dst, overlay)
			term.OutputMessage(term.Yellow + "." + term.Reset)
		}

		f, err := os.Create(output_filename)
		if err != nil {
			term.OutputError("\ncant save picture: " + err.Error())
		}
		defer f.Close()

		term.OutputMessage(term.Yellow + "." + term.Reset)
		jpeg.Encode(f, dst, nil)
		term.OutputMessage(term.Yellow + term.Bold + "DONE!\n" + term.Reset)
	}
}
コード例 #10
0
func FetchImage(artistTrack *ArtistTrack) {
	term.OutputMessage(term.Yellow + "Fetching image.." + term.Reset)
	term.OutputMessage(term.Yellow + "." + term.Reset)
	client := http.Client{}

	req, err := http.NewRequest("GET", artistTrack.Tracks[0].Cover, nil)
	if err != nil {
		fmt.Printf("Error - %s", err.Error())
	}
	resp, doError := client.Do(req)
	if doError != nil {
		term.OutputError("Error - " + doError.Error())
	}

	outputImage, _, err := image.Decode(resp.Body)
	artistTrack.Tracks[0].CoverImage = outputImage

	term.OutputMessage(term.Yellow + term.Bold + "DONE!\n" + term.Reset)
}
コード例 #11
0
ファイル: serato.go プロジェクト: Ruxton/tracklist_parsers
func ParseSeratoTracklist(bufReader *bufio.Reader) {
	term.OutputError("Serato tracklist parsing unsupported")
	os.Exit(2)
}
コード例 #12
0
func main() {

	flag.Parse(true)
	showWelcomeMessage()
	if *aboutFlag == true {
		showAboutMessage()
		os.Exit(0)
	}

	var tracklist []Track
	tracklistFileName := ""

	if *trackListFlag != "" {
		tracklistFileName = *trackListFlag
		tracklist = parseTracklist(trackListFlag)
	} else {
		if len(os.Args) > 1 {
			if os.Args[1][0:2] != "--" {
				tracklistFileName = string(os.Args[1])
				tracklist = parseTracklist(&tracklistFileName)
			} else {
				term.OutputError("Please provide a tracklist to parse")
				os.Exit(1)
			}
		} else {
			term.OutputError("Please provide a tracklist to parse")
			os.Exit(1)
		}
	}

	if len(tracklist) < 9 {
		term.OutputError("Not enough tracks in tracklist")
		os.Exit(1)
	}

	overlay_filename := ""
	if *overlayFlag != "" {
		overlay_filename = *overlayFlag
	}

	output_filename := strings.Replace(tracklistFileName, ".txt", ".jpg", -1)

	if *outputFileFlag != "" {
		output_filename = *outputFileFlag
	} else {
		if len(os.Args) > 2 {
			if os.Args[2][0:2] != "--" && os.Args[2] != "" {
				output_filename = string(os.Args[2])
			}
		}
	}

	artists := countArtists(tracklist)
	sortedArtists := sortMapByValue(artists)

	selection := sortedArtists[:9]

	db, err := bolt.Open(DATABASE_FILENAME, 0600, nil)
	if err != nil {
		term.OutputError(err.Error())
		os.Exit(2)
	}
	defer db.Close()

	db.Update(func(tx *bolt.Tx) error {
		_, err := tx.CreateBucketIfNotExists(DATABASE_BUCKET)
		if err != nil {
			return fmt.Errorf("create bucket: %s", err)
		}
		return nil
	})

	for i, _ := range selection {
		j := 0
		for !GetCover(db, i, &selection[i]) {
			replacement := sortedArtists[9+i+j]
			term.OutputError(fmt.Sprintf("Replacing with %s", replacement.Artist))
			selection[i] = replacement
			j++
		}
	}

	createImage(selection, output_filename, overlay_filename)
}