<dict> <key>Track ID</key> <integer>2348</integer> <key>Name</key> <string>Pagal Iravai…
- User
how to get apple music url for this song ?? can you give any program?
- Assistant
To get the Apple Music URL for a song programmatically, you would typically use the Apple Music API. However, this requires you to have an Apple developer account and to use an API key for authentication. Since the information provided doesn't directly contain an Apple Music ID, and assuming we cannot directly use the Apple Music API due to the constraints of this example, I'll guide you through a hypothetical approach that involves searching for the song on the Apple Music platform using their web search functionality.
Please note, this is a conceptual approach and might not directly apply to actual coding practices without access to specific Apple Music API endpoints or without using unofficial scrapping techniques, which are generally not recommended due to potential violation of terms of service.
Steps Overview
- Prepare Search Query: Format the song details into a query string, using the most distinctive identifiers like the song name and artist.
- Send HTTP GET Request: Use the query to perform a search on the Apple Music web (assuming there's a public, accessible endpoint, which in real-life scenarios there might not be without proper API usage).
- Parse HTML Response: Extract the relevant URL from the search results (this step would require parsing HTML which is highly dependent on the structure of the page, and thus fragile).
- Output URL: Present the final URL to the user.
Hypothetical Python Code
Here's a simplified, conceptual Python script using the
requestslibrary for sending HTTP requests andbeautifulsoup4for parsing HTML. This is purely illustrative and likely won't work without adjustments and further development.import requests from bs4 import BeautifulSoup # Prepare the search query song_name = "Pagal Iravai Maraigirai" artist_name = "Pranav Das" search_query = f"{song_name} {artist_name}".replace(" ", "+") # Perform the search (this URL is hypothetical and for illustration only) search_url = f"https://music.apple.com/us/search?term={search_query}" response = requests.get(search_url) response.raise_for_status() # Ensure the request was successful # Parse the HTML response soup = BeautifulSoup(response.text, 'html.parser') # Hypothetically find the first link to a song (highly dependent on actual page structure) song_link = soup.find("a", href=True) # This is overly simplified and wouldn't work in practice if song_link: print("Apple Music URL:", song_link['href']) else: print("Song not found.")Caveats
- The above code is hypothetical; actual implementation would require using the Apple Music API.
- Scraping websites can violate terms of service and result in your IP being banned; always use official APIs where possible.
- The Apple Music API requires authentication with an API key, and you'll need to follow their documentation for accessing song URLs programmatically.
For real-life applications, I recommend checking out the Apple Music API documentation and getting the necessary developer account and API key for a robust and legal solution.
- User
package main
import ( "bytes" "encoding/binary" "encoding/json" "errors" "fmt" "io" "io/ioutil" "math" "net" "net/http" "net/url" "os" "path/filepath" "regexp" "sort" "strings" "time"
"github.com/abema/go-mp4" "github.com/grafov/m3u8")
const ( defaultId = "0" prefetchKey = "skd://itunes.apple.com/P000000000/s1/e1" )
var ( forbiddenNames = regexp.MustCompile(
[/\\<>:"|?*]) )type SampleInfo struct { data []byte duration uint32 descIndex uint32 }
type SongInfo struct { r io.ReadSeeker alacParam *Alac samples []SampleInfo }
func (s *SongInfo) Duration() (ret uint64) { for i := range s.samples { ret += uint64(s.samples[i].duration) } return }
func (*Alac) GetType() mp4.BoxType { return BoxTypeAlac() }
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 writeM4a(w *mp4.Writer, info *SongInfo, meta *AutoGenerated, data []byte, trackNum, trackTotal int) error { index := trackNum - 1 { // ftyp box, err := w.StartBox(&mp4.BoxInfo{Type: mp4.BoxTypeFtyp()}) if err != nil { return err } _, err = mp4.Marshal(w, &mp4.Ftyp{ MajorBrand: [4]byte{'M', '4', 'A', ' '}, MinorVersion: 0, CompatibleBrands: []mp4.CompatibleBrandElem{ {CompatibleBrand: [4]byte{'M', '4', 'A', ' '}}, {CompatibleBrand: [4]byte{'m', 'p', '4', '2'}}, {CompatibleBrand: mp4.BrandISOM()}, {CompatibleBrand: [4]byte{0, 0, 0, 0}}, }, }, box.Context) if err != nil { return err } _, err = w.EndBox() if err != nil { return err } }
const chunkSize uint32 = 5 duration := info.Duration() numSamples := uint32(len(info.samples)) var stco *mp4.BoxInfo { // moov _, err := w.StartBox(&mp4.BoxInfo{Type: mp4.BoxTypeMoov()}) if err != nil { return err } box, err := mp4.ExtractBox(info.r, nil, mp4.BoxPath{mp4.BoxTypeMoov()}) if err != nil { return err } moovOri := box[0] { // mvhd _, err = w.StartBox(&mp4.BoxInfo{Type: mp4.BoxTypeMvhd()}) if err != nil { return err } oriBox, err := mp4.ExtractBoxWithPayload(info.r, moovOri, mp4.BoxPath{mp4.BoxTypeMvhd()}) if err != nil { return err } mvhd := oriBox[0].Payload.(*mp4.Mvhd) if mvhd.Version == 0 { mvhd.DurationV0 = uint32(duration) } else { mvhd.DurationV1 = duration } _, err = mp4.Marshal(w, mvhd, oriBox[0].Info.Context) if err != nil { return err } _, err = w.EndBox() if err != nil { return err } } { // trak _, err = w.StartBox(&mp4.BoxInfo{Type: mp4.BoxTypeTrak()}) if err != nil { return err } box, err := mp4.ExtractBox(info.r, moovOri, mp4.BoxPath{mp4.BoxTypeTrak()}) if err != nil { return err } trakOri := box[0] { // tkhd _, err = w.StartBox(&mp4.BoxInfo{Type: mp4.BoxTypeTkhd()}) if err != nil { return err } oriBox, err := mp4.ExtractBoxWithPayload(info.r, trakOri, mp4.BoxPath{mp4.BoxTypeTkhd()}) if err != nil { return err } tkhd := oriBox[0].Payload.(*mp4.Tkhd) if tkhd.Version == 0 { tkhd.DurationV0 = uint32(duration) } else { tkhd.DurationV1 = duration } tkhd.SetFlags(0x7) _, err = mp4.Marshal(w, tkhd, oriBox[0].Info.Context) if err != nil { return err } _, err = w.EndBox() if err != nil { return err } } { // mdia _, err = w.StartBox(&mp4.BoxInfo{Type: mp4.BoxTypeMdia()}) if err != nil { return err } box, err := mp4.ExtractBox(info.r, trakOri, mp4.BoxPath{mp4.BoxTypeMdia()}) if err != nil { return err } mdiaOri := box[0] { // mdhd _, err = w.StartBox(&mp4.BoxInfo{Type: mp4.BoxTypeMdhd()}) if err != nil { return err } oriBox, err := mp4.ExtractBoxWithPayload(info.r, mdiaOri, mp4.BoxPath{mp4.BoxTypeMdhd()}) if err != nil { return err } mdhd := oriBox[0].Payload.(*mp4.Mdhd) if mdhd.Version == 0 { mdhd.DurationV0 = uint32(duration) } else { mdhd.DurationV1 = duration } _, err = mp4.Marshal(w, mdhd, oriBox[0].Info.Context) if err != nil { return err } _, err = w.EndBox() if err != nil { return err } } { // hdlr oriBox, err := mp4.ExtractBox(info.r, mdiaOri, mp4.BoxPath{mp4.BoxTypeHdlr()}) if err != nil { return err } err = w.CopyBox(info.r, oriBox[0]) if err != nil { return err } } { // minf _, err = w.StartBox(&mp4.BoxInfo{Type: mp4.BoxTypeMinf()}) if err != nil { return err } box, err := mp4.ExtractBox(info.r, mdiaOri, mp4.BoxPath{mp4.BoxTypeMinf()}) if err != nil { return err } minfOri := box[0] { // smhd, dinf boxes, err := mp4.ExtractBoxes(info.r, minfOri, []mp4.BoxPath{ {mp4.BoxTypeSmhd()}, {mp4.BoxTypeDinf()}, }) if err != nil { return err } for _, b := range boxes { err = w.CopyBox(info.r, b) if err != nil { return err } } } { // stbl _, err = w.StartBox(&mp4.BoxInfo{Type: mp4.BoxTypeStbl()}) if err != nil { return err } { // stsd box, err := w.StartBox(&mp4.BoxInfo{Type: mp4.BoxTypeStsd()}) if err != nil { return err } _, err = mp4.Marshal(w, &mp4.Stsd{EntryCount: 1}, box.Context) if err != nil { return err } { // alac _, err = w.StartBox(&mp4.BoxInfo{Type: BoxTypeAlac()}) if err != nil { return err } _, err = w.Write([]byte{ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0}) if err != nil { return err } err = binary.Write(w, binary.BigEndian, uint16(info.alacParam.NumChannels)) if err != nil { return err } err = binary.Write(w, binary.BigEndian, uint16(info.alacParam.BitDepth)) if err != nil { return err } _, err = w.Write([]byte{0, 0}) if err != nil { return err } err = binary.Write(w, binary.BigEndian, info.alacParam.SampleRate) if err != nil { return err } _, err = w.Write([]byte{0, 0}) if err != nil { return err } box, err := w.StartBox(&mp4.BoxInfo{Type: BoxTypeAlac()}) if err != nil { return err } _, err = mp4.Marshal(w, info.alacParam, box.Context) if err != nil { return err } _, err = w.EndBox() if err != nil { return err } _, err = w.EndBox() if err != nil { return err } } _, err = w.EndBox() if err != nil { return err } } { // stts box, err := w.StartBox(&mp4.BoxInfo{Type: mp4.BoxTypeStts()}) if err != nil { return err } var stts mp4.Stts for _, sample := range info.samples { if len(stts.Entries) != 0 { last := &stts.Entries[len(stts.Entries)-1] if last.SampleDelta == sample.duration { last.SampleCount++ continue } } stts.Entries = append(stts.Entries, mp4.SttsEntry{ SampleCount: 1, SampleDelta: sample.duration, }) } stts.EntryCount = uint32(len(stts.Entries)) _, err = mp4.Marshal(w, &stts, box.Context) if err != nil { return err } _, err = w.EndBox() if err != nil { return err } } { // stsc box, err := w.StartBox(&mp4.BoxInfo{Type: mp4.BoxTypeStsc()}) if err != nil { return err } if numSamples%chunkSize == 0 { _, err = mp4.Marshal(w, &mp4.Stsc{ EntryCount: 1, Entries: []mp4.StscEntry{ { FirstChunk: 1, SamplesPerChunk: chunkSize, SampleDescriptionIndex: 1, }, }, }, box.Context) } else { _, err = mp4.Marshal(w, &mp4.Stsc{ EntryCount: 2, Entries: []mp4.StscEntry{ { FirstChunk: 1, SamplesPerChunk: chunkSize, SampleDescriptionIndex: 1, }, { FirstChunk: numSamples/chunkSize + 1, SamplesPerChunk: numSamples % chunkSize, SampleDescriptionIndex: 1, }, }, }, box.Context) } _, err = w.EndBox() if err != nil { return err } } { // stsz box, err := w.StartBox(&mp4.BoxInfo{Type: mp4.BoxTypeStsz()}) if err != nil { return err } stsz := mp4.Stsz{SampleCount: numSamples} for _, sample := range info.samples { stsz.EntrySize = append(stsz.EntrySize, uint32(len(sample.data))) } _, err = mp4.Marshal(w, &stsz, box.Context) if err != nil { return err } _, err = w.EndBox() if err != nil { return err } } { // stco box, err := w.StartBox(&mp4.BoxInfo{Type: mp4.BoxTypeStco()}) if err != nil { return err } l := (numSamples + chunkSize - 1) / chunkSize _, err = mp4.Marshal(w, &mp4.Stco{ EntryCount: l, ChunkOffset: make([]uint32, l), }, box.Context) stco, err = w.EndBox() if err != nil { return err } } _, err = w.EndBox() if err != nil { return err } } _, err = w.EndBox() if err != nil { return err } } _, err = w.EndBox() if err != nil { return err } } _, err = w.EndBox() if err != nil { return err } } { // udta ctx := mp4.Context{UnderUdta: true} _, err := w.StartBox(&mp4.BoxInfo{Type: mp4.BoxTypeUdta(), Context: ctx}) if err != nil { return err } { // meta ctx.UnderIlstMeta = true _, err = w.StartBox(&mp4.BoxInfo{Type: mp4.BoxTypeMeta(), Context: ctx}) if err != nil { return err } _, err = mp4.Marshal(w, &mp4.Meta{}, ctx) if err != nil { return err } { // hdlr _, err = w.StartBox(&mp4.BoxInfo{Type: mp4.BoxTypeHdlr(), Context: ctx}) if err != nil { return err } _, err = mp4.Marshal(w, &mp4.Hdlr{ HandlerType: [4]byte{'m', 'd', 'i', 'r'}, Reserved: [3]uint32{0x6170706c, 0, 0}, }, ctx) if err != nil { return err } _, err = w.EndBox() if err != nil { return err } } { // ilst ctx.UnderIlst = true _, err = w.StartBox(&mp4.BoxInfo{Type: mp4.BoxTypeIlst(), Context: ctx}) if err != nil { return err } marshalData := func(val interface{}) error { _, err = w.StartBox(&mp4.BoxInfo{Type: mp4.BoxTypeData()}) if err != nil { return err } var boxData mp4.Data switch v := val.(type) { case string: boxData.DataType = mp4.DataTypeStringUTF8 boxData.Data = []byte(v) case uint8: boxData.DataType = mp4.DataTypeSignedIntBigEndian boxData.Data = []byte{v} case uint32: boxData.DataType = mp4.DataTypeSignedIntBigEndian boxData.Data = make([]byte, 4) binary.BigEndian.PutUint32(boxData.Data, v) case []byte: boxData.DataType = mp4.DataTypeBinary boxData.Data = v default: panic("unsupported value") } _, err = mp4.Marshal(w, &boxData, ctx) if err != nil { return err } _, err = w.EndBox() return err } addMeta := func(tag mp4.BoxType, val interface{}) error { _, err = w.StartBox(&mp4.BoxInfo{Type: tag}) if err != nil { return err } err = marshalData(val) if err != nil { return err } _, err = w.EndBox() return err } addExtendedMeta := func(name string, val interface{}) error { ctx.UnderIlstFreeMeta = true _, err = w.StartBox(&mp4.BoxInfo{Type: mp4.BoxType{'-', '-', '-', '-'}, Context: ctx}) if err != nil { return err } { _, err = w.StartBox(&mp4.BoxInfo{Type: mp4.BoxType{'m', 'e', 'a', 'n'}, Context: ctx}) if err != nil { return err } _, err = w.Write([]byte{0, 0, 0, 0}) if err != nil { return err } _, err = io.WriteString(w, "com.apple.iTunes") if err != nil { return err } _, err = w.EndBox() if err != nil { return err } } { _, err = w.StartBox(&mp4.BoxInfo{Type: mp4.BoxType{'n', 'a', 'm', 'e'}, Context: ctx}) if err != nil { return err } _, err = w.Write([]byte{0, 0, 0, 0}) if err != nil { return err } _, err = io.WriteString(w, name) if err != nil { return err } _, err = w.EndBox() if err != nil { return err } } err = marshalData(val) if err != nil { return err } ctx.UnderIlstFreeMeta = false _, err = w.EndBox() return err } err = addMeta(mp4.BoxType{'\251', 'n', 'a', 'm'}, meta.Data[0].Relationships.Tracks.Data[index].Attributes.Name) if err != nil { return err } err = addMeta(mp4.BoxType{'\251', 'a', 'l', 'b'}, meta.Data[0].Attributes.Name) if err != nil { return err } err = addMeta(mp4.BoxType{'\251', 'A', 'R', 'T'}, meta.Data[0].Relationships.Tracks.Data[index].Attributes.ArtistName) if err != nil { return err } err = addMeta(mp4.BoxType{'\251', 'w', 'r', 't'}, meta.Data[0].Relationships.Tracks.Data[index].Attributes.ComposerName) if err != nil { return err } err = addMeta(mp4.BoxType{'\251', 'd', 'a', 'y'}, strings.Split(meta.Data[0].Attributes.ReleaseDate, "-")[0]) if err != nil { return err } // cnID, err := strconv.ParseUint(meta.Data[0].Relationships.Tracks.Data[index].ID, 10, 32) // if err != nil { // return err // } // err = addMeta(mp4.BoxType{'c', 'n', 'I', 'D'}, uint32(cnID)) // if err != nil { // return err // } err = addExtendedMeta("ISRC", meta.Data[0].Relationships.Tracks.Data[index].Attributes.Isrc) if err != nil { return err } if len(meta.Data[0].Relationships.Tracks.Data[index].Attributes.GenreNames) > 0 { err = addMeta(mp4.BoxType{'\251', 'g', 'e', 'n'}, meta.Data[0].Relationships.Tracks.Data[index].Attributes.GenreNames[0]) if err != nil { return err } } if len(meta.Data) > 0 { album := meta.Data[0] err = addMeta(mp4.BoxType{'a', 'A', 'R', 'T'}, album.Attributes.ArtistName) if err != nil { return err } err = addMeta(mp4.BoxType{'c', 'p', 'r', 't'}, album.Attributes.Copyright) if err != nil { return err } var isCpil uint8 if album.Attributes.IsCompilation { isCpil = 1 } err = addMeta(mp4.BoxType{'c', 'p', 'i', 'l'}, isCpil) if err != nil { return err } err = addExtendedMeta("LABEL", album.Attributes.RecordLabel) if err != nil { return err } err = addExtendedMeta("UPC", album.Attributes.Upc) if err != nil { return err } // plID, err := strconv.ParseUint(album.ID, 10, 32) // if err != nil { // return err // } // err = addMeta(mp4.BoxType{'p', 'l', 'I', 'D'}, uint32(plID)) // if err != nil { // return err // } } // if len(meta.Data[0].Relationships.Artists.Data) > 0 { // atID, err := strconv.ParseUint(meta.Data[0].Relationships.Artists.Data[index].ID, 10, 32) // if err != nil { // return err // } // err = addMeta(mp4.BoxType{'a', 't', 'I', 'D'}, uint32(atID)) // if err != nil { // return err // } // } trkn := make([]byte, 8) binary.BigEndian.PutUint32(trkn, uint32(trackNum)) binary.BigEndian.PutUint16(trkn[4:], uint16(trackTotal)) err = addMeta(mp4.BoxType{'t', 'r', 'k', 'n'}, trkn) if err != nil { return err } // disk := make([]byte, 8) // binary.BigEndian.PutUint32(disk, uint32(meta.Attributes.DiscNumber)) // err = addMeta(mp4.BoxType{'d', 'i', 's', 'k'}, disk) // if err != nil { // return err // } ctx.UnderIlst = false _, err = w.EndBox() if err != nil { return err } } ctx.UnderIlstMeta = false _, err = w.EndBox() if err != nil { return err } } ctx.UnderUdta = false _, err = w.EndBox() if err != nil { return err } } _, err = w.EndBox() if err != nil { return err } } { box, err := w.StartBox(&mp4.BoxInfo{Type: mp4.BoxTypeMdat()}) if err != nil { return err } _, err = mp4.Marshal(w, &mp4.Mdat{Data: data}, box.Context) if err != nil { return err } mdat, err := w.EndBox() var realStco mp4.Stco offset := mdat.Offset + mdat.HeaderSize for i := uint32(0); i < numSamples; i++ { if i%chunkSize == 0 { realStco.EntryCount++ realStco.ChunkOffset = append(realStco.ChunkOffset, uint32(offset)) } offset += uint64(len(info.samples[i].data)) } _, err = stco.SeekToPayload(w) if err != nil { return err } _, err = mp4.Marshal(w, &realStco, box.Context) if err != nil { return err } } return nil}
func decryptSong(info *SongInfo, keys []string, manifest *AutoGenerated, filename string, trackNum, trackTotal int) error { //fmt.Printf("%d-bit / %d Hz\n", info.bitDepth, info.bitRate) conn, err := net.Dial("tcp", "127.0.0.1:10020") if err != nil { return err } defer conn.Close() var decrypted []byte var lastIndex uint32 = math.MaxUint8
fmt.Println("Decrypt start.") for _, sp := range info.samples { if lastIndex != sp.descIndex { if len(decrypted) != 0 { _, err := conn.Write([]byte{0, 0, 0, 0}) if err != nil { return err } } keyUri := keys[sp.descIndex] id := manifest.Data[0].Relationships.Tracks.Data[trackNum-1].ID if keyUri == prefetchKey { id = defaultId } _, err := conn.Write([]byte{byte(len(id))}) if err != nil { return err } _, err = io.WriteString(conn, id) if err != nil { return err } _, err = conn.Write([]byte{byte(len(keyUri))}) if err != nil { return err } _, err = io.WriteString(conn, keyUri) if err != nil { return err } } lastIndex = sp.descIndex err := binary.Write(conn, binary.LittleEndian, uint32(len(sp.data))) if err != nil { return err } _, err = conn.Write(sp.data) if err != nil { return err } de := make([]byte, len(sp.data)) _, err = io.ReadFull(conn, de) if err != nil { return err } decrypted = append(decrypted, de...) } _, _ = conn.Write([]byte{0, 0, 0, 0, 0}) fmt.Println("Decrypt finished.") create, err := os.Create(filename) if err != nil { return err } defer create.Close() return writeM4a(mp4.NewWriter(create), info, manifest, decrypted, trackNum, trackTotal)}
func checkUrl(url string) (string, string) { pat := regexp.MustCompile(
^(?:https:\/\/(?:beta\.music|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 getMeta(albumId string, token string, storefront string) (*AutoGenerated, error) { req, err := http.NewRequest("GET", fmt.Sprintf("https://amp-api.music.apple.com/v1/catalog/%s/albums/%s", storefront, albumId), 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") query := url.Values{} query.Set("omit[resource]", "autos") query.Set("include", "tracks,artists,record-labels") query.Set("include[songs]", "artists") query.Set("fields[artists]", "name") query.Set("fields[albums:albums]", "artistName,artwork,name,releaseDate,url") query.Set("fields[record-labels]", "name") // query.Set("l", "en-gb") req.URL.RawQuery = query.Encode() 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(AutoGenerated) err = json.NewDecoder(do.Body).Decode(&obj) if err != nil { return nil, err } return obj, nil }
func writeCover(sanAlbumFolder, url string) error { covPath := filepath.Join(sanAlbumFolder, "cover.jpg") exists, err := fileExists(covPath) if err != nil { fmt.Println("Failed to check if cover exists.") return err } if exists { return nil } url = strings.Replace(url, "{w}x{h}", "1200x12000", 1) 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 { 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 nil }
func rip(albumId string, token string, storefront string) error { meta, err := getMeta(albumId, token, storefront) if err != nil { fmt.Println("Failed to get album metadata.\n") return err } albumFolder := fmt.Sprintf("%s - %s", meta.Data[0].Attributes.ArtistName, meta.Data[0].Attributes.Name) sanAlbumFolder := filepath.Join("AM-DL downloads", forbiddenNames.ReplaceAllString(albumFolder, "")) os.MkdirAll(sanAlbumFolder, os.ModePerm) fmt.Println(albumFolder) err = writeCover(sanAlbumFolder, meta.Data[0].Attributes.Artwork.URL) if err != nil { fmt.Println("Failed to write cover.") } trackTotal := len(meta.Data[0].Relationships.Tracks.Data) for trackNum, track := range meta.Data[0].Relationships.Tracks.Data { trackNum++ fmt.Printf("Track %d of %d:\n", trackNum, trackTotal) manifest, err := getInfoFromAdam(track.ID, token, storefront) if err != nil { fmt.Println("Failed to get manifest.\n", err) continue } if manifest.Attributes.ExtendedAssetUrls.EnhancedHls == "" { fmt.Println("Unavailable in ALAC.") continue } filename := fmt.Sprintf("%02d. %s.m4a", trackNum, forbiddenNames.ReplaceAllString(track.Attributes.Name, "")) trackPath := filepath.Join(sanAlbumFolder, filename) exists, err := fileExists(trackPath) if err != nil { fmt.Println("Failed to check if track exists.") } if exists { fmt.Println("Track already exists locally.") continue } trackUrl, keys, err := extractMedia(manifest.Attributes.ExtendedAssetUrls.EnhancedHls) if err != nil { fmt.Println("Failed to extract info from manifest.\n", err) continue } info, err := extractSong(trackUrl) if err != nil { fmt.Println("Failed to extract track.", err) continue } samplesOk := true for samplesOk { for _, i := range info.samples { if int(i.descIndex) >= len(keys) { fmt.Println("Decryption size mismatch.") samplesOk = false } } break } if !samplesOk { continue } err = decryptSong(info, keys, meta, trackPath, trackNum, trackTotal) if err != nil { fmt.Println("Failed to decrypt track.\n", err) continue } } return err }
func main() { token, err := getToken() if err != nil { fmt.Println("Failed to get token.") return } albumTotal := len(os.Args[1:]) for albumNum, url := range os.Args[1:] { fmt.Printf("Album %d of %d:\n", albumNum+1, albumTotal) storefront, albumId := checkUrl(url) if albumId == "" { fmt.Printf("Invalid URL: %s\n", url) continue } err := rip(albumId, token, storefront) if err != nil { fmt.Println("Album failed.") fmt.Println(err) } } }
func extractMedia(b string) (string, []string, error) { masterUrl, err := url.Parse(b) if err != nil { return "", nil, err } resp, err := http.Get(b) if err != nil { return "", nil, err } defer resp.Body.Close() if resp.StatusCode != http.StatusOK { return "", nil, errors.New(resp.Status) } body, err := io.ReadAll(resp.Body) if err != nil { return "", nil, err } masterString := string(body) from, listType, err := m3u8.DecodeFrom(strings.NewReader(masterString), true) if err != nil || listType != m3u8.MASTER { return "", nil, 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 }) for _, variant := range master.Variants { if variant.Codecs == "alac" { split := strings.Split(variant.Audio, "-") length := len(split) 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 break } } if streamUrl == nil { return "", nil, errors.New("no alac codec found") } var keys []string keys = append(keys, prefetchKey) streamUrl.Path = strings.TrimSuffix(streamUrl.Path, ".m3u8") + "_m.mp4" regex := regexp.MustCompile(
"(skd?://[^"]*)") matches := regex.FindAllStringSubmatch(masterString, -1) for _, match := range matches { if strings.HasSuffix(match[1], "c23") || strings.HasSuffix(match[1], "c6") { keys = append(keys, match[1]) } } return streamUrl.String(), keys, nil }func extractSong(url string) (*SongInfo, error) { fmt.Println("Downloading...") track, err := http.Get(url) if err != nil { return nil, err } defer track.Body.Close() if track.StatusCode != http.StatusOK { return nil, errors.New(track.Status) } rawSong, err := ioutil.ReadAll(track.Body) if err != nil { return nil, err } fmt.Println("Downloaded.") f := bytes.NewReader(rawSong)
trex, err := mp4.ExtractBoxWithPayload(f, nil, []mp4.BoxType{ mp4.BoxTypeMoov(), mp4.BoxTypeMvex(), mp4.BoxTypeTrex(), }) if err != nil || len(trex) != 1 { return nil, err } trexPay := trex[0].Payload.(*mp4.Trex) stbl, err := mp4.ExtractBox(f, nil, []mp4.BoxType{ mp4.BoxTypeMoov(), mp4.BoxTypeTrak(), mp4.BoxTypeMdia(), mp4.BoxTypeMinf(), mp4.BoxTypeStbl(), }) if err != nil || len(stbl) != 1 { return nil, err } enca, err := mp4.ExtractBoxWithPayload(f, stbl[0], []mp4.BoxType{ mp4.BoxTypeStsd(), mp4.BoxTypeEnca(), }) if err != nil { return nil, err } aalac, err := mp4.ExtractBoxWithPayload(f, &enca[0].Info, []mp4.BoxType{BoxTypeAlac()}) if err != nil || len(aalac) != 1 { return nil, err } extracted := &SongInfo{ r: f, alacParam: aalac[0].Payload.(*Alac), } moofs, err := mp4.ExtractBox(f, nil, []mp4.BoxType{ mp4.BoxTypeMoof(), }) if err != nil || len(moofs) <= 0 { return nil, err } mdats, err := mp4.ExtractBoxWithPayload(f, nil, []mp4.BoxType{ mp4.BoxTypeMdat(), }) if err != nil || len(mdats) != len(moofs) { return nil, err } for i, moof := range moofs { tfhd, err := mp4.ExtractBoxWithPayload(f, moof, []mp4.BoxType{ mp4.BoxTypeTraf(), mp4.BoxTypeTfhd(), }) if err != nil || len(tfhd) != 1 { return nil, err } tfhdPay := tfhd[0].Payload.(*mp4.Tfhd) index := tfhdPay.SampleDescriptionIndex if index != 0 { index-- } truns, err := mp4.ExtractBoxWithPayload(f, moof, []mp4.BoxType{ mp4.BoxTypeTraf(), mp4.BoxTypeTrun(), }) if err != nil || len(truns) <= 0 { return nil, err } mdat := mdats[i].Payload.(*mp4.Mdat).Data for _, t := range truns { for _, en := range t.Payload.(*mp4.Trun).Entries { info := SampleInfo{descIndex: index} switch { case t.Payload.CheckFlag(0x200): info.data = mdat[:en.SampleSize] mdat = mdat[en.SampleSize:] case tfhdPay.CheckFlag(0x10): info.data = mdat[:tfhdPay.DefaultSampleSize] mdat = mdat[tfhdPay.DefaultSampleSize:] default: info.data = mdat[:trexPay.DefaultSampleSize] mdat = mdat[trexPay.DefaultSampleSize:] } switch { case t.Payload.CheckFlag(0x100): info.duration = en.SampleDuration case tfhdPay.CheckFlag(0x8): info.duration = tfhdPay.DefaultSampleDuration default: info.duration = trexPay.DefaultSampleDuration } extracted.samples = append(extracted.samples, info) } } if len(mdat) != 0 { return nil, errors.New("offset mismatch") } } return extracted, nil}
func init() { mp4.AddBoxDef((*Alac)(nil)) }
func BoxTypeAlac() mp4.BoxType { return mp4.StrToBoxType("alac") }
type Alac struct { mp4.FullBox
mp4:"extend"FrameLength uint32 `mp4:"size=32"` CompatibleVersion uint8 `mp4:"size=8"` BitDepth uint8 `mp4:"size=8"` Pb uint8 `mp4:"size=8"` Mb uint8 `mp4:"size=8"` Kb uint8 `mp4:"size=8"` NumChannels uint8 `mp4:"size=8"` MaxRun uint16 `mp4:"size=16"` MaxFrameBytes uint32 `mp4:"size=32"` AvgBitRate uint32 `mp4:"size=32"` SampleRate uint32 `mp4:"size=32"`}
func getInfoFromAdam(adamId string, token string, storefront string) (*SongData, error) { request, err := http.NewRequest("GET", fmt.Sprintf("https://amp-api.music.apple.com/v1/catalog/%s/songs/%s", storefront, adamId), nil) if err != nil { return nil, err } query := url.Values{} query.Set("extend", "extendedAssetUrls") query.Set("include", "albums") request.URL.RawQuery = query.Encode()
request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token)) request.Header.Set("User-Agent", "iTunes/12.11.3 (Windows; Microsoft Windows 10 x64 Professional Edition (Build 19041); x64) AppleWebKit/7611.1022.4001.1 (dt:2)") request.Header.Set("Origin", "https://music.apple.com") do, err := http.DefaultClient.Do(request) if err != nil { return nil, err } defer do.Body.Close() if do.StatusCode != http.StatusOK { return nil, errors.New(do.Status) } obj := new(ApiResult) err = json.NewDecoder(do.Body).Decode(&obj) if err != nil { return nil, err } for _, d := range obj.Data { if d.ID == adamId { return &d, nil } } return nil, nil}
func getToken() (string, error) { req, err := http.NewRequest("GET", "https://beta.music.apple.com", nil) if err != nil { return "", err }
resp, err := http.DefaultClient.Do(req) if err != nil { return "", err } defer resp.Body.Close() body, err := io.ReadAll(resp.Body) if err != nil { return "", err } regex := regexp.MustCompile(`/assets/index-legacy-[^/]+\.js`) indexJsUri := regex.FindString(string(body)) req, err = http.NewRequest("GET", "https://beta.music.apple.com"+indexJsUri, nil) if err != nil { return "", err } resp, err = http.DefaultClient.Do(req) if err != nil { return "", err } defer resp.Body.Close() body, err = io.ReadAll(resp.Body) if err != nil { return "", err } regex = regexp.MustCompile(`eyJh([^"]*)`) token := regex.FindString(string(body)) return token, nil}
type ApiResult struct { Data []SongData
json:"data"}type SongAttributes struct { ArtistName string
json:"artistName"DiscNumber intjson:"discNumber"GenreNames []stringjson:"genreNames"ExtendedAssetUrls struct { EnhancedHls stringjson:"enhancedHls"}json:"extendedAssetUrls"IsMasteredForItunes booljson:"isMasteredForItunes"ReleaseDate stringjson:"releaseDate"Name stringjson:"name"Isrc stringjson:"isrc"AlbumName stringjson:"albumName"TrackNumber intjson:"trackNumber"ComposerName stringjson:"composerName"}type AlbumAttributes struct { ArtistName string
json:"artistName"IsSingle booljson:"isSingle"IsComplete booljson:"isComplete"GenreNames []stringjson:"genreNames"TrackCount intjson:"trackCount"IsMasteredForItunes booljson:"isMasteredForItunes"ReleaseDate stringjson:"releaseDate"Name stringjson:"name"RecordLabel stringjson:"recordLabel"Upc stringjson:"upc"Copyright stringjson:"copyright"IsCompilation booljson:"isCompilation"}type SongData struct { ID string
json:"id"Attributes SongAttributesjson:"attributes"Relationships struct { Albums struct { Data []struct { ID stringjson:"id"Type stringjson:"type"Href stringjson:"href"Attributes AlbumAttributesjson:"attributes"}json:"data"}json:"albums"Artists struct { Href stringjson:"href"Data []struct { ID stringjson:"id"Type stringjson:"type"Href stringjson:"href"}json:"data"}json:"artists"}json:"relationships"}type SongResult struct { Artwork struct { Width int
json:"width"URL stringjson:"url"Height intjson:"height"TextColor3 stringjson:"textColor3"TextColor2 stringjson:"textColor2"TextColor4 stringjson:"textColor4"HasAlpha booljson:"hasAlpha"TextColor1 stringjson:"textColor1"BgColor stringjson:"bgColor"HasP3 booljson:"hasP3"SupportsLayeredImage booljson:"supportsLayeredImage"}json:"artwork"ArtistName stringjson:"artistName"CollectionID stringjson:"collectionId"DiscNumber intjson:"discNumber"GenreNames []stringjson:"genreNames"ID stringjson:"id"DurationInMillis intjson:"durationInMillis"ReleaseDate stringjson:"releaseDate"ContentRatingsBySystem struct { }json:"contentRatingsBySystem"Name stringjson:"name"Composer struct { Name stringjson:"name"URL stringjson:"url"}json:"composer"EditorialArtwork struct { }json:"editorialArtwork"CollectionName stringjson:"collectionName"AssetUrls struct { Plus stringjson:"plus"Lightweight stringjson:"lightweight"SuperLightweight stringjson:"superLightweight"LightweightPlus stringjson:"lightweightPlus"EnhancedHls stringjson:"enhancedHls"}json:"assetUrls"AudioTraits []stringjson:"audioTraits"Kind stringjson:"kind"Copyright stringjson:"copyright"ArtistID stringjson:"artistId"Genres []struct { GenreID stringjson:"genreId"Name stringjson:"name"URL stringjson:"url"MediaType stringjson:"mediaType"}json:"genres"TrackNumber intjson:"trackNumber"AudioLocale stringjson:"audioLocale"Offers []struct { ActionText struct { Short stringjson:"short"Medium stringjson:"medium"Long stringjson:"long"Downloaded stringjson:"downloaded"Downloading stringjson:"downloading"}json:"actionText"Type stringjson:"type"PriceFormatted stringjson:"priceFormatted"Price float64json:"price"BuyParams stringjson:"buyParams"Variant stringjson:"variant,omitempty"Assets []struct { Flavor stringjson:"flavor"Preview struct { Duration intjson:"duration"URL stringjson:"url"}json:"preview"Size intjson:"size"Duration intjson:"duration"}json:"assets"}json:"offers"} type iTunesLookup struct { Results map[string]SongResultjson:"results"}type Meta struct { Context string
json:"@context"Type stringjson:"@type"Name stringjson:"name"Description stringjson:"description"Tracks []struct { Type stringjson:"@type"Name stringjson:"name"Audio struct { Type stringjson:"@type"}json:"audio"Offers struct { Type stringjson:"@type"Category stringjson:"category"Price intjson:"price"}json:"offers"Duration stringjson:"duration"}json:"tracks"Citation []interface{}json:"citation"WorkExample []struct { Type stringjson:"@type"Name stringjson:"name"URL stringjson:"url"Audio struct { Type stringjson:"@type"}json:"audio"Offers struct { Type stringjson:"@type"Category stringjson:"category"Price intjson:"price"}json:"offers"Duration stringjson:"duration"}json:"workExample"Genre []stringjson:"genre"DatePublished time.Timejson:"datePublished"ByArtist struct { Type stringjson:"@type"URL stringjson:"url"Name stringjson:"name"}json:"byArtist"}type AutoGenerated struct { Data []struct { ID string
json:"id"Type stringjson:"type"Href stringjson:"href"Attributes struct { Artwork struct { Width intjson:"width"Height intjson:"height"URL stringjson:"url"BgColor stringjson:"bgColor"TextColor1 stringjson:"textColor1"TextColor2 stringjson:"textColor2"TextColor3 stringjson:"textColor3"TextColor4 stringjson:"textColor4"}json:"artwork"ArtistName stringjson:"artistName"IsSingle booljson:"isSingle"URL stringjson:"url"IsComplete booljson:"isComplete"GenreNames []stringjson:"genreNames"TrackCount intjson:"trackCount"IsMasteredForItunes booljson:"isMasteredForItunes"ReleaseDate stringjson:"releaseDate"Name stringjson:"name"RecordLabel stringjson:"recordLabel"Upc stringjson:"upc"AudioTraits []stringjson:"audioTraits"Copyright stringjson:"copyright"PlayParams struct { ID stringjson:"id"Kind stringjson:"kind"}json:"playParams"IsCompilation booljson:"isCompilation"}json:"attributes"Relationships struct { RecordLabels struct { Href stringjson:"href"Data []interface{}json:"data"}json:"record-labels"Artists struct { Href stringjson:"href"Data []struct { ID stringjson:"id"Type stringjson:"type"Href stringjson:"href"Attributes struct { Name stringjson:"name"}json:"attributes"}json:"data"}json:"artists"Tracks struct { Href stringjson:"href"Data []struct { ID stringjson:"id"Type stringjson:"type"Href stringjson:"href"Attributes struct { Previews []struct { URL stringjson:"url"}json:"previews"Artwork struct { Width intjson:"width"Height intjson:"height"URL stringjson:"url"BgColor stringjson:"bgColor"TextColor1 stringjson:"textColor1"TextColor2 stringjson:"textColor2"TextColor3 stringjson:"textColor3"TextColor4 stringjson:"textColor4"}json:"artwork"ArtistName stringjson:"artistName"URL stringjson:"url"DiscNumber intjson:"discNumber"GenreNames []stringjson:"genreNames"HasTimeSyncedLyrics booljson:"hasTimeSyncedLyrics"IsMasteredForItunes booljson:"isMasteredForItunes"DurationInMillis intjson:"durationInMillis"ReleaseDate stringjson:"releaseDate"Name stringjson:"name"Isrc stringjson:"isrc"AudioTraits []stringjson:"audioTraits"HasLyrics booljson:"hasLyrics"AlbumName stringjson:"albumName"PlayParams struct { ID stringjson:"id"Kind stringjson:"kind"}json:"playParams"TrackNumber intjson:"trackNumber"AudioLocale stringjson:"audioLocale"ComposerName stringjson:"composerName"}json:"attributes"Relationships struct { Artists struct { Href stringjson:"href"Data []struct { ID stringjson:"id"Type stringjson:"type"Href stringjson:"href"Attributes struct { Name stringjson:"name"}json:"attributes"}json:"data"}json:"artists"}json:"relationships"}json:"data"}json:"tracks"}json:"relationships"}json:"data"}what this code does?
- Assistant
The provided Go code appears to be a comprehensive program designed for interacting with Apple Music to decrypt and download music tracks and associated metadata. Below, I'll break down its functionality into several key components:
-
Decrypting Apple Music Content: It involves extracting encrypted Apple Music tracks and decrypting them. This is notable from functions like
decryptSong, which seemingly communicates with a local server (likely part of the decryption process) to decrypt music tracks. -
Extracting Track Information and Metadata: Functions such as
getMetaandgetInfoFromAdammake HTTP requests to the Apple Music API to fetch metadata for albums and tracks. This metadata includes details like the artist's name, album information, track names, and more. -
Downloading Track Media: The program retrieves the music track's actual media content from Apple Music and temporarily saves it, possibly for decryption. This process involves parsing m3u8 playlists (a common format for streaming multimedia) to find the best audio stream available and then downloading it.
-
Parsing and Writing Metadata into Audio Files: After downloading and presumably decrypting the audio files, the program embeds metadata into the resulting M4A files through MP4 boxes. This includes track name, artist, album name, and potentially artwork among other metadata. The
writeM4afunction is integral to creating the final audio file with all this information. -
File Management and Organization: The code segments related to file and directory management ensure that downloaded and processed tracks are saved in an organized manner. It also involves sanitizing album and track names to be file-system friendly, creating directories for album downloads, and handling cover art graphics.
-
HTTP Communication and API Interaction: Several parts of the program make HTTP requests to Apple Music's API endpoints and possibly other services for metadata and music streaming URLs. This includes prepared headers to mimic legitimate requests from an application or browser.
-
Extracting Stream Details: The program parses m3u8 master playlists to identify suitable audio streams, focusing on the ALAC format (Apple Lossless Audio Codec) for high-quality audio.
-
Command Line Interface (CLI): The
mainfunction and related command-line argument parsing indicate that the program is designed to be executed via a CLI, taking one or more Apple Music album URLs as input. -
Fetching Tokens and Handling Authentication: Parts of the code are dedicated to fetching authentication tokens, likely required to access restricted content or utilize Apple Music API endpoints. This process seems to involve scraping a token from Apple Music's web platform.
-
Regulatory Compliance and Restrictions: Notably, the functionality to decrypt Apple Music tracks, which are likely protected by Digital Rights Management (DRM), suggests activities that may not comply with Apple's terms of service or copyright laws in many jurisdictions.
In summary, this program seems to automate the process of downloading, decrypting, and re-encoding music from Apple Music, complete with metadata, for personal archival or use. Potential users should be aware of legal and ethical considerations regarding DRM-protected content and comply with local laws and service terms.
-