private void AddReleases()
        {
            foreach (LocalAlbum album in matcherResult.NewReleases)
            {
                Release release = new Release();
                release.JoinedAlbumArtists = album.AlbumArtist;
                release.Artists.Add(new ReleaseArtist()
                {
                    Artist = this.collectionManager.GetOrCreateArtist(album.AlbumArtist)
                });
                release.Title = album.Title;
                if (album.Year == 0)
                {
                    release.ReleaseDate = new ReleaseDate();
                }
                else
                {
                    release.ReleaseDate = new ReleaseDate(album.Year);
                }
                release.Genre = album.Genre;
                release.Tracklist.AddRange(this.collectionManager.Operations.GenerateTracklistForLocalAlbum(this.collectionManager, album, release));

                release.DateAdded = DateTime.Now;
                release.DateModified = DateTime.Now;
                release.DateAudioModified = DateTime.Now;

                release.UpdateDynamicProperties();
                this.collectionManager.Save(release);

                ++this.totalProcessed;
                this.OnProgressChanged();
            }
        }
Ejemplo n.º 2
0
 public TreeReleaseItem(TreeArtistItem artistItem, Release release, bool showImage, bool showEmptyImage)
 {
     this.ArtistItem = artistItem;
     this.Release = release;
     this.showImage = showImage;
     this.showEmptyImage = showEmptyImage;
 }
        private List<IParallelTask> GenerateReplayGainTasks(Release[] releases, IProgress<double> progress)
        {
            List<IParallelTask> tasks = new List<IParallelTask>();

            DspEncoderFactory replayGainFactory = new DspEncoderFactory(this.settingsManager.Settings.LocalConcurrencyLevel, true, false);

            double progressCoef = 1.0 / releases.Length;
            int processed = 0;
            foreach (Release release in releases)
            {
                ReplayGainTask rgTask = new ReplayGainTask(replayGainFactory, release, true, true, false);

                foreach (Track track in release.Tracklist)
                {
                    string filename = Path.Combine(this.CollectionManager.Settings.MusicDirectory, track.RelativeFilename);
                    var task = new FileEncodeTask(replayGainFactory, () => AudioHelper.GetAudioSourceForFile(filename), filename, null);

                    tasks.Add(task);
                    rgTask.AddItem(track, task);
                }

                tasks.Add(rgTask);

                ++processed;
                progress.Report(processed * progressCoef);
            }

            return tasks;
        }
Ejemplo n.º 4
0
        public override IEnumerable GetDistribution(Release[] releases)
        {
            SortedDictionary<int, int> result = new SortedDictionary<int, int>();
            foreach (Release release in releases)
            {
                int year = this.GetYear(release);
                if (year != 0)
                {
                    int bucket = year / Step * Step;

                    if (!result.ContainsKey(bucket))
                    {
                        result[bucket] = 0;
                    }

                    ++result[bucket];
                }
            }

            foreach (var item in result)
            {
                int startYear = item.Key;
                int endYear = item.Key + Step - 1;
                yield return new Item()
                {
                    Key = " " + startYear + "-" + endYear + " ",
                    Value = item.Value,
                    Start = startYear,
                    End = endYear
                };
            }
        }
 public void PlayRelease(Release release)
 {
     string tempPath = Path.GetTempPath();
     string playlistPath = Path.Combine(tempPath, "MusicDatabasePlaylist.m3u8");
     File.WriteAllText(playlistPath, M3UGenerator.GeneratePlaylist(release, release.Tracklist, this.CollectionManager.Settings.MusicDirectory), Encoding.UTF8);
     Process.Start(playlistPath);
 }
        private void AddItemsForRelease(Release release)
        {
            int currentDisc = 0;
            foreach (Track track in release.Tracklist)
            {
                if (release.DiscCount != 1 && track.Disc != currentDisc)
                {
                    currentDisc = track.Disc;
                    this.listTracks.Items.Add(new CustomListViewItem()
                    {
                        Title = "Disc " + currentDisc,
                        FontStyle = FontStyles.Italic,

                        DynamicRange = DspHelper.GetRoundedDr(release.DynamicRange),
                        DynamicRangeBrush = UIHelper.GetDrBrush(DspHelper.GetRoundedDr(release.DynamicRange), drAlpha),

                        AlbumGain = FormatGain(release.ReplayGainAlbumGain)
                    });
                }

                this.listTracks.Items.Add(new CustomListViewItem()
                {
                    Disc = track.Disc.ToString(),
                    Position = track.Position.ToString(),
                    JoinedArtists = track.JoinedArtists,
                    Title = track.Title,

                    DynamicRange = DspHelper.GetRoundedDr(track.DynamicRange),
                    DynamicRangeBrush = UIHelper.GetDrBrush(DspHelper.GetRoundedDr(release.DynamicRange), drAlpha),

                    AlbumGain = FormatGain(release.ReplayGainAlbumGain),
                    TrackGain = FormatGain(track.ReplayGainTrackGain)
                });
            }
        }
 public DiscogsReleaseMerger(Window window, ICollectionManager collectionManager, Release release, ReleaseImagesEditor imagesEditor)
 {
     this.window = window;
     this.collectionManager = collectionManager;
     this.release = release;
     this.imagesEditor = imagesEditor;
     this.discs = new List<IEnumerable<Tuple<Track, string>>>();
 }
