mirror of
https://github.com/zhaarey/apple-music-downloader.git
synced 2025-10-23 15:11:05 +00:00
2365 lines
74 KiB
Go
2365 lines
74 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"regexp"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"main/utils/ampapi"
|
|
"main/utils/lyrics"
|
|
"main/utils/runv2"
|
|
"main/utils/runv3"
|
|
"main/utils/structs"
|
|
"main/utils/task"
|
|
|
|
"github.com/AlecAivazis/survey/v2"
|
|
"github.com/fatih/color"
|
|
"github.com/grafov/m3u8"
|
|
"github.com/olekukonko/tablewriter"
|
|
"github.com/spf13/pflag"
|
|
"github.com/zhaarey/go-mp4tag"
|
|
"gopkg.in/yaml.v2"
|
|
)
|
|
|
|
var (
|
|
forbiddenNames = regexp.MustCompile(`[/\\<>:"|?*]`)
|
|
dl_atmos bool
|
|
dl_aac bool
|
|
dl_select bool
|
|
dl_song bool
|
|
artist_select bool
|
|
debug_mode bool
|
|
alac_max *int
|
|
atmos_max *int
|
|
mv_max *int
|
|
mv_audio_type *string
|
|
aac_type *string
|
|
Config structs.ConfigSet
|
|
counter structs.Counter
|
|
okDict = make(map[string][]int)
|
|
)
|
|
|
|
func loadConfig() error {
|
|
data, err := os.ReadFile("config.yaml")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = yaml.Unmarshal(data, &Config)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(Config.Storefront) != 2 {
|
|
Config.Storefront = "us"
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func LimitString(s string) string {
|
|
if len([]rune(s)) > Config.LimitMax {
|
|
return string([]rune(s)[:Config.LimitMax])
|
|
}
|
|
return s
|
|
}
|
|
|
|
func isInArray(arr []int, target int) bool {
|
|
for _, num := range arr {
|
|
if num == target {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func fileExists(path string) (bool, error) {
|
|
f, err := os.Stat(path)
|
|
if err == nil {
|
|
return !f.IsDir(), nil
|
|
} else if os.IsNotExist(err) {
|
|
return false, nil
|
|
}
|
|
return false, err
|
|
}
|
|
|
|
func checkUrl(url string) (string, string) {
|
|
pat := regexp.MustCompile(`^(?:https:\/\/(?:beta\.music|music|classical\.music)\.apple\.com\/(\w{2})(?:\/album|\/album\/.+))\/(?:id)?(\d[^\D]+)(?:$|\?)`)
|
|
matches := pat.FindAllStringSubmatch(url, -1)
|
|
|
|
if matches == nil {
|
|
return "", ""
|
|
} else {
|
|
return matches[0][1], matches[0][2]
|
|
}
|
|
}
|
|
func checkUrlMv(url string) (string, string) {
|
|
pat := regexp.MustCompile(`^(?:https:\/\/(?:beta\.music|music)\.apple\.com\/(\w{2})(?:\/music-video|\/music-video\/.+))\/(?:id)?(\d[^\D]+)(?:$|\?)`)
|
|
matches := pat.FindAllStringSubmatch(url, -1)
|
|
|
|
if matches == nil {
|
|
return "", ""
|
|
} else {
|
|
return matches[0][1], matches[0][2]
|
|
}
|
|
}
|
|
func checkUrlSong(url string) (string, string) {
|
|
pat := regexp.MustCompile(`^(?:https:\/\/(?:beta\.music|music|classical\.music)\.apple\.com\/(\w{2})(?:\/song|\/song\/.+))\/(?:id)?(\d[^\D]+)(?:$|\?)`)
|
|
matches := pat.FindAllStringSubmatch(url, -1)
|
|
|
|
if matches == nil {
|
|
return "", ""
|
|
} else {
|
|
return matches[0][1], matches[0][2]
|
|
}
|
|
}
|
|
func checkUrlPlaylist(url string) (string, string) {
|
|
pat := regexp.MustCompile(`^(?:https:\/\/(?:beta\.music|music|classical\.music)\.apple\.com\/(\w{2})(?:\/playlist|\/playlist\/.+))\/(?:id)?(pl\.[\w-]+)(?:$|\?)`)
|
|
matches := pat.FindAllStringSubmatch(url, -1)
|
|
|
|
if matches == nil {
|
|
return "", ""
|
|
} else {
|
|
return matches[0][1], matches[0][2]
|
|
}
|
|
}
|
|
|
|
func checkUrlStation(url string) (string, string) {
|
|
pat := regexp.MustCompile(`^(?:https:\/\/(?:beta\.music|music)\.apple\.com\/(\w{2})(?:\/station|\/station\/.+))\/(?:id)?(ra\.[\w-]+)(?:$|\?)`)
|
|
matches := pat.FindAllStringSubmatch(url, -1)
|
|
|
|
if matches == nil {
|
|
return "", ""
|
|
} else {
|
|
return matches[0][1], matches[0][2]
|
|
}
|
|
}
|
|
|
|
func checkUrlArtist(url string) (string, string) {
|
|
pat := regexp.MustCompile(`^(?:https:\/\/(?:beta\.music|music|classical\.music)\.apple\.com\/(\w{2})(?:\/artist|\/artist\/.+))\/(?:id)?(\d[^\D]+)(?:$|\?)`)
|
|
matches := pat.FindAllStringSubmatch(url, -1)
|
|
|
|
if matches == nil {
|
|
return "", ""
|
|
} else {
|
|
return matches[0][1], matches[0][2]
|
|
}
|
|
}
|
|
func getUrlSong(songUrl string, token string) (string, error) {
|
|
storefront, songId := checkUrlSong(songUrl)
|
|
manifest, err := ampapi.GetSongResp(storefront, songId, Config.Language, token)
|
|
if err != nil {
|
|
fmt.Println("\u26A0 Failed to get manifest:", err)
|
|
counter.NotSong++
|
|
return "", err
|
|
}
|
|
albumId := manifest.Data[0].Relationships.Albums.Data[0].ID
|
|
songAlbumUrl := fmt.Sprintf("https://music.apple.com/%s/album/1/%s?i=%s", storefront, albumId, songId)
|
|
return songAlbumUrl, nil
|
|
}
|
|
func getUrlArtistName(artistUrl string, token string) (string, string, error) {
|
|
storefront, artistId := checkUrlArtist(artistUrl)
|
|
req, err := http.NewRequest("GET", fmt.Sprintf("https://amp-api.music.apple.com/v1/catalog/%s/artists/%s", storefront, artistId), nil)
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))
|
|
req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36")
|
|
req.Header.Set("Origin", "https://music.apple.com")
|
|
query := url.Values{}
|
|
query.Set("l", Config.Language)
|
|
do, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
defer do.Body.Close()
|
|
if do.StatusCode != http.StatusOK {
|
|
return "", "", errors.New(do.Status)
|
|
}
|
|
obj := new(structs.AutoGeneratedArtist)
|
|
err = json.NewDecoder(do.Body).Decode(&obj)
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
return obj.Data[0].Attributes.Name, obj.Data[0].ID, nil
|
|
}
|
|
|
|
func checkArtist(artistUrl string, token string, relationship string) ([]string, error) {
|
|
storefront, artistId := checkUrlArtist(artistUrl)
|
|
Num := 0
|
|
//id := 1
|
|
var args []string
|
|
var urls []string
|
|
var options [][]string
|
|
for {
|
|
req, err := http.NewRequest("GET", fmt.Sprintf("https://amp-api.music.apple.com/v1/catalog/%s/artists/%s/%s?limit=100&offset=%d&l=%s", storefront, artistId, relationship, Num, Config.Language), nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))
|
|
req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36")
|
|
req.Header.Set("Origin", "https://music.apple.com")
|
|
do, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer do.Body.Close()
|
|
if do.StatusCode != http.StatusOK {
|
|
return nil, errors.New(do.Status)
|
|
}
|
|
obj := new(structs.AutoGeneratedArtist)
|
|
err = json.NewDecoder(do.Body).Decode(&obj)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, album := range obj.Data {
|
|
options = append(options, []string{album.Attributes.Name, album.Attributes.ReleaseDate, album.ID, album.Attributes.URL})
|
|
}
|
|
Num = Num + 100
|
|
if len(obj.Next) == 0 {
|
|
break
|
|
}
|
|
}
|
|
sort.Slice(options, func(i, j int) bool {
|
|
// 将日期字符串解析为 time.Time 类型进行比较
|
|
dateI, _ := time.Parse("2006-01-02", options[i][1])
|
|
dateJ, _ := time.Parse("2006-01-02", options[j][1])
|
|
return dateI.Before(dateJ) // 返回 true 表示 i 在 j 前面
|
|
})
|
|
|
|
table := tablewriter.NewWriter(os.Stdout)
|
|
if relationship == "albums" {
|
|
table.SetHeader([]string{"", "Album Name", "Date", "Album ID"})
|
|
} else if relationship == "music-videos" {
|
|
table.SetHeader([]string{"", "MV Name", "Date", "MV ID"})
|
|
}
|
|
table.SetRowLine(false)
|
|
table.SetHeaderColor(tablewriter.Colors{},
|
|
tablewriter.Colors{tablewriter.FgRedColor, tablewriter.Bold},
|
|
tablewriter.Colors{tablewriter.Bold, tablewriter.FgBlackColor},
|
|
tablewriter.Colors{tablewriter.Bold, tablewriter.FgBlackColor})
|
|
|
|
table.SetColumnColor(tablewriter.Colors{tablewriter.FgCyanColor},
|
|
tablewriter.Colors{tablewriter.Bold, tablewriter.FgRedColor},
|
|
tablewriter.Colors{tablewriter.Bold, tablewriter.FgBlackColor},
|
|
tablewriter.Colors{tablewriter.Bold, tablewriter.FgBlackColor})
|
|
for i, v := range options {
|
|
urls = append(urls, v[3])
|
|
options[i] = append([]string{fmt.Sprint(i + 1)}, v[:3]...)
|
|
table.Append(options[i])
|
|
}
|
|
table.Render()
|
|
if artist_select {
|
|
fmt.Println("You have selected all options:")
|
|
return urls, nil
|
|
}
|
|
reader := bufio.NewReader(os.Stdin)
|
|
fmt.Println("Please select from the " + relationship + " options above (multiple options separated by commas, ranges supported, or type 'all' to select all)")
|
|
cyanColor := color.New(color.FgCyan)
|
|
cyanColor.Print("Enter your choice: ")
|
|
input, _ := reader.ReadString('\n')
|
|
|
|
input = strings.TrimSpace(input)
|
|
if input == "all" {
|
|
fmt.Println("You have selected all options:")
|
|
return urls, nil
|
|
}
|
|
|
|
selectedOptions := [][]string{}
|
|
parts := strings.Split(input, ",")
|
|
for _, part := range parts {
|
|
if strings.Contains(part, "-") {
|
|
rangeParts := strings.Split(part, "-")
|
|
selectedOptions = append(selectedOptions, rangeParts)
|
|
} else {
|
|
selectedOptions = append(selectedOptions, []string{part})
|
|
}
|
|
}
|
|
|
|
fmt.Println("You have selected the following options:")
|
|
for _, opt := range selectedOptions {
|
|
if len(opt) == 1 {
|
|
num, err := strconv.Atoi(opt[0])
|
|
if err != nil {
|
|
fmt.Println("Invalid option:", opt[0])
|
|
continue
|
|
}
|
|
if num > 0 && num <= len(options) {
|
|
fmt.Println(options[num-1])
|
|
args = append(args, urls[num-1])
|
|
} else {
|
|
fmt.Println("Option out of range:", opt[0])
|
|
}
|
|
} else if len(opt) == 2 {
|
|
start, err1 := strconv.Atoi(opt[0])
|
|
end, err2 := strconv.Atoi(opt[1])
|
|
if err1 != nil || err2 != nil {
|
|
fmt.Println("Invalid range:", opt)
|
|
continue
|
|
}
|
|
if start < 1 || end > len(options) || start > end {
|
|
fmt.Println("Range out of range:", opt)
|
|
continue
|
|
}
|
|
for i := start; i <= end; i++ {
|
|
fmt.Println(options[i-1])
|
|
args = append(args, urls[i-1])
|
|
}
|
|
} else {
|
|
fmt.Println("Invalid option:", opt)
|
|
}
|
|
}
|
|
return args, nil
|
|
}
|
|
|
|
func writeCover(sanAlbumFolder, name string, url string) (string, error) {
|
|
originalUrl := url
|
|
var ext string
|
|
var covPath string
|
|
if Config.CoverFormat == "original" {
|
|
ext = strings.Split(url, "/")[len(strings.Split(url, "/"))-2]
|
|
ext = ext[strings.LastIndex(ext, ".")+1:]
|
|
covPath = filepath.Join(sanAlbumFolder, name+"."+ext)
|
|
} else {
|
|
covPath = filepath.Join(sanAlbumFolder, name+"."+Config.CoverFormat)
|
|
}
|
|
exists, err := fileExists(covPath)
|
|
if err != nil {
|
|
fmt.Println("Failed to check if cover exists.")
|
|
return "", err
|
|
}
|
|
if exists {
|
|
_ = os.Remove(covPath)
|
|
}
|
|
if Config.CoverFormat == "png" {
|
|
re := regexp.MustCompile(`\{w\}x\{h\}`)
|
|
parts := re.Split(url, 2)
|
|
url = parts[0] + "{w}x{h}" + strings.Replace(parts[1], ".jpg", ".png", 1)
|
|
}
|
|
url = strings.Replace(url, "{w}x{h}", Config.CoverSize+"x"+Config.CoverSize, 1)
|
|
if Config.CoverFormat == "original" {
|
|
url = strings.Replace(url, "is1-ssl.mzstatic.com/image/thumb", "a5.mzstatic.com/us/r1000/0", 1)
|
|
url = url[:strings.LastIndex(url, "/")]
|
|
}
|
|
req, err := http.NewRequest("GET", url, nil)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36")
|
|
do, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
defer do.Body.Close()
|
|
if do.StatusCode != http.StatusOK {
|
|
if Config.CoverFormat == "original" {
|
|
fmt.Println("Failed to get cover, falling back to " + ext + " url.")
|
|
splitByDot := strings.Split(originalUrl, ".")
|
|
last := splitByDot[len(splitByDot)-1]
|
|
fallback := originalUrl[:len(originalUrl)-len(last)] + ext
|
|
fallback = strings.Replace(fallback, "{w}x{h}", Config.CoverSize+"x"+Config.CoverSize, 1)
|
|
fmt.Println("Fallback URL:", fallback)
|
|
req, err = http.NewRequest("GET", fallback, nil)
|
|
if err != nil {
|
|
fmt.Println("Failed to create request for fallback url.")
|
|
return "", err
|
|
}
|
|
req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36")
|
|
do, err = http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
fmt.Println("Failed to get cover from fallback url.")
|
|
return "", err
|
|
}
|
|
defer do.Body.Close()
|
|
if do.StatusCode != http.StatusOK {
|
|
fmt.Println(fallback)
|
|
return "", errors.New(do.Status)
|
|
}
|
|
} else {
|
|
return "", errors.New(do.Status)
|
|
}
|
|
}
|
|
f, err := os.Create(covPath)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
defer f.Close()
|
|
_, err = io.Copy(f, do.Body)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return covPath, nil
|
|
}
|
|
|
|
func writeLyrics(sanAlbumFolder, filename string, lrc string) error {
|
|
lyricspath := filepath.Join(sanAlbumFolder, filename)
|
|
f, err := os.Create(lyricspath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer f.Close()
|
|
_, err = f.WriteString(lrc)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func contains(slice []string, item string) bool {
|
|
for _, v := range slice {
|
|
if v == item {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// START: New functions for search functionality
|
|
|
|
// SearchResultItem is a unified struct to hold search results for display.
|
|
type SearchResultItem struct {
|
|
Type string
|
|
Name string
|
|
Detail string
|
|
URL string
|
|
ID string
|
|
}
|
|
|
|
// QualityOption holds information about a downloadable quality.
|
|
type QualityOption struct {
|
|
ID string
|
|
Description string
|
|
}
|
|
|
|
// setDlFlags configures the global download flags based on the user's quality selection.
|
|
func setDlFlags(quality string) {
|
|
dl_atmos = false
|
|
dl_aac = false
|
|
|
|
switch quality {
|
|
case "atmos":
|
|
dl_atmos = true
|
|
fmt.Println("Quality set to: Dolby Atmos")
|
|
case "aac":
|
|
dl_aac = true
|
|
*aac_type = "aac"
|
|
fmt.Println("Quality set to: High-Quality (AAC)")
|
|
case "alac":
|
|
fmt.Println("Quality set to: Lossless (ALAC)")
|
|
}
|
|
}
|
|
|
|
// promptForQuality asks the user to select a download quality for the chosen media.
|
|
func promptForQuality(item SearchResultItem, token string) (string, error) {
|
|
if item.Type == "Artist" {
|
|
fmt.Println("Artist selected. Proceeding to list all albums/videos.")
|
|
return "default", nil
|
|
}
|
|
|
|
fmt.Printf("\nFetching available qualities for: %s\n", item.Name)
|
|
|
|
qualities := []QualityOption{
|
|
{ID: "alac", Description: "Lossless (ALAC)"},
|
|
{ID: "aac", Description: "High-Quality (AAC)"},
|
|
{ID: "atmos", Description: "Dolby Atmos"},
|
|
}
|
|
qualityOptions := []string{}
|
|
for _, q := range qualities {
|
|
qualityOptions = append(qualityOptions, q.Description)
|
|
}
|
|
|
|
prompt := &survey.Select{
|
|
Message: "Select a quality to download:",
|
|
Options: qualityOptions,
|
|
PageSize: 5,
|
|
}
|
|
|
|
selectedIndex := 0
|
|
err := survey.AskOne(prompt, &selectedIndex)
|
|
if err != nil {
|
|
// This can happen if the user presses Ctrl+C
|
|
return "", nil
|
|
}
|
|
|
|
return qualities[selectedIndex].ID, nil
|
|
}
|
|
|
|
// handleSearch manages the entire interactive search process.
|
|
func handleSearch(searchType string, queryParts []string, token string) (string, error) {
|
|
query := strings.Join(queryParts, " ")
|
|
validTypes := map[string]bool{"album": true, "song": true, "artist": true}
|
|
if !validTypes[searchType] {
|
|
return "", fmt.Errorf("invalid search type: %s. Use 'album', 'song', or 'artist'", searchType)
|
|
}
|
|
|
|
fmt.Printf("Searching for %ss: \"%s\" in storefront \"%s\"\n", searchType, query, Config.Storefront)
|
|
|
|
offset := 0
|
|
limit := 15 // Increased limit for better navigation
|
|
|
|
apiSearchType := searchType + "s"
|
|
|
|
for {
|
|
searchResp, err := ampapi.Search(Config.Storefront, query, apiSearchType, Config.Language, token, limit, offset)
|
|
if err != nil {
|
|
return "", fmt.Errorf("error fetching search results: %w", err)
|
|
}
|
|
|
|
var items []SearchResultItem
|
|
var displayOptions []string
|
|
hasNext := false
|
|
|
|
// Special options for navigation
|
|
const prevPageOpt = "⬅️ Previous Page"
|
|
const nextPageOpt = "➡️ Next Page"
|
|
|
|
// Add previous page option if applicable
|
|
if offset > 0 {
|
|
displayOptions = append(displayOptions, prevPageOpt)
|
|
}
|
|
|
|
switch searchType {
|
|
case "album":
|
|
if searchResp.Results.Albums != nil {
|
|
for _, item := range searchResp.Results.Albums.Data {
|
|
year := ""
|
|
if len(item.Attributes.ReleaseDate) >= 4 {
|
|
year = item.Attributes.ReleaseDate[:4]
|
|
}
|
|
trackInfo := fmt.Sprintf("%d tracks", item.Attributes.TrackCount)
|
|
detail := fmt.Sprintf("%s (%s, %s)", item.Attributes.ArtistName, year, trackInfo)
|
|
displayOptions = append(displayOptions, fmt.Sprintf("%s - %s", item.Attributes.Name, detail))
|
|
items = append(items, SearchResultItem{Type: "Album", URL: item.Attributes.URL, ID: item.ID})
|
|
}
|
|
hasNext = searchResp.Results.Albums.Next != ""
|
|
}
|
|
case "song":
|
|
if searchResp.Results.Songs != nil {
|
|
for _, item := range searchResp.Results.Songs.Data {
|
|
detail := fmt.Sprintf("%s (%s)", item.Attributes.ArtistName, item.Attributes.AlbumName)
|
|
displayOptions = append(displayOptions, fmt.Sprintf("%s - %s", item.Attributes.Name, detail))
|
|
items = append(items, SearchResultItem{Type: "Song", URL: item.Attributes.URL, ID: item.ID})
|
|
}
|
|
hasNext = searchResp.Results.Songs.Next != ""
|
|
}
|
|
case "artist":
|
|
if searchResp.Results.Artists != nil {
|
|
for _, item := range searchResp.Results.Artists.Data {
|
|
detail := ""
|
|
if len(item.Attributes.GenreNames) > 0 {
|
|
detail = strings.Join(item.Attributes.GenreNames, ", ")
|
|
}
|
|
displayOptions = append(displayOptions, fmt.Sprintf("%s (%s)", item.Attributes.Name, detail))
|
|
items = append(items, SearchResultItem{Type: "Artist", URL: item.Attributes.URL, ID: item.ID})
|
|
}
|
|
hasNext = searchResp.Results.Artists.Next != ""
|
|
}
|
|
}
|
|
|
|
if len(items) == 0 && offset == 0 {
|
|
fmt.Println("No results found.")
|
|
return "", nil
|
|
}
|
|
|
|
// Add next page option if applicable
|
|
if hasNext {
|
|
displayOptions = append(displayOptions, nextPageOpt)
|
|
}
|
|
|
|
prompt := &survey.Select{
|
|
Message: "Use arrow keys to navigate, Enter to select:",
|
|
Options: displayOptions,
|
|
PageSize: limit, // Show a full page of results
|
|
}
|
|
|
|
selectedIndex := 0
|
|
err = survey.AskOne(prompt, &selectedIndex)
|
|
if err != nil {
|
|
// User pressed Ctrl+C
|
|
return "", nil
|
|
}
|
|
|
|
selectedOption := displayOptions[selectedIndex]
|
|
|
|
// Handle pagination
|
|
if selectedOption == nextPageOpt {
|
|
offset += limit
|
|
continue
|
|
}
|
|
if selectedOption == prevPageOpt {
|
|
offset -= limit
|
|
continue
|
|
}
|
|
|
|
// Adjust index to match the `items` slice if "Previous Page" was an option
|
|
itemIndex := selectedIndex
|
|
if offset > 0 {
|
|
itemIndex--
|
|
}
|
|
|
|
selectedItem := items[itemIndex]
|
|
|
|
// Automatically set single song download flag
|
|
if selectedItem.Type == "Song" {
|
|
dl_song = true
|
|
}
|
|
|
|
quality, err := promptForQuality(selectedItem, token)
|
|
if err != nil {
|
|
return "", fmt.Errorf("could not process quality selection: %w", err)
|
|
}
|
|
if quality == "" { // User cancelled quality selection
|
|
fmt.Println("Selection cancelled.")
|
|
return "", nil
|
|
}
|
|
|
|
if quality != "default" {
|
|
setDlFlags(quality)
|
|
}
|
|
|
|
return selectedItem.URL, nil
|
|
}
|
|
}
|
|
|
|
// END: New functions for search functionality
|
|
|
|
func ripTrack(track *task.Track, token string, mediaUserToken string) {
|
|
var err error
|
|
counter.Total++
|
|
fmt.Printf("Track %d of %d: %s\n", track.TaskNum, track.TaskTotal, track.Type)
|
|
//提前获取到的播放列表下track所在的专辑信息
|
|
if track.PreType == "playlists" && Config.UseSongInfoForPlaylist {
|
|
track.GetAlbumData(token)
|
|
}
|
|
//mv dl dev
|
|
if track.Type == "music-videos" {
|
|
if len(mediaUserToken) <= 50 {
|
|
fmt.Println("meida-user-token is not set, skip MV dl")
|
|
counter.Success++
|
|
return
|
|
}
|
|
if _, err := exec.LookPath("mp4decrypt"); err != nil {
|
|
fmt.Println("mp4decrypt is not found, skip MV dl")
|
|
counter.Success++
|
|
return
|
|
}
|
|
err := mvDownloader(track.ID, track.SaveDir, token, track.Storefront, mediaUserToken, track)
|
|
if err != nil {
|
|
fmt.Println("\u26A0 Failed to dl MV:", err)
|
|
counter.Error++
|
|
return
|
|
}
|
|
counter.Success++
|
|
return
|
|
}
|
|
needDlAacLc := false
|
|
if dl_aac && Config.AacType == "aac-lc" {
|
|
needDlAacLc = true
|
|
}
|
|
if track.WebM3u8 == "" && !needDlAacLc {
|
|
if dl_atmos {
|
|
fmt.Println("Unavailable")
|
|
counter.Unavailable++
|
|
return
|
|
}
|
|
fmt.Println("Unavailable, trying to dl aac-lc")
|
|
needDlAacLc = true
|
|
}
|
|
needCheck := false
|
|
|
|
if Config.GetM3u8Mode == "all" {
|
|
needCheck = true
|
|
} else if Config.GetM3u8Mode == "hires" && contains(track.Resp.Attributes.AudioTraits, "hi-res-lossless") {
|
|
needCheck = true
|
|
}
|
|
var EnhancedHls_m3u8 string
|
|
if needCheck && !needDlAacLc {
|
|
EnhancedHls_m3u8, _ = checkM3u8(track.ID, "song")
|
|
if strings.HasSuffix(EnhancedHls_m3u8, ".m3u8") {
|
|
track.DeviceM3u8 = EnhancedHls_m3u8
|
|
track.M3u8 = EnhancedHls_m3u8
|
|
}
|
|
}
|
|
var Quality string
|
|
if strings.Contains(Config.SongFileFormat, "Quality") {
|
|
if dl_atmos {
|
|
Quality = fmt.Sprintf("%dKbps", Config.AtmosMax-2000)
|
|
} else if needDlAacLc {
|
|
Quality = "256Kbps"
|
|
} else {
|
|
_, Quality, err = extractMedia(track.M3u8, true)
|
|
if err != nil {
|
|
fmt.Println("Failed to extract quality from manifest.\n", err)
|
|
counter.Error++
|
|
return
|
|
}
|
|
}
|
|
}
|
|
track.Quality = Quality
|
|
|
|
stringsToJoin := []string{}
|
|
if track.Resp.Attributes.IsAppleDigitalMaster {
|
|
if Config.AppleMasterChoice != "" {
|
|
stringsToJoin = append(stringsToJoin, Config.AppleMasterChoice)
|
|
}
|
|
}
|
|
if track.Resp.Attributes.ContentRating == "explicit" {
|
|
if Config.ExplicitChoice != "" {
|
|
stringsToJoin = append(stringsToJoin, Config.ExplicitChoice)
|
|
}
|
|
}
|
|
if track.Resp.Attributes.ContentRating == "clean" {
|
|
if Config.CleanChoice != "" {
|
|
stringsToJoin = append(stringsToJoin, Config.CleanChoice)
|
|
}
|
|
}
|
|
Tag_string := strings.Join(stringsToJoin, " ")
|
|
|
|
songName := strings.NewReplacer(
|
|
"{SongId}", track.ID,
|
|
"{SongNumer}", fmt.Sprintf("%02d", track.TaskNum),
|
|
"{SongName}", LimitString(track.Resp.Attributes.Name),
|
|
"{DiscNumber}", fmt.Sprintf("%0d", track.Resp.Attributes.DiscNumber),
|
|
"{TrackNumber}", fmt.Sprintf("%0d", track.Resp.Attributes.TrackNumber),
|
|
"{Quality}", Quality,
|
|
"{Tag}", Tag_string,
|
|
"{Codec}", track.Codec,
|
|
).Replace(Config.SongFileFormat)
|
|
fmt.Println(songName)
|
|
filename := fmt.Sprintf("%s.m4a", forbiddenNames.ReplaceAllString(songName, "_"))
|
|
track.SaveName = filename
|
|
trackPath := filepath.Join(track.SaveDir, track.SaveName)
|
|
lrcFilename := fmt.Sprintf("%s.%s", forbiddenNames.ReplaceAllString(songName, "_"), Config.LrcFormat)
|
|
|
|
//get lrc
|
|
var lrc string = ""
|
|
if Config.EmbedLrc || Config.SaveLrcFile {
|
|
lrcStr, err := lyrics.Get(track.Storefront, track.ID, Config.LrcType, Config.Language, Config.LrcFormat, token, mediaUserToken)
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
} else {
|
|
if Config.SaveLrcFile {
|
|
err := writeLyrics(track.SaveDir, lrcFilename, lrcStr)
|
|
if err != nil {
|
|
fmt.Printf("Failed to write lyrics")
|
|
}
|
|
}
|
|
if Config.EmbedLrc {
|
|
lrc = lrcStr
|
|
}
|
|
}
|
|
}
|
|
|
|
exists, err := fileExists(trackPath)
|
|
if err != nil {
|
|
fmt.Println("Failed to check if track exists.")
|
|
}
|
|
if exists {
|
|
fmt.Println("Track already exists locally.")
|
|
counter.Success++
|
|
okDict[track.PreID] = append(okDict[track.PreID], track.TaskNum)
|
|
return
|
|
}
|
|
if needDlAacLc {
|
|
if len(mediaUserToken) <= 50 {
|
|
fmt.Println("Invalid media-user-token")
|
|
counter.Error++
|
|
return
|
|
}
|
|
_, err := runv3.Run(track.ID, trackPath, token, mediaUserToken, false)
|
|
if err != nil {
|
|
fmt.Println("Failed to dl aac-lc:", err)
|
|
if err.Error() == "Unavailable" {
|
|
counter.Unavailable++
|
|
return
|
|
}
|
|
counter.Error++
|
|
return
|
|
}
|
|
} else {
|
|
trackM3u8Url, _, err := extractMedia(track.M3u8, false)
|
|
if err != nil {
|
|
fmt.Println("\u26A0 Failed to extract info from manifest:", err)
|
|
counter.Unavailable++
|
|
return
|
|
}
|
|
//边下载边解密
|
|
err = runv2.Run(track.ID, trackM3u8Url, trackPath, Config)
|
|
if err != nil {
|
|
fmt.Println("Failed to run v2:", err)
|
|
counter.Error++
|
|
return
|
|
}
|
|
}
|
|
tags := []string{
|
|
"tool=",
|
|
fmt.Sprintf("artist=%s", track.Resp.Attributes.ArtistName),
|
|
}
|
|
if Config.EmbedCover {
|
|
if (strings.Contains(track.PreID, "pl.") || strings.Contains(track.PreID, "ra.")) && Config.DlAlbumcoverForPlaylist {
|
|
track.CoverPath, err = writeCover(track.SaveDir, track.ID, track.Resp.Attributes.Artwork.URL)
|
|
if err != nil {
|
|
fmt.Println("Failed to write cover.")
|
|
}
|
|
}
|
|
tags = append(tags, fmt.Sprintf("cover=%s", track.CoverPath))
|
|
}
|
|
tagsString := strings.Join(tags, ":")
|
|
cmd := exec.Command("MP4Box", "-itags", tagsString, trackPath)
|
|
if err := cmd.Run(); err != nil {
|
|
fmt.Printf("Embed failed: %v\n", err)
|
|
counter.Error++
|
|
return
|
|
}
|
|
if (strings.Contains(track.PreID, "pl.") || strings.Contains(track.PreID, "ra.")) && Config.DlAlbumcoverForPlaylist {
|
|
if err := os.Remove(track.CoverPath); err != nil {
|
|
fmt.Printf("Error deleting file: %s\n", track.CoverPath)
|
|
counter.Error++
|
|
return
|
|
}
|
|
}
|
|
track.SavePath = trackPath
|
|
err = writeMP4Tags(track, lrc)
|
|
if err != nil {
|
|
fmt.Println("\u26A0 Failed to write tags in media:", err)
|
|
counter.Unavailable++
|
|
return
|
|
}
|
|
counter.Success++
|
|
okDict[track.PreID] = append(okDict[track.PreID], track.TaskNum)
|
|
}
|
|
|
|
func ripStation(albumId string, token string, storefront string, mediaUserToken string) error {
|
|
station := task.NewStation(storefront, albumId)
|
|
err := station.GetResp(mediaUserToken, token, Config.Language)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
fmt.Println(" -", station.Type)
|
|
meta := station.Resp
|
|
|
|
var Codec string
|
|
if dl_atmos {
|
|
Codec = "ATMOS"
|
|
} else if dl_aac {
|
|
Codec = "AAC"
|
|
} else {
|
|
Codec = "ALAC"
|
|
}
|
|
station.Codec = Codec
|
|
var singerFoldername string
|
|
if Config.ArtistFolderFormat != "" {
|
|
singerFoldername = strings.NewReplacer(
|
|
"{ArtistName}", "Apple Music Station",
|
|
"{ArtistId}", "",
|
|
"{UrlArtistName}", "Apple Music Station",
|
|
).Replace(Config.ArtistFolderFormat)
|
|
if strings.HasSuffix(singerFoldername, ".") {
|
|
singerFoldername = strings.ReplaceAll(singerFoldername, ".", "")
|
|
}
|
|
singerFoldername = strings.TrimSpace(singerFoldername)
|
|
fmt.Println(singerFoldername)
|
|
}
|
|
singerFolder := filepath.Join(Config.AlacSaveFolder, forbiddenNames.ReplaceAllString(singerFoldername, "_"))
|
|
if dl_atmos {
|
|
singerFolder = filepath.Join(Config.AtmosSaveFolder, forbiddenNames.ReplaceAllString(singerFoldername, "_"))
|
|
}
|
|
if dl_aac {
|
|
singerFolder = filepath.Join(Config.AacSaveFolder, forbiddenNames.ReplaceAllString(singerFoldername, "_"))
|
|
}
|
|
os.MkdirAll(singerFolder, os.ModePerm)
|
|
station.SaveDir = singerFolder
|
|
|
|
playlistFolder := strings.NewReplacer(
|
|
"{ArtistName}", "Apple Music Station",
|
|
"{PlaylistName}", LimitString(station.Name),
|
|
"{PlaylistId}", station.ID,
|
|
"{Quality}", "",
|
|
"{Codec}", Codec,
|
|
"{Tag}", "",
|
|
).Replace(Config.PlaylistFolderFormat)
|
|
if strings.HasSuffix(playlistFolder, ".") {
|
|
playlistFolder = strings.ReplaceAll(playlistFolder, ".", "")
|
|
}
|
|
playlistFolder = strings.TrimSpace(playlistFolder)
|
|
playlistFolderPath := filepath.Join(singerFolder, forbiddenNames.ReplaceAllString(playlistFolder, "_"))
|
|
os.MkdirAll(playlistFolderPath, os.ModePerm)
|
|
station.SaveName = playlistFolder
|
|
fmt.Println(playlistFolder)
|
|
|
|
covPath, err := writeCover(playlistFolderPath, "cover", meta.Data[0].Attributes.Artwork.URL)
|
|
if err != nil {
|
|
fmt.Println("Failed to write cover.")
|
|
}
|
|
station.CoverPath = covPath
|
|
|
|
if Config.SaveAnimatedArtwork && meta.Data[0].Attributes.EditorialVideo.MotionSquare.Video != "" {
|
|
fmt.Println("Found Animation Artwork.")
|
|
|
|
motionvideoUrlSquare, err := extractVideo(meta.Data[0].Attributes.EditorialVideo.MotionSquare.Video)
|
|
if err != nil {
|
|
fmt.Println("no motion video square.\n", err)
|
|
} else {
|
|
exists, err := fileExists(filepath.Join(playlistFolderPath, "square_animated_artwork.mp4"))
|
|
if err != nil {
|
|
fmt.Println("Failed to check if animated artwork square exists.")
|
|
}
|
|
if exists {
|
|
fmt.Println("Animated artwork square already exists locally.")
|
|
} else {
|
|
fmt.Println("Animation Artwork Square Downloading...")
|
|
cmd := exec.Command("ffmpeg", "-loglevel", "quiet", "-y", "-i", motionvideoUrlSquare, "-c", "copy", filepath.Join(playlistFolderPath, "square_animated_artwork.mp4"))
|
|
if err := cmd.Run(); err != nil {
|
|
fmt.Printf("animated artwork square dl err: %v\n", err)
|
|
} else {
|
|
fmt.Println("Animation Artwork Square Downloaded")
|
|
}
|
|
}
|
|
}
|
|
|
|
if Config.EmbyAnimatedArtwork {
|
|
cmd3 := exec.Command("ffmpeg", "-i", filepath.Join(playlistFolderPath, "square_animated_artwork.mp4"), "-vf", "scale=440:-1", "-r", "24", "-f", "gif", filepath.Join(playlistFolderPath, "folder.jpg"))
|
|
if err := cmd3.Run(); err != nil {
|
|
fmt.Printf("animated artwork square to gif err: %v\n", err)
|
|
}
|
|
}
|
|
}
|
|
if station.Type == "stream" {
|
|
counter.Total++
|
|
if isInArray(okDict[station.ID], 1) {
|
|
counter.Success++
|
|
return nil
|
|
}
|
|
songName := strings.NewReplacer(
|
|
"{SongId}", station.ID,
|
|
"{SongNumer}", "01",
|
|
"{SongName}", LimitString(station.Name),
|
|
"{DiscNumber}", "1",
|
|
"{TrackNumber}", "1",
|
|
"{Quality}", "256Kbps",
|
|
"{Tag}", "",
|
|
"{Codec}", "AAC",
|
|
).Replace(Config.SongFileFormat)
|
|
fmt.Println(songName)
|
|
trackPath := filepath.Join(playlistFolderPath, fmt.Sprintf("%s.m4a", forbiddenNames.ReplaceAllString(songName, "_")))
|
|
exists, _ := fileExists(trackPath)
|
|
if exists {
|
|
counter.Success++
|
|
okDict[station.ID] = append(okDict[station.ID], 1)
|
|
|
|
fmt.Println("Radio already exists locally.")
|
|
return nil
|
|
}
|
|
assetsUrl, err := ampapi.GetStationAssetsUrl(station.ID, mediaUserToken, token)
|
|
if err != nil {
|
|
fmt.Println("Failed to get station assets url.", err)
|
|
counter.Error++
|
|
return err
|
|
}
|
|
trackM3U8 := strings.ReplaceAll(assetsUrl, "index.m3u8", "256/prog_index.m3u8")
|
|
keyAndUrls, _ := runv3.Run(station.ID, trackM3U8, token, mediaUserToken, true)
|
|
err = runv3.ExtMvData(keyAndUrls, trackPath)
|
|
if err != nil {
|
|
fmt.Println("Failed to download station stream.", err)
|
|
counter.Error++
|
|
return err
|
|
}
|
|
tags := []string{
|
|
"tool=",
|
|
"disk=1/1",
|
|
"track=1",
|
|
"tracknum=1/1",
|
|
fmt.Sprintf("artist=%s", "Apple Music Station"),
|
|
fmt.Sprintf("performer=%s", "Apple Music Station"),
|
|
fmt.Sprintf("album_artist=%s", "Apple Music Station"),
|
|
fmt.Sprintf("album=%s", station.Name),
|
|
fmt.Sprintf("title=%s", station.Name),
|
|
}
|
|
if Config.EmbedCover {
|
|
tags = append(tags, fmt.Sprintf("cover=%s", station.CoverPath))
|
|
}
|
|
tagsString := strings.Join(tags, ":")
|
|
cmd := exec.Command("MP4Box", "-itags", tagsString, trackPath)
|
|
if err := cmd.Run(); err != nil {
|
|
fmt.Printf("Embed failed: %v\n", err)
|
|
}
|
|
counter.Success++
|
|
okDict[station.ID] = append(okDict[station.ID], 1)
|
|
return nil
|
|
}
|
|
|
|
for i := range station.Tracks {
|
|
station.Tracks[i].CoverPath = covPath
|
|
station.Tracks[i].SaveDir = playlistFolderPath
|
|
station.Tracks[i].Codec = Codec
|
|
}
|
|
|
|
trackTotal := len(station.Tracks)
|
|
arr := make([]int, trackTotal)
|
|
for i := 0; i < trackTotal; i++ {
|
|
arr[i] = i + 1
|
|
}
|
|
var selected []int
|
|
|
|
if true {
|
|
selected = arr
|
|
}
|
|
for i := range station.Tracks {
|
|
i++
|
|
if isInArray(selected, i) {
|
|
ripTrack(&station.Tracks[i-1], token, mediaUserToken)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func ripAlbum(albumId string, token string, storefront string, mediaUserToken string, urlArg_i string) error {
|
|
album := task.NewAlbum(storefront, albumId)
|
|
err := album.GetResp(token, Config.Language)
|
|
if err != nil {
|
|
fmt.Println("Failed to get album response.")
|
|
return err
|
|
}
|
|
meta := album.Resp
|
|
if debug_mode {
|
|
fmt.Println(meta.Data[0].Attributes.ArtistName)
|
|
fmt.Println(meta.Data[0].Attributes.Name)
|
|
|
|
for trackNum, track := range meta.Data[0].Relationships.Tracks.Data {
|
|
trackNum++
|
|
fmt.Printf("\nTrack %d of %d:\n", trackNum, len(meta.Data[0].Relationships.Tracks.Data))
|
|
fmt.Printf("%02d. %s\n", trackNum, track.Attributes.Name)
|
|
|
|
manifest, err := ampapi.GetSongResp(storefront, track.ID, album.Language, token)
|
|
if err != nil {
|
|
fmt.Printf("Failed to get manifest for track %d: %v\n", trackNum, err)
|
|
continue
|
|
}
|
|
|
|
var m3u8Url string
|
|
if manifest.Data[0].Attributes.ExtendedAssetUrls.EnhancedHls != "" {
|
|
m3u8Url = manifest.Data[0].Attributes.ExtendedAssetUrls.EnhancedHls
|
|
}
|
|
needCheck := false
|
|
if Config.GetM3u8Mode == "all" {
|
|
needCheck = true
|
|
} else if Config.GetM3u8Mode == "hires" && contains(track.Attributes.AudioTraits, "hi-res-lossless") {
|
|
needCheck = true
|
|
}
|
|
if needCheck {
|
|
fullM3u8Url, err := checkM3u8(track.ID, "song")
|
|
if err == nil && strings.HasSuffix(fullM3u8Url, ".m3u8") {
|
|
m3u8Url = fullM3u8Url
|
|
} else {
|
|
fmt.Println("Failed to get best quality m3u8 from device m3u8 port, will use m3u8 from Web API")
|
|
}
|
|
}
|
|
|
|
_, _, err = extractMedia(m3u8Url, true)
|
|
if err != nil {
|
|
fmt.Printf("Failed to extract quality info for track %d: %v\n", trackNum, err)
|
|
continue
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
var Codec string
|
|
if dl_atmos {
|
|
Codec = "ATMOS"
|
|
} else if dl_aac {
|
|
Codec = "AAC"
|
|
} else {
|
|
Codec = "ALAC"
|
|
}
|
|
album.Codec = Codec
|
|
var singerFoldername string
|
|
if Config.ArtistFolderFormat != "" {
|
|
if len(meta.Data[0].Relationships.Artists.Data) > 0 {
|
|
singerFoldername = strings.NewReplacer(
|
|
"{UrlArtistName}", LimitString(meta.Data[0].Attributes.ArtistName),
|
|
"{ArtistName}", LimitString(meta.Data[0].Attributes.ArtistName),
|
|
"{ArtistId}", meta.Data[0].Relationships.Artists.Data[0].ID,
|
|
).Replace(Config.ArtistFolderFormat)
|
|
} else {
|
|
singerFoldername = strings.NewReplacer(
|
|
"{UrlArtistName}", LimitString(meta.Data[0].Attributes.ArtistName),
|
|
"{ArtistName}", LimitString(meta.Data[0].Attributes.ArtistName),
|
|
"{ArtistId}", "",
|
|
).Replace(Config.ArtistFolderFormat)
|
|
}
|
|
if strings.HasSuffix(singerFoldername, ".") {
|
|
singerFoldername = strings.ReplaceAll(singerFoldername, ".", "")
|
|
}
|
|
singerFoldername = strings.TrimSpace(singerFoldername)
|
|
fmt.Println(singerFoldername)
|
|
}
|
|
singerFolder := filepath.Join(Config.AlacSaveFolder, forbiddenNames.ReplaceAllString(singerFoldername, "_"))
|
|
if dl_atmos {
|
|
singerFolder = filepath.Join(Config.AtmosSaveFolder, forbiddenNames.ReplaceAllString(singerFoldername, "_"))
|
|
}
|
|
if dl_aac {
|
|
singerFolder = filepath.Join(Config.AacSaveFolder, forbiddenNames.ReplaceAllString(singerFoldername, "_"))
|
|
}
|
|
os.MkdirAll(singerFolder, os.ModePerm)
|
|
album.SaveDir = singerFolder
|
|
var Quality string
|
|
if strings.Contains(Config.AlbumFolderFormat, "Quality") {
|
|
if dl_atmos {
|
|
Quality = fmt.Sprintf("%dKbps", Config.AtmosMax-2000)
|
|
} else if dl_aac && Config.AacType == "aac-lc" {
|
|
Quality = "256Kbps"
|
|
} else {
|
|
manifest1, err := ampapi.GetSongResp(storefront, meta.Data[0].Relationships.Tracks.Data[0].ID, album.Language, token)
|
|
if err != nil {
|
|
fmt.Println("Failed to get manifest.\n", err)
|
|
} else {
|
|
if manifest1.Data[0].Attributes.ExtendedAssetUrls.EnhancedHls == "" {
|
|
Codec = "AAC"
|
|
Quality = "256Kbps"
|
|
} else {
|
|
needCheck := false
|
|
|
|
if Config.GetM3u8Mode == "all" {
|
|
needCheck = true
|
|
} else if Config.GetM3u8Mode == "hires" && contains(meta.Data[0].Relationships.Tracks.Data[0].Attributes.AudioTraits, "hi-res-lossless") {
|
|
needCheck = true
|
|
}
|
|
var EnhancedHls_m3u8 string
|
|
if needCheck {
|
|
EnhancedHls_m3u8, _ = checkM3u8(meta.Data[0].Relationships.Tracks.Data[0].ID, "album")
|
|
if strings.HasSuffix(EnhancedHls_m3u8, ".m3u8") {
|
|
manifest1.Data[0].Attributes.ExtendedAssetUrls.EnhancedHls = EnhancedHls_m3u8
|
|
}
|
|
}
|
|
_, Quality, err = extractMedia(manifest1.Data[0].Attributes.ExtendedAssetUrls.EnhancedHls, true)
|
|
if err != nil {
|
|
fmt.Println("Failed to extract quality from manifest.\n", err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
stringsToJoin := []string{}
|
|
if meta.Data[0].Attributes.IsAppleDigitalMaster || meta.Data[0].Attributes.IsMasteredForItunes {
|
|
if Config.AppleMasterChoice != "" {
|
|
stringsToJoin = append(stringsToJoin, Config.AppleMasterChoice)
|
|
}
|
|
}
|
|
if meta.Data[0].Attributes.ContentRating == "explicit" {
|
|
if Config.ExplicitChoice != "" {
|
|
stringsToJoin = append(stringsToJoin, Config.ExplicitChoice)
|
|
}
|
|
}
|
|
if meta.Data[0].Attributes.ContentRating == "clean" {
|
|
if Config.CleanChoice != "" {
|
|
stringsToJoin = append(stringsToJoin, Config.CleanChoice)
|
|
}
|
|
}
|
|
Tag_string := strings.Join(stringsToJoin, " ")
|
|
var albumFolderName string
|
|
albumFolderName = strings.NewReplacer(
|
|
"{ReleaseDate}", meta.Data[0].Attributes.ReleaseDate,
|
|
"{ReleaseYear}", meta.Data[0].Attributes.ReleaseDate[:4],
|
|
"{ArtistName}", LimitString(meta.Data[0].Attributes.ArtistName),
|
|
"{AlbumName}", LimitString(meta.Data[0].Attributes.Name),
|
|
"{UPC}", meta.Data[0].Attributes.Upc,
|
|
"{RecordLabel}", meta.Data[0].Attributes.RecordLabel,
|
|
"{Copyright}", meta.Data[0].Attributes.Copyright,
|
|
"{AlbumId}", albumId,
|
|
"{Quality}", Quality,
|
|
"{Codec}", Codec,
|
|
"{Tag}", Tag_string,
|
|
).Replace(Config.AlbumFolderFormat)
|
|
|
|
if strings.HasSuffix(albumFolderName, ".") {
|
|
albumFolderName = strings.ReplaceAll(albumFolderName, ".", "")
|
|
}
|
|
albumFolderName = strings.TrimSpace(albumFolderName)
|
|
albumFolderPath := filepath.Join(singerFolder, forbiddenNames.ReplaceAllString(albumFolderName, "_"))
|
|
os.MkdirAll(albumFolderPath, os.ModePerm)
|
|
album.SaveName = albumFolderName
|
|
fmt.Println(albumFolderName)
|
|
if Config.SaveArtistCover {
|
|
if len(meta.Data[0].Relationships.Artists.Data) > 0 {
|
|
_, err = writeCover(singerFolder, "folder", meta.Data[0].Relationships.Artists.Data[0].Attributes.Artwork.Url)
|
|
if err != nil {
|
|
fmt.Println("Failed to write artist cover.")
|
|
}
|
|
}
|
|
}
|
|
covPath, err := writeCover(albumFolderPath, "cover", meta.Data[0].Attributes.Artwork.URL)
|
|
if err != nil {
|
|
fmt.Println("Failed to write cover.")
|
|
}
|
|
if Config.SaveAnimatedArtwork && meta.Data[0].Attributes.EditorialVideo.MotionDetailSquare.Video != "" {
|
|
fmt.Println("Found Animation Artwork.")
|
|
|
|
motionvideoUrlSquare, err := extractVideo(meta.Data[0].Attributes.EditorialVideo.MotionDetailSquare.Video)
|
|
if err != nil {
|
|
fmt.Println("no motion video square.\n", err)
|
|
} else {
|
|
exists, err := fileExists(filepath.Join(albumFolderPath, "square_animated_artwork.mp4"))
|
|
if err != nil {
|
|
fmt.Println("Failed to check if animated artwork square exists.")
|
|
}
|
|
if exists {
|
|
fmt.Println("Animated artwork square already exists locally.")
|
|
} else {
|
|
fmt.Println("Animation Artwork Square Downloading...")
|
|
cmd := exec.Command("ffmpeg", "-loglevel", "quiet", "-y", "-i", motionvideoUrlSquare, "-c", "copy", filepath.Join(albumFolderPath, "square_animated_artwork.mp4"))
|
|
if err := cmd.Run(); err != nil {
|
|
fmt.Printf("animated artwork square dl err: %v\n", err)
|
|
} else {
|
|
fmt.Println("Animation Artwork Square Downloaded")
|
|
}
|
|
}
|
|
}
|
|
|
|
if Config.EmbyAnimatedArtwork {
|
|
cmd3 := exec.Command("ffmpeg", "-i", filepath.Join(albumFolderPath, "square_animated_artwork.mp4"), "-vf", "scale=440:-1", "-r", "24", "-f", "gif", filepath.Join(albumFolderPath, "folder.jpg"))
|
|
if err := cmd3.Run(); err != nil {
|
|
fmt.Printf("animated artwork square to gif err: %v\n", err)
|
|
}
|
|
}
|
|
|
|
motionvideoUrlTall, err := extractVideo(meta.Data[0].Attributes.EditorialVideo.MotionDetailTall.Video)
|
|
if err != nil {
|
|
fmt.Println("no motion video tall.\n", err)
|
|
} else {
|
|
exists, err := fileExists(filepath.Join(albumFolderPath, "tall_animated_artwork.mp4"))
|
|
if err != nil {
|
|
fmt.Println("Failed to check if animated artwork tall exists.")
|
|
}
|
|
if exists {
|
|
fmt.Println("Animated artwork tall already exists locally.")
|
|
} else {
|
|
fmt.Println("Animation Artwork Tall Downloading...")
|
|
cmd := exec.Command("ffmpeg", "-loglevel", "quiet", "-y", "-i", motionvideoUrlTall, "-c", "copy", filepath.Join(albumFolderPath, "tall_animated_artwork.mp4"))
|
|
if err := cmd.Run(); err != nil {
|
|
fmt.Printf("animated artwork tall dl err: %v\n", err)
|
|
} else {
|
|
fmt.Println("Animation Artwork Tall Downloaded")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for i := range album.Tracks {
|
|
album.Tracks[i].CoverPath = covPath
|
|
album.Tracks[i].SaveDir = albumFolderPath
|
|
album.Tracks[i].Codec = Codec
|
|
}
|
|
trackTotal := len(meta.Data[0].Relationships.Tracks.Data)
|
|
arr := make([]int, trackTotal)
|
|
for i := 0; i < trackTotal; i++ {
|
|
arr[i] = i + 1
|
|
}
|
|
|
|
if dl_song {
|
|
if urlArg_i == "" {
|
|
} else {
|
|
for i := range album.Tracks {
|
|
if urlArg_i == album.Tracks[i].ID {
|
|
ripTrack(&album.Tracks[i], token, mediaUserToken)
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
var selected []int
|
|
if !dl_select {
|
|
selected = arr
|
|
} else {
|
|
selected = album.ShowSelect()
|
|
}
|
|
for i := range album.Tracks {
|
|
i++
|
|
if isInArray(okDict[albumId], i) {
|
|
counter.Total++
|
|
counter.Success++
|
|
continue
|
|
}
|
|
if isInArray(selected, i) {
|
|
ripTrack(&album.Tracks[i-1], token, mediaUserToken)
|
|
}
|
|
}
|
|
return nil
|
|
|
|
}
|
|
func ripPlaylist(playlistId string, token string, storefront string, mediaUserToken string) error {
|
|
playlist := task.NewPlaylist(storefront, playlistId)
|
|
err := playlist.GetResp(token, Config.Language)
|
|
if err != nil {
|
|
fmt.Println("Failed to get playlist response.")
|
|
return err
|
|
}
|
|
meta := playlist.Resp
|
|
if debug_mode {
|
|
fmt.Println(meta.Data[0].Attributes.ArtistName)
|
|
fmt.Println(meta.Data[0].Attributes.Name)
|
|
|
|
for trackNum, track := range meta.Data[0].Relationships.Tracks.Data {
|
|
trackNum++
|
|
fmt.Printf("\nTrack %d of %d:\n", trackNum, len(meta.Data[0].Relationships.Tracks.Data))
|
|
fmt.Printf("%02d. %s\n", trackNum, track.Attributes.Name)
|
|
|
|
manifest, err := ampapi.GetSongResp(storefront, track.ID, playlist.Language, token)
|
|
if err != nil {
|
|
fmt.Printf("Failed to get manifest for track %d: %v\n", trackNum, err)
|
|
continue
|
|
}
|
|
|
|
var m3u8Url string
|
|
if manifest.Data[0].Attributes.ExtendedAssetUrls.EnhancedHls != "" {
|
|
m3u8Url = manifest.Data[0].Attributes.ExtendedAssetUrls.EnhancedHls
|
|
}
|
|
needCheck := false
|
|
if Config.GetM3u8Mode == "all" {
|
|
needCheck = true
|
|
} else if Config.GetM3u8Mode == "hires" && contains(track.Attributes.AudioTraits, "hi-res-lossless") {
|
|
needCheck = true
|
|
}
|
|
if needCheck {
|
|
fullM3u8Url, err := checkM3u8(track.ID, "song")
|
|
if err == nil && strings.HasSuffix(fullM3u8Url, ".m3u8") {
|
|
m3u8Url = fullM3u8Url
|
|
} else {
|
|
fmt.Println("Failed to get best quality m3u8 from device m3u8 port, will use m3u8 from Web API")
|
|
}
|
|
}
|
|
|
|
_, _, err = extractMedia(m3u8Url, true)
|
|
if err != nil {
|
|
fmt.Printf("Failed to extract quality info for track %d: %v\n", trackNum, err)
|
|
continue
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
var Codec string
|
|
if dl_atmos {
|
|
Codec = "ATMOS"
|
|
} else if dl_aac {
|
|
Codec = "AAC"
|
|
} else {
|
|
Codec = "ALAC"
|
|
}
|
|
playlist.Codec = Codec
|
|
var singerFoldername string
|
|
if Config.ArtistFolderFormat != "" {
|
|
singerFoldername = strings.NewReplacer(
|
|
"{ArtistName}", "Apple Music",
|
|
"{ArtistId}", "",
|
|
"{UrlArtistName}", "Apple Music",
|
|
).Replace(Config.ArtistFolderFormat)
|
|
if strings.HasSuffix(singerFoldername, ".") {
|
|
singerFoldername = strings.ReplaceAll(singerFoldername, ".", "")
|
|
}
|
|
singerFoldername = strings.TrimSpace(singerFoldername)
|
|
fmt.Println(singerFoldername)
|
|
}
|
|
singerFolder := filepath.Join(Config.AlacSaveFolder, forbiddenNames.ReplaceAllString(singerFoldername, "_"))
|
|
if dl_atmos {
|
|
singerFolder = filepath.Join(Config.AtmosSaveFolder, forbiddenNames.ReplaceAllString(singerFoldername, "_"))
|
|
}
|
|
if dl_aac {
|
|
singerFolder = filepath.Join(Config.AacSaveFolder, forbiddenNames.ReplaceAllString(singerFoldername, "_"))
|
|
}
|
|
os.MkdirAll(singerFolder, os.ModePerm)
|
|
playlist.SaveDir = singerFolder
|
|
|
|
var Quality string
|
|
if strings.Contains(Config.AlbumFolderFormat, "Quality") {
|
|
if dl_atmos {
|
|
Quality = fmt.Sprintf("%dKbps", Config.AtmosMax-2000)
|
|
} else if dl_aac && Config.AacType == "aac-lc" {
|
|
Quality = "256Kbps"
|
|
} else {
|
|
manifest1, err := ampapi.GetSongResp(storefront, meta.Data[0].Relationships.Tracks.Data[0].ID, playlist.Language, token)
|
|
if err != nil {
|
|
fmt.Println("Failed to get manifest.\n", err)
|
|
} else {
|
|
if manifest1.Data[0].Attributes.ExtendedAssetUrls.EnhancedHls == "" {
|
|
Codec = "AAC"
|
|
Quality = "256Kbps"
|
|
} else {
|
|
needCheck := false
|
|
|
|
if Config.GetM3u8Mode == "all" {
|
|
needCheck = true
|
|
} else if Config.GetM3u8Mode == "hires" && contains(meta.Data[0].Relationships.Tracks.Data[0].Attributes.AudioTraits, "hi-res-lossless") {
|
|
needCheck = true
|
|
}
|
|
var EnhancedHls_m3u8 string
|
|
if needCheck {
|
|
EnhancedHls_m3u8, _ = checkM3u8(meta.Data[0].Relationships.Tracks.Data[0].ID, "album")
|
|
if strings.HasSuffix(EnhancedHls_m3u8, ".m3u8") {
|
|
manifest1.Data[0].Attributes.ExtendedAssetUrls.EnhancedHls = EnhancedHls_m3u8
|
|
}
|
|
}
|
|
_, Quality, err = extractMedia(manifest1.Data[0].Attributes.ExtendedAssetUrls.EnhancedHls, true)
|
|
if err != nil {
|
|
fmt.Println("Failed to extract quality from manifest.\n", err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
stringsToJoin := []string{}
|
|
if meta.Data[0].Attributes.IsAppleDigitalMaster || meta.Data[0].Attributes.IsMasteredForItunes {
|
|
if Config.AppleMasterChoice != "" {
|
|
stringsToJoin = append(stringsToJoin, Config.AppleMasterChoice)
|
|
}
|
|
}
|
|
if meta.Data[0].Attributes.ContentRating == "explicit" {
|
|
if Config.ExplicitChoice != "" {
|
|
stringsToJoin = append(stringsToJoin, Config.ExplicitChoice)
|
|
}
|
|
}
|
|
if meta.Data[0].Attributes.ContentRating == "clean" {
|
|
if Config.CleanChoice != "" {
|
|
stringsToJoin = append(stringsToJoin, Config.CleanChoice)
|
|
}
|
|
}
|
|
Tag_string := strings.Join(stringsToJoin, " ")
|
|
playlistFolder := strings.NewReplacer(
|
|
"{ArtistName}", "Apple Music",
|
|
"{PlaylistName}", LimitString(meta.Data[0].Attributes.Name),
|
|
"{PlaylistId}", playlistId,
|
|
"{Quality}", Quality,
|
|
"{Codec}", Codec,
|
|
"{Tag}", Tag_string,
|
|
).Replace(Config.PlaylistFolderFormat)
|
|
if strings.HasSuffix(playlistFolder, ".") {
|
|
playlistFolder = strings.ReplaceAll(playlistFolder, ".", "")
|
|
}
|
|
playlistFolder = strings.TrimSpace(playlistFolder)
|
|
playlistFolderPath := filepath.Join(singerFolder, forbiddenNames.ReplaceAllString(playlistFolder, "_"))
|
|
os.MkdirAll(playlistFolderPath, os.ModePerm)
|
|
playlist.SaveName = playlistFolder
|
|
fmt.Println(playlistFolder)
|
|
covPath, err := writeCover(playlistFolderPath, "cover", meta.Data[0].Attributes.Artwork.URL)
|
|
if err != nil {
|
|
fmt.Println("Failed to write cover.")
|
|
}
|
|
|
|
for i := range playlist.Tracks {
|
|
playlist.Tracks[i].CoverPath = covPath
|
|
playlist.Tracks[i].SaveDir = playlistFolderPath
|
|
playlist.Tracks[i].Codec = Codec
|
|
}
|
|
|
|
if Config.SaveAnimatedArtwork && meta.Data[0].Attributes.EditorialVideo.MotionDetailSquare.Video != "" {
|
|
fmt.Println("Found Animation Artwork.")
|
|
|
|
motionvideoUrlSquare, err := extractVideo(meta.Data[0].Attributes.EditorialVideo.MotionDetailSquare.Video)
|
|
if err != nil {
|
|
fmt.Println("no motion video square.\n", err)
|
|
} else {
|
|
exists, err := fileExists(filepath.Join(playlistFolderPath, "square_animated_artwork.mp4"))
|
|
if err != nil {
|
|
fmt.Println("Failed to check if animated artwork square exists.")
|
|
}
|
|
if exists {
|
|
fmt.Println("Animated artwork square already exists locally.")
|
|
} else {
|
|
fmt.Println("Animation Artwork Square Downloading...")
|
|
cmd := exec.Command("ffmpeg", "-loglevel", "quiet", "-y", "-i", motionvideoUrlSquare, "-c", "copy", filepath.Join(playlistFolderPath, "square_animated_artwork.mp4"))
|
|
if err := cmd.Run(); err != nil {
|
|
fmt.Printf("animated artwork square dl err: %v\n", err)
|
|
} else {
|
|
fmt.Println("Animation Artwork Square Downloaded")
|
|
}
|
|
}
|
|
}
|
|
|
|
if Config.EmbyAnimatedArtwork {
|
|
cmd3 := exec.Command("ffmpeg", "-i", filepath.Join(playlistFolderPath, "square_animated_artwork.mp4"), "-vf", "scale=440:-1", "-r", "24", "-f", "gif", filepath.Join(playlistFolderPath, "folder.jpg"))
|
|
if err := cmd3.Run(); err != nil {
|
|
fmt.Printf("animated artwork square to gif err: %v\n", err)
|
|
}
|
|
}
|
|
|
|
motionvideoUrlTall, err := extractVideo(meta.Data[0].Attributes.EditorialVideo.MotionDetailTall.Video)
|
|
if err != nil {
|
|
fmt.Println("no motion video tall.\n", err)
|
|
} else {
|
|
exists, err := fileExists(filepath.Join(playlistFolderPath, "tall_animated_artwork.mp4"))
|
|
if err != nil {
|
|
fmt.Println("Failed to check if animated artwork tall exists.")
|
|
}
|
|
if exists {
|
|
fmt.Println("Animated artwork tall already exists locally.")
|
|
} else {
|
|
fmt.Println("Animation Artwork Tall Downloading...")
|
|
cmd := exec.Command("ffmpeg", "-loglevel", "quiet", "-y", "-i", motionvideoUrlTall, "-c", "copy", filepath.Join(playlistFolderPath, "tall_animated_artwork.mp4"))
|
|
if err := cmd.Run(); err != nil {
|
|
fmt.Printf("animated artwork tall dl err: %v\n", err)
|
|
} else {
|
|
fmt.Println("Animation Artwork Tall Downloaded")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
trackTotal := len(meta.Data[0].Relationships.Tracks.Data)
|
|
arr := make([]int, trackTotal)
|
|
for i := 0; i < trackTotal; i++ {
|
|
arr[i] = i + 1
|
|
}
|
|
var selected []int
|
|
|
|
if !dl_select {
|
|
selected = arr
|
|
} else {
|
|
selected = playlist.ShowSelect()
|
|
}
|
|
for i := range playlist.Tracks {
|
|
i++
|
|
if isInArray(okDict[playlistId], i) {
|
|
counter.Total++
|
|
counter.Success++
|
|
continue
|
|
}
|
|
if isInArray(selected, i) {
|
|
ripTrack(&playlist.Tracks[i-1], token, mediaUserToken)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func writeMP4Tags(track *task.Track, lrc string) error {
|
|
t := &mp4tag.MP4Tags{
|
|
Title: track.Resp.Attributes.Name,
|
|
TitleSort: track.Resp.Attributes.Name,
|
|
Artist: track.Resp.Attributes.ArtistName,
|
|
ArtistSort: track.Resp.Attributes.ArtistName,
|
|
Custom: map[string]string{
|
|
"PERFORMER": track.Resp.Attributes.ArtistName,
|
|
"RELEASETIME": track.Resp.Attributes.ReleaseDate,
|
|
"ISRC": track.Resp.Attributes.Isrc,
|
|
"LABEL": "",
|
|
"UPC": "",
|
|
},
|
|
Composer: track.Resp.Attributes.ComposerName,
|
|
ComposerSort: track.Resp.Attributes.ComposerName,
|
|
CustomGenre: track.Resp.Attributes.GenreNames[0],
|
|
Lyrics: lrc,
|
|
TrackNumber: int16(track.Resp.Attributes.TrackNumber),
|
|
DiscNumber: int16(track.Resp.Attributes.DiscNumber),
|
|
Album: track.Resp.Attributes.AlbumName,
|
|
AlbumSort: track.Resp.Attributes.AlbumName,
|
|
}
|
|
|
|
if track.PreType == "albums" {
|
|
albumID, err := strconv.ParseUint(track.PreID, 10, 32)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.ItunesAlbumID = int32(albumID)
|
|
}
|
|
|
|
if len(track.Resp.Relationships.Artists.Data) > 0 {
|
|
artistID, err := strconv.ParseUint(track.Resp.Relationships.Artists.Data[0].ID, 10, 32)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.ItunesArtistID = int32(artistID)
|
|
}
|
|
|
|
if (track.PreType == "playlists" || track.PreType == "stations") && !Config.UseSongInfoForPlaylist {
|
|
t.DiscNumber = 1
|
|
t.DiscTotal = 1
|
|
t.TrackNumber = int16(track.TaskNum)
|
|
t.TrackTotal = int16(track.TaskTotal)
|
|
t.Album = track.PlaylistData.Attributes.Name
|
|
t.AlbumSort = track.PlaylistData.Attributes.Name
|
|
t.AlbumArtist = track.PlaylistData.Attributes.ArtistName
|
|
t.AlbumArtistSort = track.PlaylistData.Attributes.ArtistName
|
|
} else if (track.PreType == "playlists" || track.PreType == "stations") && Config.UseSongInfoForPlaylist {
|
|
t.DiscTotal = int16(track.DiscTotal)
|
|
t.TrackTotal = int16(track.AlbumData.Attributes.TrackCount)
|
|
t.AlbumArtist = track.AlbumData.Attributes.ArtistName
|
|
t.AlbumArtistSort = track.AlbumData.Attributes.ArtistName
|
|
t.Custom["UPC"] = track.AlbumData.Attributes.Upc
|
|
t.Custom["LABEL"] = track.AlbumData.Attributes.RecordLabel
|
|
t.Date = track.AlbumData.Attributes.ReleaseDate
|
|
t.Copyright = track.AlbumData.Attributes.Copyright
|
|
t.Publisher = track.AlbumData.Attributes.RecordLabel
|
|
} else {
|
|
t.DiscTotal = int16(track.DiscTotal)
|
|
t.TrackTotal = int16(track.AlbumData.Attributes.TrackCount)
|
|
t.AlbumArtist = track.AlbumData.Attributes.ArtistName
|
|
t.AlbumArtistSort = track.AlbumData.Attributes.ArtistName
|
|
t.Custom["UPC"] = track.AlbumData.Attributes.Upc
|
|
t.Date = track.AlbumData.Attributes.ReleaseDate
|
|
t.Copyright = track.AlbumData.Attributes.Copyright
|
|
t.Publisher = track.AlbumData.Attributes.RecordLabel
|
|
}
|
|
|
|
if track.Resp.Attributes.ContentRating == "explicit" {
|
|
t.ItunesAdvisory = mp4tag.ItunesAdvisoryExplicit
|
|
} else if track.Resp.Attributes.ContentRating == "clean" {
|
|
t.ItunesAdvisory = mp4tag.ItunesAdvisoryClean
|
|
} else {
|
|
t.ItunesAdvisory = mp4tag.ItunesAdvisoryNone
|
|
}
|
|
|
|
mp4, err := mp4tag.Open(track.SavePath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer mp4.Close()
|
|
err = mp4.Write(t, []string{})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func main() {
|
|
err := loadConfig()
|
|
if err != nil {
|
|
fmt.Printf("load Config failed: %v", err)
|
|
return
|
|
}
|
|
token, err := ampapi.GetToken()
|
|
if err != nil {
|
|
if Config.AuthorizationToken != "" && Config.AuthorizationToken != "your-authorization-token" {
|
|
token = strings.Replace(Config.AuthorizationToken, "Bearer ", "", -1)
|
|
} else {
|
|
fmt.Println("Failed to get token.")
|
|
return
|
|
}
|
|
}
|
|
var search_type string
|
|
pflag.StringVar(&search_type, "search", "", "Search for 'album', 'song', or 'artist'. Provide query after flags.")
|
|
pflag.BoolVar(&dl_atmos, "atmos", false, "Enable atmos download mode")
|
|
pflag.BoolVar(&dl_aac, "aac", false, "Enable adm-aac download mode")
|
|
pflag.BoolVar(&dl_select, "select", false, "Enable selective download")
|
|
pflag.BoolVar(&dl_song, "song", false, "Enable single song download mode")
|
|
pflag.BoolVar(&artist_select, "all-album", false, "Download all artist albums")
|
|
pflag.BoolVar(&debug_mode, "debug", false, "Enable debug mode to show audio quality information")
|
|
alac_max = pflag.Int("alac-max", Config.AlacMax, "Specify the max quality for download alac")
|
|
atmos_max = pflag.Int("atmos-max", Config.AtmosMax, "Specify the max quality for download atmos")
|
|
aac_type = pflag.String("aac-type", Config.AacType, "Select AAC type, aac aac-binaural aac-downmix")
|
|
mv_audio_type = pflag.String("mv-audio-type", Config.MVAudioType, "Select MV audio type, atmos ac3 aac")
|
|
mv_max = pflag.Int("mv-max", Config.MVMax, "Specify the max quality for download MV")
|
|
|
|
pflag.Usage = func() {
|
|
fmt.Fprintf(os.Stderr, "Usage: %s [options] [url1 url2 ...]\n", "[main | main.exe | go run main.go]")
|
|
fmt.Fprintf(os.Stderr, "Search Usage: %s --search [album|song|artist] [query]\n", "[main | main.exe | go run main.go]")
|
|
fmt.Println("\nOptions:")
|
|
pflag.PrintDefaults()
|
|
}
|
|
|
|
pflag.Parse()
|
|
Config.AlacMax = *alac_max
|
|
Config.AtmosMax = *atmos_max
|
|
Config.AacType = *aac_type
|
|
Config.MVAudioType = *mv_audio_type
|
|
Config.MVMax = *mv_max
|
|
|
|
args := pflag.Args()
|
|
|
|
if search_type != "" {
|
|
if len(args) == 0 {
|
|
fmt.Println("Error: --search flag requires a query.")
|
|
pflag.Usage()
|
|
return
|
|
}
|
|
selectedUrl, err := handleSearch(search_type, args, token)
|
|
if err != nil {
|
|
fmt.Printf("\nSearch process failed: %v\n", err)
|
|
return
|
|
}
|
|
if selectedUrl == "" {
|
|
fmt.Println("\nExiting.")
|
|
return
|
|
}
|
|
os.Args = []string{selectedUrl}
|
|
} else {
|
|
if len(args) == 0 {
|
|
fmt.Println("No URLs provided. Please provide at least one URL.")
|
|
pflag.Usage()
|
|
return
|
|
}
|
|
os.Args = args
|
|
}
|
|
|
|
if strings.Contains(os.Args[0], "/artist/") {
|
|
urlArtistName, urlArtistID, err := getUrlArtistName(os.Args[0], token)
|
|
if err != nil {
|
|
fmt.Println("Failed to get artistname.")
|
|
return
|
|
}
|
|
Config.ArtistFolderFormat = strings.NewReplacer(
|
|
"{UrlArtistName}", LimitString(urlArtistName),
|
|
"{ArtistId}", urlArtistID,
|
|
).Replace(Config.ArtistFolderFormat)
|
|
albumArgs, err := checkArtist(os.Args[0], token, "albums")
|
|
if err != nil {
|
|
fmt.Println("Failed to get artist albums.")
|
|
return
|
|
}
|
|
mvArgs, err := checkArtist(os.Args[0], token, "music-videos")
|
|
if err != nil {
|
|
fmt.Println("Failed to get artist music-videos.")
|
|
}
|
|
os.Args = append(albumArgs, mvArgs...)
|
|
}
|
|
albumTotal := len(os.Args)
|
|
for {
|
|
for albumNum, urlRaw := range os.Args {
|
|
fmt.Printf("Queue %d of %d: ", albumNum+1, albumTotal)
|
|
var storefront, albumId string
|
|
|
|
if strings.Contains(urlRaw, "/music-video/") {
|
|
fmt.Println("Music Video")
|
|
if debug_mode {
|
|
continue
|
|
}
|
|
counter.Total++
|
|
if len(Config.MediaUserToken) <= 50 {
|
|
fmt.Println(": meida-user-token is not set, skip MV dl")
|
|
counter.Success++
|
|
continue
|
|
}
|
|
if _, err := exec.LookPath("mp4decrypt"); err != nil {
|
|
fmt.Println(": mp4decrypt is not found, skip MV dl")
|
|
counter.Success++
|
|
continue
|
|
}
|
|
mvSaveDir := strings.NewReplacer(
|
|
"{ArtistName}", "",
|
|
"{UrlArtistName}", "",
|
|
"{ArtistId}", "",
|
|
).Replace(Config.ArtistFolderFormat)
|
|
if mvSaveDir != "" {
|
|
mvSaveDir = filepath.Join(Config.AlacSaveFolder, forbiddenNames.ReplaceAllString(mvSaveDir, "_"))
|
|
} else {
|
|
mvSaveDir = Config.AlacSaveFolder
|
|
}
|
|
storefront, albumId = checkUrlMv(urlRaw)
|
|
err := mvDownloader(albumId, mvSaveDir, token, storefront, Config.MediaUserToken, nil)
|
|
if err != nil {
|
|
fmt.Println("\u26A0 Failed to dl MV:", err)
|
|
counter.Error++
|
|
continue
|
|
}
|
|
counter.Success++
|
|
continue
|
|
}
|
|
if strings.Contains(urlRaw, "/song/") {
|
|
fmt.Printf("Song->")
|
|
storefront, songId := checkUrlSong(urlRaw)
|
|
if storefront == "" || songId == "" {
|
|
fmt.Println("Invalid song URL format.")
|
|
continue
|
|
}
|
|
err := ripSong(songId, token, storefront, Config.MediaUserToken)
|
|
if err != nil {
|
|
fmt.Println("Failed to rip song:", err)
|
|
}
|
|
continue
|
|
}
|
|
parse, err := url.Parse(urlRaw)
|
|
if err != nil {
|
|
log.Fatalf("Invalid URL: %v", err)
|
|
}
|
|
var urlArg_i = parse.Query().Get("i")
|
|
|
|
if strings.Contains(urlRaw, "/album/") {
|
|
fmt.Println("Album")
|
|
storefront, albumId = checkUrl(urlRaw)
|
|
err := ripAlbum(albumId, token, storefront, Config.MediaUserToken, urlArg_i)
|
|
if err != nil {
|
|
fmt.Println("Failed to rip album:", err)
|
|
}
|
|
} else if strings.Contains(urlRaw, "/playlist/") {
|
|
fmt.Println("Playlist")
|
|
storefront, albumId = checkUrlPlaylist(urlRaw)
|
|
err := ripPlaylist(albumId, token, storefront, Config.MediaUserToken)
|
|
if err != nil {
|
|
fmt.Println("Failed to rip playlist:", err)
|
|
}
|
|
} else if strings.Contains(urlRaw, "/station/") {
|
|
fmt.Printf("Station")
|
|
storefront, albumId = checkUrlStation(urlRaw)
|
|
if len(Config.MediaUserToken) <= 50 {
|
|
fmt.Println(": meida-user-token is not set, skip station dl")
|
|
continue
|
|
}
|
|
err := ripStation(albumId, token, storefront, Config.MediaUserToken)
|
|
if err != nil {
|
|
fmt.Println("Failed to rip station:", err)
|
|
}
|
|
} else {
|
|
fmt.Println("Invalid type")
|
|
}
|
|
}
|
|
fmt.Printf("======= [\u2714 ] Completed: %d/%d | [\u26A0 ] Warnings: %d | [\u2716 ] Errors: %d =======\n", counter.Success, counter.Total, counter.Unavailable+counter.NotSong, counter.Error)
|
|
if counter.Error == 0 {
|
|
break
|
|
}
|
|
fmt.Println("Error detected, press Enter to try again...")
|
|
fmt.Scanln()
|
|
fmt.Println("Start trying again...")
|
|
counter = structs.Counter{}
|
|
}
|
|
}
|
|
|
|
func mvDownloader(adamID string, saveDir string, token string, storefront string, mediaUserToken string, track *task.Track) error {
|
|
MVInfo, err := ampapi.GetMusicVideoResp(storefront, adamID, Config.Language, token)
|
|
if err != nil {
|
|
fmt.Println("\u26A0 Failed to get MV manifest:", err)
|
|
return nil
|
|
}
|
|
|
|
if strings.HasSuffix(saveDir, ".") {
|
|
saveDir = strings.ReplaceAll(saveDir, ".", "")
|
|
}
|
|
saveDir = strings.TrimSpace(saveDir)
|
|
|
|
vidPath := filepath.Join(saveDir, fmt.Sprintf("%s_vid.mp4", adamID))
|
|
audPath := filepath.Join(saveDir, fmt.Sprintf("%s_aud.mp4", adamID))
|
|
mvSaveName := fmt.Sprintf("%s (%s)", MVInfo.Data[0].Attributes.Name, adamID)
|
|
if track != nil {
|
|
mvSaveName = fmt.Sprintf("%02d. %s", track.TaskNum, MVInfo.Data[0].Attributes.Name)
|
|
}
|
|
|
|
mvOutPath := filepath.Join(saveDir, fmt.Sprintf("%s.mp4", forbiddenNames.ReplaceAllString(mvSaveName, "_")))
|
|
|
|
fmt.Println(MVInfo.Data[0].Attributes.Name)
|
|
|
|
exists, _ := fileExists(mvOutPath)
|
|
if exists {
|
|
fmt.Println("MV already exists locally.")
|
|
return nil
|
|
}
|
|
|
|
mvm3u8url, _, _ := runv3.GetWebplayback(adamID, token, mediaUserToken, true)
|
|
if mvm3u8url == "" {
|
|
return errors.New("media-user-token may wrong or expired")
|
|
}
|
|
|
|
os.MkdirAll(saveDir, os.ModePerm)
|
|
videom3u8url, _ := extractVideo(mvm3u8url)
|
|
videokeyAndUrls, _ := runv3.Run(adamID, videom3u8url, token, mediaUserToken, true)
|
|
_ = runv3.ExtMvData(videokeyAndUrls, vidPath)
|
|
audiom3u8url, _ := extractMvAudio(mvm3u8url)
|
|
audiokeyAndUrls, _ := runv3.Run(adamID, audiom3u8url, token, mediaUserToken, true)
|
|
_ = runv3.ExtMvData(audiokeyAndUrls, audPath)
|
|
|
|
tags := []string{
|
|
"tool=",
|
|
fmt.Sprintf("artist=%s", MVInfo.Data[0].Attributes.ArtistName),
|
|
fmt.Sprintf("title=%s", MVInfo.Data[0].Attributes.Name),
|
|
fmt.Sprintf("genre=%s", MVInfo.Data[0].Attributes.GenreNames[0]),
|
|
fmt.Sprintf("created=%s", MVInfo.Data[0].Attributes.ReleaseDate),
|
|
fmt.Sprintf("ISRC=%s", MVInfo.Data[0].Attributes.Isrc),
|
|
}
|
|
|
|
if MVInfo.Data[0].Attributes.ContentRating == "explicit" {
|
|
tags = append(tags, "rating=1")
|
|
} else if MVInfo.Data[0].Attributes.ContentRating == "clean" {
|
|
tags = append(tags, "rating=2")
|
|
} else {
|
|
tags = append(tags, "rating=0")
|
|
}
|
|
|
|
if track != nil {
|
|
if track.PreType == "playlists" && !Config.UseSongInfoForPlaylist {
|
|
tags = append(tags, "disk=1/1")
|
|
tags = append(tags, fmt.Sprintf("album=%s", track.PlaylistData.Attributes.Name))
|
|
tags = append(tags, fmt.Sprintf("track=%d", track.TaskNum))
|
|
tags = append(tags, fmt.Sprintf("tracknum=%d/%d", track.TaskNum, track.TaskTotal))
|
|
tags = append(tags, fmt.Sprintf("album_artist=%s", track.PlaylistData.Attributes.ArtistName))
|
|
tags = append(tags, fmt.Sprintf("performer=%s", track.Resp.Attributes.ArtistName))
|
|
} else if track.PreType == "playlists" && Config.UseSongInfoForPlaylist {
|
|
tags = append(tags, fmt.Sprintf("album=%s", track.AlbumData.Attributes.Name))
|
|
tags = append(tags, fmt.Sprintf("disk=%d/%d", track.Resp.Attributes.DiscNumber, track.DiscTotal))
|
|
tags = append(tags, fmt.Sprintf("track=%d", track.Resp.Attributes.TrackNumber))
|
|
tags = append(tags, fmt.Sprintf("tracknum=%d/%d", track.Resp.Attributes.TrackNumber, track.AlbumData.Attributes.TrackCount))
|
|
tags = append(tags, fmt.Sprintf("album_artist=%s", track.AlbumData.Attributes.ArtistName))
|
|
tags = append(tags, fmt.Sprintf("performer=%s", track.Resp.Attributes.ArtistName))
|
|
tags = append(tags, fmt.Sprintf("copyright=%s", track.AlbumData.Attributes.Copyright))
|
|
tags = append(tags, fmt.Sprintf("UPC=%s", track.AlbumData.Attributes.Upc))
|
|
} else {
|
|
tags = append(tags, fmt.Sprintf("album=%s", track.AlbumData.Attributes.Name))
|
|
tags = append(tags, fmt.Sprintf("disk=%d/%d", track.Resp.Attributes.DiscNumber, track.DiscTotal))
|
|
tags = append(tags, fmt.Sprintf("track=%d", track.Resp.Attributes.TrackNumber))
|
|
tags = append(tags, fmt.Sprintf("tracknum=%d/%d", track.Resp.Attributes.TrackNumber, track.AlbumData.Attributes.TrackCount))
|
|
tags = append(tags, fmt.Sprintf("album_artist=%s", track.AlbumData.Attributes.ArtistName))
|
|
tags = append(tags, fmt.Sprintf("performer=%s", track.Resp.Attributes.ArtistName))
|
|
tags = append(tags, fmt.Sprintf("copyright=%s", track.AlbumData.Attributes.Copyright))
|
|
tags = append(tags, fmt.Sprintf("UPC=%s", track.AlbumData.Attributes.Upc))
|
|
}
|
|
} else {
|
|
tags = append(tags, fmt.Sprintf("album=%s", MVInfo.Data[0].Attributes.AlbumName))
|
|
tags = append(tags, fmt.Sprintf("disk=%d", MVInfo.Data[0].Attributes.DiscNumber))
|
|
tags = append(tags, fmt.Sprintf("track=%d", MVInfo.Data[0].Attributes.TrackNumber))
|
|
tags = append(tags, fmt.Sprintf("tracknum=%d", MVInfo.Data[0].Attributes.TrackNumber))
|
|
tags = append(tags, fmt.Sprintf("performer=%s", MVInfo.Data[0].Attributes.ArtistName))
|
|
}
|
|
|
|
var covPath string
|
|
if true {
|
|
thumbURL := MVInfo.Data[0].Attributes.Artwork.URL
|
|
baseThumbName := forbiddenNames.ReplaceAllString(mvSaveName, "_") + "_thumbnail"
|
|
covPath, err = writeCover(saveDir, baseThumbName, thumbURL)
|
|
if err != nil {
|
|
fmt.Println("Failed to save MV thumbnail:", err)
|
|
} else {
|
|
tags = append(tags, fmt.Sprintf("cover=%s", covPath))
|
|
}
|
|
}
|
|
|
|
tagsString := strings.Join(tags, ":")
|
|
muxCmd := exec.Command("MP4Box", "-itags", tagsString, "-quiet", "-add", vidPath, "-add", audPath, "-keep-utc", "-new", mvOutPath)
|
|
fmt.Printf("MV Remuxing...")
|
|
if err := muxCmd.Run(); err != nil {
|
|
fmt.Printf("MV mux failed: %v\n", err)
|
|
return err
|
|
}
|
|
fmt.Printf("\rMV Remuxed. \n")
|
|
defer os.Remove(vidPath)
|
|
defer os.Remove(audPath)
|
|
defer os.Remove(covPath)
|
|
|
|
return nil
|
|
}
|
|
|
|
func extractMvAudio(c string) (string, error) {
|
|
MediaUrl, err := url.Parse(c)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
resp, err := http.Get(c)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return "", errors.New(resp.Status)
|
|
}
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
audioString := string(body)
|
|
from, listType, err := m3u8.DecodeFrom(strings.NewReader(audioString), true)
|
|
if err != nil || listType != m3u8.MASTER {
|
|
return "", errors.New("m3u8 not of media type")
|
|
}
|
|
|
|
audio := from.(*m3u8.MasterPlaylist)
|
|
|
|
var audioPriority = []string{"audio-atmos", "audio-ac3", "audio-stereo-256"}
|
|
if Config.MVAudioType == "ac3" {
|
|
audioPriority = []string{"audio-ac3", "audio-stereo-256"}
|
|
} else if Config.MVAudioType == "aac" {
|
|
audioPriority = []string{"audio-stereo-256"}
|
|
}
|
|
|
|
re := regexp.MustCompile(`_gr(\d+)_`)
|
|
|
|
type AudioStream struct {
|
|
URL string
|
|
Rank int
|
|
GroupID string
|
|
}
|
|
var audioStreams []AudioStream
|
|
|
|
for _, variant := range audio.Variants {
|
|
for _, audiov := range variant.Alternatives {
|
|
if audiov.URI != "" {
|
|
for _, priority := range audioPriority {
|
|
if audiov.GroupId == priority {
|
|
matches := re.FindStringSubmatch(audiov.URI)
|
|
if len(matches) == 2 {
|
|
var rank int
|
|
fmt.Sscanf(matches[1], "%d", &rank)
|
|
streamUrl, _ := MediaUrl.Parse(audiov.URI)
|
|
audioStreams = append(audioStreams, AudioStream{
|
|
URL: streamUrl.String(),
|
|
Rank: rank,
|
|
GroupID: audiov.GroupId,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(audioStreams) == 0 {
|
|
return "", errors.New("no suitable audio stream found")
|
|
}
|
|
|
|
sort.Slice(audioStreams, func(i, j int) bool {
|
|
return audioStreams[i].Rank > audioStreams[j].Rank
|
|
})
|
|
fmt.Println("Audio: " + audioStreams[0].GroupID)
|
|
return audioStreams[0].URL, nil
|
|
}
|
|
|
|
func checkM3u8(b string, f string) (string, error) {
|
|
var EnhancedHls string
|
|
if Config.GetM3u8FromDevice {
|
|
adamID := b
|
|
conn, err := net.Dial("tcp", Config.GetM3u8Port)
|
|
if err != nil {
|
|
fmt.Println("Error connecting to device:", err)
|
|
return "none", err
|
|
}
|
|
defer conn.Close()
|
|
if f == "song" {
|
|
fmt.Println("Connected to device")
|
|
}
|
|
|
|
adamIDBuffer := []byte(adamID)
|
|
lengthBuffer := []byte{byte(len(adamIDBuffer))}
|
|
|
|
_, err = conn.Write(lengthBuffer)
|
|
if err != nil {
|
|
fmt.Println("Error writing length to device:", err)
|
|
return "none", err
|
|
}
|
|
|
|
_, err = conn.Write(adamIDBuffer)
|
|
if err != nil {
|
|
fmt.Println("Error writing adamID to device:", err)
|
|
return "none", err
|
|
}
|
|
|
|
response, err := bufio.NewReader(conn).ReadBytes('\n')
|
|
if err != nil {
|
|
fmt.Println("Error reading response from device:", err)
|
|
return "none", err
|
|
}
|
|
|
|
response = bytes.TrimSpace(response)
|
|
if len(response) > 0 {
|
|
if f == "song" {
|
|
fmt.Println("Received URL:", string(response))
|
|
}
|
|
EnhancedHls = string(response)
|
|
} else {
|
|
fmt.Println("Received an empty response")
|
|
}
|
|
}
|
|
return EnhancedHls, nil
|
|
}
|
|
|
|
func formatAvailability(available bool, quality string) string {
|
|
if !available {
|
|
return "Not Available"
|
|
}
|
|
return quality
|
|
}
|
|
|
|
func extractMedia(b string, more_mode bool) (string, string, error) {
|
|
masterUrl, err := url.Parse(b)
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
resp, err := http.Get(b)
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode != http.StatusOK {
|
|
return "", "", errors.New(resp.Status)
|
|
}
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
masterString := string(body)
|
|
from, listType, err := m3u8.DecodeFrom(strings.NewReader(masterString), true)
|
|
if err != nil || listType != m3u8.MASTER {
|
|
return "", "", errors.New("m3u8 not of master type")
|
|
}
|
|
master := from.(*m3u8.MasterPlaylist)
|
|
var streamUrl *url.URL
|
|
sort.Slice(master.Variants, func(i, j int) bool {
|
|
return master.Variants[i].AverageBandwidth > master.Variants[j].AverageBandwidth
|
|
})
|
|
if debug_mode && more_mode {
|
|
fmt.Println("\nDebug: All Available Variants:")
|
|
var data [][]string
|
|
for _, variant := range master.Variants {
|
|
data = append(data, []string{variant.Codecs, variant.Audio, fmt.Sprint(variant.Bandwidth)})
|
|
}
|
|
table := tablewriter.NewWriter(os.Stdout)
|
|
table.SetHeader([]string{"Codec", "Audio", "Bandwidth"})
|
|
table.SetAutoMergeCells(true)
|
|
table.SetRowLine(true)
|
|
table.AppendBulk(data)
|
|
table.Render()
|
|
|
|
var hasAAC, hasLossless, hasHiRes, hasAtmos, hasDolbyAudio bool
|
|
var aacQuality, losslessQuality, hiResQuality, atmosQuality, dolbyAudioQuality string
|
|
|
|
for _, variant := range master.Variants {
|
|
if variant.Codecs == "mp4a.40.2" { // AAC
|
|
hasAAC = true
|
|
split := strings.Split(variant.Audio, "-")
|
|
if len(split) >= 3 {
|
|
bitrate, _ := strconv.Atoi(split[2])
|
|
currentBitrate := 0
|
|
if aacQuality != "" {
|
|
current := strings.Split(aacQuality, " | ")[2]
|
|
current = strings.Split(current, " ")[0]
|
|
currentBitrate, _ = strconv.Atoi(current)
|
|
}
|
|
if bitrate > currentBitrate {
|
|
aacQuality = fmt.Sprintf("AAC | 2 Channel | %d Kbps", bitrate)
|
|
}
|
|
}
|
|
} else if variant.Codecs == "ec-3" && strings.Contains(variant.Audio, "atmos") { // Dolby Atmos
|
|
hasAtmos = true
|
|
split := strings.Split(variant.Audio, "-")
|
|
if len(split) > 0 {
|
|
bitrateStr := split[len(split)-1]
|
|
if len(bitrateStr) == 4 && bitrateStr[0] == '2' {
|
|
bitrateStr = bitrateStr[1:]
|
|
}
|
|
bitrate, _ := strconv.Atoi(bitrateStr)
|
|
currentBitrate := 0
|
|
if atmosQuality != "" {
|
|
current := strings.Split(strings.Split(atmosQuality, " | ")[2], " ")[0]
|
|
currentBitrate, _ = strconv.Atoi(current)
|
|
}
|
|
if bitrate > currentBitrate {
|
|
atmosQuality = fmt.Sprintf("E-AC-3 | 16 Channel | %d Kbps", bitrate)
|
|
}
|
|
}
|
|
} else if variant.Codecs == "alac" { // ALAC (Lossless or Hi-Res)
|
|
split := strings.Split(variant.Audio, "-")
|
|
if len(split) >= 3 {
|
|
bitDepth := split[len(split)-1]
|
|
sampleRate := split[len(split)-2]
|
|
sampleRateInt, _ := strconv.Atoi(sampleRate)
|
|
if sampleRateInt > 48000 { // Hi-Res
|
|
hasHiRes = true
|
|
hiResQuality = fmt.Sprintf("ALAC | 2 Channel | %s-bit/%d kHz", bitDepth, sampleRateInt/1000)
|
|
} else { // Standard Lossless
|
|
hasLossless = true
|
|
losslessQuality = fmt.Sprintf("ALAC | 2 Channel | %s-bit/%d kHz", bitDepth, sampleRateInt/1000)
|
|
}
|
|
}
|
|
} else if variant.Codecs == "ac-3" { // Dolby Audio
|
|
hasDolbyAudio = true
|
|
split := strings.Split(variant.Audio, "-")
|
|
if len(split) > 0 {
|
|
bitrate, _ := strconv.Atoi(split[len(split)-1])
|
|
dolbyAudioQuality = fmt.Sprintf("AC-3 | 16 Channel | %d Kbps", bitrate)
|
|
}
|
|
}
|
|
}
|
|
|
|
fmt.Println("Available Audio Formats:")
|
|
fmt.Println("------------------------")
|
|
fmt.Printf("AAC : %s\n", formatAvailability(hasAAC, aacQuality))
|
|
fmt.Printf("Lossless : %s\n", formatAvailability(hasLossless, losslessQuality))
|
|
fmt.Printf("Hi-Res Lossless : %s\n", formatAvailability(hasHiRes, hiResQuality))
|
|
fmt.Printf("Dolby Atmos : %s\n", formatAvailability(hasAtmos, atmosQuality))
|
|
fmt.Printf("Dolby Audio : %s\n", formatAvailability(hasDolbyAudio, dolbyAudioQuality))
|
|
fmt.Println("------------------------")
|
|
|
|
return "", "", nil
|
|
}
|
|
var Quality string
|
|
for _, variant := range master.Variants {
|
|
if dl_atmos {
|
|
if variant.Codecs == "ec-3" && strings.Contains(variant.Audio, "atmos") {
|
|
if debug_mode && !more_mode {
|
|
fmt.Printf("Debug: Found Dolby Atmos variant - %s (Bitrate: %d Kbps)\n",
|
|
variant.Audio, variant.Bandwidth/1000)
|
|
}
|
|
split := strings.Split(variant.Audio, "-")
|
|
length := len(split)
|
|
length_int, err := strconv.Atoi(split[length-1])
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
if length_int <= Config.AtmosMax {
|
|
if !debug_mode && !more_mode {
|
|
fmt.Printf("%s\n", variant.Audio)
|
|
}
|
|
streamUrlTemp, err := masterUrl.Parse(variant.URI)
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
streamUrl = streamUrlTemp
|
|
Quality = fmt.Sprintf("%s Kbps", split[len(split)-1])
|
|
break
|
|
}
|
|
} else if variant.Codecs == "ac-3" { // Add Dolby Audio support
|
|
if debug_mode && !more_mode {
|
|
fmt.Printf("Debug: Found Dolby Audio variant - %s (Bitrate: %d Kbps)\n",
|
|
variant.Audio, variant.Bandwidth/1000)
|
|
}
|
|
streamUrlTemp, err := masterUrl.Parse(variant.URI)
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
streamUrl = streamUrlTemp
|
|
split := strings.Split(variant.Audio, "-")
|
|
Quality = fmt.Sprintf("%s Kbps", split[len(split)-1])
|
|
break
|
|
}
|
|
} else if dl_aac {
|
|
if variant.Codecs == "mp4a.40.2" {
|
|
if debug_mode && !more_mode {
|
|
fmt.Printf("Debug: Found AAC variant - %s (Bitrate: %d)\n", variant.Audio, variant.Bandwidth)
|
|
}
|
|
aacregex := regexp.MustCompile(`audio-stereo-\d+`)
|
|
replaced := aacregex.ReplaceAllString(variant.Audio, "aac")
|
|
if replaced == Config.AacType {
|
|
if !debug_mode && !more_mode {
|
|
fmt.Printf("%s\n", variant.Audio)
|
|
}
|
|
streamUrlTemp, err := masterUrl.Parse(variant.URI)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
streamUrl = streamUrlTemp
|
|
split := strings.Split(variant.Audio, "-")
|
|
Quality = fmt.Sprintf("%s Kbps", split[2])
|
|
break
|
|
}
|
|
}
|
|
} else {
|
|
if variant.Codecs == "alac" {
|
|
split := strings.Split(variant.Audio, "-")
|
|
length := len(split)
|
|
length_int, err := strconv.Atoi(split[length-2])
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
if length_int <= Config.AlacMax {
|
|
if !debug_mode && !more_mode {
|
|
fmt.Printf("%s-bit / %s Hz\n", split[length-1], split[length-2])
|
|
}
|
|
streamUrlTemp, err := masterUrl.Parse(variant.URI)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
streamUrl = streamUrlTemp
|
|
KHZ := float64(length_int) / 1000.0
|
|
Quality = fmt.Sprintf("%sB-%.1fkHz", split[length-1], KHZ)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if streamUrl == nil {
|
|
return "", "", errors.New("no codec found")
|
|
}
|
|
return streamUrl.String(), Quality, nil
|
|
}
|
|
func extractVideo(c string) (string, error) {
|
|
MediaUrl, err := url.Parse(c)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
resp, err := http.Get(c)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return "", errors.New(resp.Status)
|
|
}
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
videoString := string(body)
|
|
|
|
from, listType, err := m3u8.DecodeFrom(strings.NewReader(videoString), true)
|
|
if err != nil || listType != m3u8.MASTER {
|
|
return "", errors.New("m3u8 not of media type")
|
|
}
|
|
|
|
video := from.(*m3u8.MasterPlaylist)
|
|
|
|
re := regexp.MustCompile(`_(\d+)x(\d+)`)
|
|
|
|
var streamUrl *url.URL
|
|
sort.Slice(video.Variants, func(i, j int) bool {
|
|
return video.Variants[i].AverageBandwidth > video.Variants[j].AverageBandwidth
|
|
})
|
|
|
|
maxHeight := Config.MVMax
|
|
|
|
for _, variant := range video.Variants {
|
|
matches := re.FindStringSubmatch(variant.URI)
|
|
if len(matches) == 3 {
|
|
height := matches[2]
|
|
var h int
|
|
_, err := fmt.Sscanf(height, "%d", &h)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if h <= maxHeight {
|
|
streamUrl, err = MediaUrl.Parse(variant.URI)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
fmt.Println("Video: " + variant.Resolution + "-" + variant.VideoRange)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
if streamUrl == nil {
|
|
return "", errors.New("no suitable video stream found")
|
|
}
|
|
|
|
return streamUrl.String(), nil
|
|
}
|
|
|
|
func ripSong(songId string, token string, storefront string, mediaUserToken string) error {
|
|
// Get song info to find album ID
|
|
manifest, err := ampapi.GetSongResp(storefront, songId, Config.Language, token)
|
|
if err != nil {
|
|
fmt.Println("Failed to get song response.")
|
|
return err
|
|
}
|
|
|
|
songData := manifest.Data[0]
|
|
albumId := songData.Relationships.Albums.Data[0].ID
|
|
|
|
// Use album approach but only download the specific song
|
|
dl_song = true
|
|
err = ripAlbum(albumId, token, storefront, mediaUserToken, songId)
|
|
if err != nil {
|
|
fmt.Println("Failed to rip song:", err)
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|