コード例 #1
0
ファイル: MusicDBParser.cs プロジェクト: rroc/gmsvis
        //////////////////////////////////////////////////////////////////////////
        // Method:    AddReleaseDate
        // FullName:  MusicDataminer.MusicDBParser.AddReleaseDate
        // Access:    private
        // Returns:   void
        // Parameter: MusicBrainzRelease release
        //////////////////////////////////////////////////////////////////////////
        private void AddReleaseDate(MusicBrainzRelease release)
        {
            int key = release.date;
            List <MusicBrainzRelease> dates;

            if (!this.dataBase.dates.ContainsKey(key))
            {
                dates = new List <MusicBrainzRelease>();
                this.dataBase.dates[key] = dates;
            }
            else
            {
                dates = (List <MusicBrainzRelease>) this.dataBase.dates[key];
            }

            dates.Add(release);
        }
コード例 #2
0
ファイル: MusicDBParser.cs プロジェクト: rroc/gmsvis
        //////////////////////////////////////////////////////////////////////////
        // Method:    GetMusicBrainzReleases
        // FullName:  MusicDataminer.MusicDBParser.GetMusicBrainzReleases
        // Access:    public
        // Returns:   bool
        // Parameter: string artist
        // Parameter: string albumName
        // Parameter: MusicBrainz o
        // Parameter: List<MusicBrainzAlbum> releasesList
        // Parameter: out string retrievedName
        //////////////////////////////////////////////////////////////////////////
        public bool GetMusicBrainzReleases(string artist, string albumName,
                                           List <MusicBrainzRelease> releasesList, out string retrievedName, string aStyle)
        {
            MusicBrainz o;

            // Create the musicbrainz object, which will be needed for subsequent calls
            o = new MusicBrainz();
            // Set the proper server to use. Defaults to mm.musicbrainz.org:80
            if (Environment.GetEnvironmentVariable("MB_SERVER") != null)
            {
                o.SetServer(Environment.GetEnvironmentVariable("MB_SERVER"), 80);
            }
            // Check to see if the debug env var has been set
            if (Environment.GetEnvironmentVariable("MB_DEBUG") != null)
            {
                o.SetDebug(Environment.GetEnvironmentVariable("MB_DEBUG") != "0");
            }
            // Tell the server to only return 4 levels of data, unless the MB_DEPTH env var is set
            if (Environment.GetEnvironmentVariable("MB_DEPTH") != null)
            {
                o.SetDepth(int.Parse(Environment.GetEnvironmentVariable("MB_DEPTH")));
            }
            else
            {
                o.SetDepth(4);
            }

            retrievedName = albumName;
            bool foundRelevantRelease = false;

            //Console.WriteLine("Searching for occurrences for: " + artist + " / " + albumName);
            iForm.PrintLine("(" + aStyle + ") LOOK: " + artist + " / " + albumName);
            bool found = o.Query(MusicBrainz.MBQ_FileInfoLookup, new String[] { "", artist, albumName, "", "", "" });

            if (!found)
            {
                return(found);
            }

            // Select the first album
            o.Select(MusicBrainz.MBS_SelectLookupResult, 1);

            string type;

            o.GetResultData(MusicBrainz.MBE_LookupGetType, out type);
            string fragment;

            o.GetFragmentFromURL(type, out fragment);

            // iterate through all the results
            o.Select(MusicBrainz.MBS_Rewind);

            if (!o.Select(MusicBrainz.MBS_SelectLookupResult, 1))
            {
                return(foundRelevantRelease);
            }

            // NOTE: must be done before the next Select
            int relevance = o.GetResultInt(MusicBrainz.MBE_LookupGetRelevance);

            // if not sure about it, quit
            if (relevance < 80)
            {
                return(foundRelevantRelease);
            }

            // select the album
            o.Select(MusicBrainz.MBS_SelectLookupResultAlbum);

            o.GetResultData(MusicBrainz.MBE_AlbumGetAlbumName, out retrievedName);

            int nReleases = o.GetResultInt(MusicBrainz.MBE_AlbumGetNumReleaseDates);

            if (nReleases != 0)
            {
                albumName = retrievedName;

                for (int i = 1; i <= nReleases; i++)
                {
                    if (o.Select(MusicBrainz.MBS_SelectReleaseDate, i))
                    {
                        foundRelevantRelease = true;

                        string country;
                        o.GetResultData(MusicBrainz.MBE_ReleaseGetCountry, out country);

                        string date;
                        o.GetResultData(MusicBrainz.MBE_ReleaseGetDate, out date);

                        if (dataBase.countries.ContainsKey(country.ToUpper()))
                        {
                            // add it to the list
                            MusicBrainzRelease release = new MusicBrainzRelease();

                            release.country = (Country)dataBase.countries[country];

                            if (date.Length >= 4)
                            {
                                release.date = int.Parse(date.Substring(0, 4));
                            }
                            else
                            {
                                return(false); //release.date = int.Parse(date);
                            }

                            // Add the release both to the Album and Country
                            releasesList.Add(release);
                            release.country.releases.Add(release);
                        }
                    }

                    o.Select(MusicBrainz.MBS_Back);
                }
            }
            return(foundRelevantRelease);
        }