Ejemplo n.º 8
0
 private int GetYear(Release release)
 {
     ReleaseDate releaseDate = release.OriginalReleaseDate != null && release.OriginalReleaseDate.IsValid ? release.OriginalReleaseDate : release.ReleaseDate;
     if (releaseDate.Type != ReleaseDateType.Invalid)
     {
         return releaseDate.Date.Year;
     }
     return 0;
 }
Ejemplo n.º 9
0
 public ReplayGainTask(IEncoderFactory factory, Release release, bool recalculateReplayGain, bool writePeaks, bool saveDynamicRange)
 {
     this.EncoderFactory = factory;
     this.Release = release;
     this.TrackTasks = new List<Item>();
     this.RecalculateReplayGain = recalculateReplayGain;
     this.WritePeaks = writePeaks;
     this.SaveDynamicRange = saveDynamicRange;
 }
 public void ComputeReleaseChecksum(Release release)
 {
     AudioChecksumWindow checksumWindow = new AudioChecksumWindow();
     foreach (Track track in release.Tracklist)
     {
         checksumWindow.AddItem(track.GetAbsoluteFilename(this.CollectionManager));
     }
     checksumWindow.ShowDialog(Window.GetWindow(this.mainCollectionView));
 }
 public bool DeleteRelease(Release release, bool tryDeleteFiles)
 {
     Release currentRelease = this.releases.Where(r => r.Id.Equals(release.Id)).FirstOrDefault();
     if (currentRelease != null)
     {
         this.releases.Remove(currentRelease);
     }
     return true;
 }
        public ViewReleaseImagesWindow(ICollectionManager collectionManager, Release release)
        {
            this.release = release;
            this.CollectionManager = collectionManager;

            InitializeComponent();

            this.releaseImagesEditor.CollectionManager = this.CollectionManager;
            this.releaseImagesEditor.Release = release;
        }
        public WikipediaImporterWindow(Release release)
        {
            this.release = release;

            InitializeComponent();

            this.textOldReleaseDate.Text = "Current: " + (release.OriginalReleaseDate.IsValid ? release.OriginalReleaseDate.ToString() : "empty");

            this.PickPageName();
        }
Ejemplo n.º 14
0
        public override IEnumerable GetDistribution(Release[] releases)
        {
            if (releases.Length == 0)
            {
                yield break;
            }

            DateTime[] dates = releases.Select(r => r.DateAdded).ToArray();

            DateTime start = dates.Min();
            start = new DateTime(start.Year, start.Month, 1);

            int[] offsets = dates.Select(d => this.MonthsDifference(d, start)).ToArray();
            int maxOffset = offsets.Max();
            int scale = maxOffset / 32 + 1;
            maxOffset /= scale;

            int[] counts = new int[maxOffset + 1];
            for (int i = 0; i < offsets.Length; ++i)
            {
                int limit = offsets[i] / scale;
                for (int j = limit; j < counts.Length; ++j)
                {
                    ++counts[j];
                }
            }

            for (int i = 0; i < counts.Length; ++i)
            {
                int offset = i * scale;
                DateTime date1 = start.AddMonths(offset);
                DateTime date2 = start.AddMonths(offset + scale - 1);
                string label;
                if (date1.Equals(date2))
                {
                    label = date1.ToString("MM/yy");
                }
                else
                {
                    label = date1.Month.ToString("00") + "-" + date2.Month.ToString("00") + "/" + date1.ToString("yy");
                }

                yield return new Item()
                {
                    Key = " " + label + " ",
                    Value = counts[i],
                    Start = start.AddMonths(offset),
                    End = start.AddMonths(offset + scale)
                };
            }
        }
        public bool IsReleasePerfect(Release release)
        {
            if (release.Images.Count == 0)
            {
                return false;
            }

            if (release.AdditionalFiles.Count == 0)
            {
                return false;
            }

            if (string.IsNullOrEmpty(release.Label))
            {
                return false;
            }

            if (string.IsNullOrEmpty(release.CatalogNumber))
            {
                return false;
            }

            if (release.IsFlagged)
            {
                return false;
            }

            if (release.ReleaseDate.Type == ReleaseDateType.Invalid)
            {
                return false;
            }

            if (string.IsNullOrEmpty(release.Country))
            {
                return false;
            }

            if (release.DiscogsReleaseId == 0)
            {
                return false;
            }

            if (release.DiscogsMasterId == 0)
            {
                return false;
            }

            return true;
        }
        public ReplaceReleaseFilesWindow(ICollectionSessionFactory collectionSessionFactory, string releaseId)
            : base(collectionSessionFactory)
        {
            this.release = this.CollectionManager.GetReleaseById(releaseId);

            InitializeComponent();

            this.networkBox.CollectionManager = this.CollectionManager;
            this.networkBox.SettingsManager = this.SettingsManager;

            this.items = new ObservableCollection<IImportSourceItem>();
            this.items.CollectionChanged += this.items_CollectionChanged;

            this.listTracks.ItemsSource = release.Tracklist;
            this.listImportItems.ItemsSource = this.items;
        }
 public void DeleteRelease(Release release)
 {
     VerificationWindow verify = new VerificationWindow("This will permanently delete all files and images!");
     if (verify.ShowDialog(Window.GetWindow(this.mainCollectionView)) == true)
     {
         //using (var transaction = this.CollectionManager.BeginTransaction())
         //{
         string releaseName = release.JoinedAlbumArtists + " - " + release.Title;
         if (!this.CollectionManager.DeleteRelease(release, true))
         {
             Dialogs.Inform("Some files from " + releaseName + " were not deleted successfully. Please check by hand.");
         }
         //transaction.Commit();
         //}
         CollectionManagerGlobal.OnCollectionChanged();
     }
 }
Ejemplo n.º 18
0
        public override IEnumerable GetDistribution(Release[] releases)
        {
            Dictionary<string, int> result = new Dictionary<string, int>();

            foreach (Release release in releases)
            {
                if (!string.IsNullOrEmpty(release.Country))
                {
                    if (!result.ContainsKey(release.Country))
                    {
                        result[release.Country] = 0;
                    }

                    ++result[release.Country];
                }
            }

            var allItems = result.OrderBy(i => -i.Value);
            var topItems = allItems.Take(6);
            var otherItems = allItems.Skip(6);
            int otherItemsSum = otherItems.Sum(i => i.Value);

            foreach (var topItem in topItems)
            {
                yield return new Item()
                {
                    Key = topItem.Key + " (" + topItem.Value + ")",
                    Value = topItem.Value,
                    Countries = new string[] { topItem.Key },
                };
            }

            if (otherItemsSum != 0)
            {
                yield return new Item()
                {
                    Key = "Other (" + otherItemsSum + ")",
                    Value = otherItemsSum,
                    Countries = otherItems.Select(i => i.Key).ToArray()
                };
            }
        }