コード例 #3
0
ファイル: MusicDBParser.cs プロジェクト: rroc/gmsvis
        public static bool FilterDB(string srcDBFilename,
                                    string outputFilename)
        {
            DB destination;

            string iGeoDataPath = "./geodata/";

            List <string> countryFilter = ParseCountryFilter(iGeoDataPath + "countries_acronyms_europe.txt");

            bool loaded = MusicDBLoader.LoadDB(srcDBFilename, out destination);

            if (loaded)
            {
                ArrayList albums = new ArrayList(destination.albums.Values);
                for (int i = 0; i < albums.Count; i++)
                {
                    Album album = (Album)albums[i];

                    for (int j = 0; j < album.releases.Count; j++)
                    {
                        MusicBrainzRelease release = album.releases[j];

                        if (!countryFilter.Contains(release.country.acronym))
                        {
                            album.releases.RemoveAt(j--);
                            release.freeDBAlbum = null;
                        }
                    }

                    // if it became an empty album
                    if (album.releases.Count == 0)
                    {
                        string key = album.artist.name + "€" + album.title;
                        key = key.ToLowerInvariant();

                        key = ClearString(key);
                        destination.albums.Remove(key);

                        key = ClearString(album.artist.name.ToLowerInvariant());
                        Artist artist = (Artist)destination.artists[key];
                        artist.albums.Remove(album);

                        if (album.artist.albums.Count == 0)
                        {
                            destination.artists.Remove(key);
                        }
                    }
                }

                // filter releases in styles
                foreach (Style style in destination.styles.Values)
                {
                    for (int k = 0; k < style.releases.Count; k++)
                    {
                        MusicBrainzRelease release = style.releases[k];

                        if (release.freeDBAlbum == null ||
                            !countryFilter.Contains(release.country.acronym))
                        {
                            style.releases.RemoveAt(k--);
                        }
                    }
                }

                // filter countries
                ArrayList countries = new ArrayList(destination.countries.Values);
                foreach (Country country in countries)
                {
                    if (!countryFilter.Contains(country.acronym))
                    {
                        destination.countries.Remove(country.acronym);
                    }
                    else
                    {
                        for (int k = 0; k < country.releases.Count; k++)
                        {
                            MusicBrainzRelease release = country.releases[k];

                            if (release.freeDBAlbum == null)
                            {
                                country.releases.RemoveAt(k--);
                            }
                        }
                    }
                }

                // filter styles
                ArrayList styles = new ArrayList(destination.styles.Keys);
                for (int k = 0; k < styles.Count; k++)
                {
                    object key   = styles[k];
                    Style  style = (Style)destination.styles[key];

                    if (style.releases.Count == 0)
                    {
                        destination.styles.Remove(key);
                    }
                }

                MusicDBLoader.SaveDB(outputFilename, destination);

                return(true);
            }

            return(false);
        }