Ejemplo n.º 19
0
 public static void UpdateReleaseThumbnail(Release release, ICollectionImageHandler imageHandler)
 {
     Image mainImage = release.Images.FirstOrDefault(i => i.IsMain);
     if (mainImage != null)
     {
         byte[] thumbnail = null;
         string thumbExtension = null, thumbMimeType = null;
         thumbnail = ThumbnailGenerator.CreateThumbnail(
                       imageHandler.LoadImage(mainImage),
                       MusicDatabase.Engine.Entities.Release.ThumbnailSize,
                       out thumbExtension,
                       out thumbMimeType);
         release.Thumbnail = thumbnail;
         Assert.IsTrue(thumbMimeType == MusicDatabase.Engine.Entities.Release.ThumbnailMimeType);
     }
     else
     {
         release.Thumbnail = null;
     }
 }
Ejemplo n.º 20
0
        public void LoadReleases(Release[] releases)
        {
            this.listView.ItemsSource = null;
            this.releaseItemByReleaseId.Clear();

            if (releases != null)
            {
                bool showImages = this.CollectionManager.Settings.ShowImagesInReleaseTree;

                var releaseItems = releases.OrderBy(r => r, this.GetComparer()).Select(r => new ReleaseItem(r, showImages)).ToArray();

                this.releaseItemByReleaseId.Clear();
                foreach (var releaseItem in releaseItems)
                {
                    this.releaseItemByReleaseId[releaseItem.Release.Id] = releaseItem;
                }

                this.listView.ItemsSource = releaseItems;
            }
        }
Ejemplo n.º 21
0
        public AudioFileTag(Release release, Track track)
        {
            this.AlbumArtists = release.JoinedAlbumArtists;
            if (string.IsNullOrEmpty(track.JoinedArtists))
            {
                this.Artists = release.JoinedAlbumArtists;
            }
            else
            {
                this.Artists = track.JoinedArtists;
            }
            this.Album = release.Title;
            this.Title = track.Title;
            this.Track = track.Position;
            this.TrackCount = release.Tracklist.Count(t => t.Disc == track.Disc);
            this.Disc = track.Disc;
            this.DiscCount = release.DiscCount;
            if (release.OriginalReleaseDate != null && release.OriginalReleaseDate.IsValid)
            {
                this.Year = release.OriginalReleaseDate.Date.Year;
            }
            else
            {
                this.Year = release.ReleaseDate.IsValid ? release.ReleaseDate.Date.Year : 0;
            }
            this.Genre = release.Genre;

            Image mainImage = release.Images.Where(i => i.IsMain == true).FirstOrDefault();
            if (release.Thumbnail != null && mainImage != null)
            {
                this.Images = new AudioFileImage[]
                {
                    new AudioFileImage() {
                        Data = release.Thumbnail,
                        MimeType = Release.ThumbnailMimeType,
                        Description = mainImage.Description,
                        Type = mainImage.Type
                    }
                };
            }
        }
Ejemplo n.º 22
0
 public static string GeneratePlaylist(Release release, IEnumerable<Track> tracklist, string musicRoot)
 {
     StringBuilder sb = new StringBuilder();
     sb.AppendLine("#EXTM3U");
     sb.AppendLine();
     foreach (Track track in tracklist)
     {
         sb.Append("#EXTINF:-1,");
         if (release.HasTrackArtists)
         {
             sb.Append(track.JoinedArtists);
         }
         else
         {
             sb.Append(release.JoinedAlbumArtists);
         }
         sb.AppendLine(" - "+track.Title);
         sb.AppendLine(Path.Combine(musicRoot, track.RelativeFilename));
     }
     return sb.ToString();
 }
Ejemplo n.º 23
0
        public override IEnumerable GetDistribution(Release[] releases)
        {
            SortedDictionary<int, int> result = new SortedDictionary<int, int>();
            if (releases.Length == 0)
            {
                return result;
            }

            var releasesWithRg = releases.Where(r => !double.IsNaN(r.ReplayGainAlbumGain)).ToArray();
            int minRg = (int)releasesWithRg.Min(r => r.ReplayGainAlbumGain);
            int maxRg = (int)releasesWithRg.Max(r => r.ReplayGainAlbumGain);
            for (int i = minRg; i <= maxRg; ++i)
            {
                result[i] = 0;
            }
            foreach (Release release in releasesWithRg)
            {
                ++result[(int)release.ReplayGainAlbumGain];
            }
            return result;
        }
        public void LoadReleaseFromXml(string path)
        {
            this.busyIndicator.IsBusy = true;

            new Task(() =>
            {
                using (XmlReleaseImporter xmlReleaseImporter = new XmlReleaseImporter(path, this.CollectionManager))
                {
                    this.release = xmlReleaseImporter.ImportRelease();
                }

                this.Dispatcher.InvokeAction(() =>
                {
                    this.releaseDetails.Visibility = Visibility.Visible;
                    this.tracklistView.Visibility = Visibility.Visible;
                    this.busyIndicator.IsBusy = false;

                    this.UpdateUI();
                });
            }).Start();
        }
        private void GenerateDynamicRangeTasks(Release[] releases, IProgress<double> progress)
        {
            DspEncoderFactory replayGainFactory = new DspEncoderFactory(this.settingsManager.Settings.LocalConcurrencyLevel, false, true);

            double progressCoef = 1.0 / releases.Length;
            int processed = 0;
            foreach (Release release in releases)
            {
                foreach (Track track in release.Tracklist)
                {
                    string filename = Path.Combine(this.CollectionManager.Settings.MusicDirectory, track.RelativeFilename);
                    var task = new FileEncodeTask(replayGainFactory, () => AudioHelper.GetAudioSourceForFile(filename), filename, null);

                    this.trackToTask[track] = task;
                    this.tasks.Add(task);
                }

                ++processed;
                progress.Report(processed * progressCoef);
            }
        }
Ejemplo n.º 26
0
        public override IEnumerable GetDistribution(Release[] releases)
        {
            if (releases.Length == 0)
            {
                yield break;
            }

            List<int> buckets = new List<int>(Enumerable.Repeat(0, BucketSize + 1));

            foreach (Release release in releases)
            {
                ++buckets[release.Score / BucketSize];
            }

            bool started = false;

            int bucketIndex = 0;
            foreach (int bucket in buckets)
            {
                started = started || (bucket > 0);

                if (started)
                {
                    int bucketRangeStart = bucketIndex * BucketSize;
                    int bucketRangeEnd = bucketRangeStart + BucketSize - 1;
                    string key = bucketIndex == 10 ? "100" : (bucketRangeStart + " - " + bucketRangeEnd);

                    yield return new Item()
                    {
                        Key = key,
                        Value = bucket,
                        Start = bucketRangeStart,
                        End = bucketRangeEnd
                    };
                }

                ++bucketIndex;
            }
        }
Ejemplo n.º 27
0
        public override IEnumerable GetDistribution(Release[] releases)
        {
            SortedDictionary<int, int> result = new SortedDictionary<int, int>();

            var releasesWithDr = releases.Where(r => r.DynamicRange != 0).ToArray();
            if (releasesWithDr.Length == 0)
            {
                return result;
            }

            int minDr = (int)Math.Round(releasesWithDr.Min(r => r.DynamicRange));
            int maxDr = (int)Math.Round(releasesWithDr.Max(r => r.DynamicRange));
            for (int i = minDr; i <= maxDr; ++i)
            {
                result[i] = 0;
            }

            foreach (Release release in releasesWithDr)
            {
                ++result[(int)Math.Round(release.DynamicRange)];
            }

            return result;
        }
        public EditReleaseWindow(ICollectionSessionFactory sessionFactory, string releaseId)
            : base(sessionFactory)
        {
            this.release = this.CollectionManager.GetReleaseById(releaseId);

            InitializeComponent();

            this.detailsEditor.Release = this.release;
            this.imagesEditor.CollectionManager = this.CollectionManager;
            this.imagesEditor.Release = this.release;
            this.additionalFilesEditor.Release = this.release;

            for (int i = 1; i <= this.release.DiscCount; ++i)
            {
                EditReleaseDiscEditor discEditor = new EditReleaseDiscEditor();
                discEditor.SetData(this.release, i);

                this.tabs.Items.Add(new TabItem()
                {
                    Header = "Disc " + i,
                    Content = discEditor
                });
            }
        }
Ejemplo n.º 29
0
 public ReleaseScorer(Release release)
 {
     this.release = release;
 }
 public void SetData(Release release, int discNumber)
 {
     this.dataGrid.ItemsSource = release.Tracklist.Where(t => t.Disc == discNumber).ToArray();
 }