├── src
    ├── SoundFingerprinting.DuplicatesDetector
    │   ├── Settings.StyleCop
    │   ├── Application.ico
    │   ├── Images
    │   │   └── icon.png
    │   ├── View
    │   │   ├── GenericView.xaml.cs
    │   │   ├── ReportView.xaml.cs
    │   │   ├── PathListView.xaml.cs
    │   │   ├── GenericView.xaml
    │   │   ├── PathListView.xaml
    │   │   └── ReportView.xaml
    │   ├── MainWindow.xaml.cs
    │   ├── Services
    │   │   ├── ISaveFileDialogService.cs
    │   │   ├── IOpenFileDialogService.cs
    │   │   ├── IWindowService.cs
    │   │   ├── IFolderBrowserDialogService.cs
    │   │   ├── FolderBrowserDialogService.cs
    │   │   ├── IGenericViewWindow.cs
    │   │   ├── SaveFileDialogService.cs
    │   │   ├── WindowService.cs
    │   │   ├── IMessageBoxService.cs
    │   │   ├── MessageBoxService.cs
    │   │   ├── OpenFileDialogService.cs
    │   │   └── GenericViewWindowService.cs
    │   ├── ViewModel
    │   │   ├── GenericViewModel.cs
    │   │   ├── MainWindowViewModel.cs
    │   │   ├── BooleanToVisibilityConverter.cs
    │   │   ├── ViewModelBase.cs
    │   │   ├── Helper.cs
    │   │   ├── ReportViewModel.cs
    │   │   └── PathListViewModel.cs
    │   ├── app.config
    │   ├── Themes
    │   │   ├── Converters.xaml
    │   │   ├── TextBlock.xaml
    │   │   ├── ItemContStyle.xaml
    │   │   ├── SetIdConverter.cs
    │   │   ├── Brushes.xaml
    │   │   ├── Datagrid.xaml
    │   │   ├── RoundedButton.xaml
    │   │   └── ProgressBar.xaml
    │   ├── App.xaml.cs
    │   ├── Infrastructure
    │   │   ├── ServiceContainer.cs
    │   │   ├── ServiceInjector.cs
    │   │   ├── TrackHelper.cs
    │   │   └── CSVWriter.cs
    │   ├── MainWindowResourceDictionary.xaml
    │   ├── Properties
    │   │   └── AssemblyInfo.cs
    │   ├── Model
    │   │   ├── ResultItem.cs
    │   │   └── Item.cs
    │   ├── App.xaml
    │   ├── MainWindow.xaml
    │   ├── RelayCommand.cs
    │   ├── DuplicatesDetectorService.cs
    │   ├── SoundFingerprinting.DuplicatesDetector.csproj
    │   └── DuplicatesDetectorFacade.cs
    ├── .nuget
    │   ├── NuGet.exe
    │   ├── NuGet.Config
    │   └── NuGet.targets
    ├── SoundFingerprinting.DuplicatesDetector.sln
    └── Settings.StyleCop
├── .gitignore
└── licence.txt


/src/SoundFingerprinting.DuplicatesDetector/Settings.StyleCop:
--------------------------------------------------------------------------------
1 | <StyleCopSettings Version="105" />


--------------------------------------------------------------------------------
/src/.nuget/NuGet.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/AddictedCS/soundfingerprinting.duplicatesdetector/HEAD/src/.nuget/NuGet.exe


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Application.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/AddictedCS/soundfingerprinting.duplicatesdetector/HEAD/src/SoundFingerprinting.DuplicatesDetector/Application.ico


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Images/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/AddictedCS/soundfingerprinting.duplicatesdetector/HEAD/src/SoundFingerprinting.DuplicatesDetector/Images/icon.png


--------------------------------------------------------------------------------
/src/.nuget/NuGet.Config:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <configuration>
3 |   <solution>
4 |     <add key="disableSourceControlIntegration" value="true" />
5 |   </solution>
6 | </configuration>


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | release/
 2 | debug/
 3 | msbuild.log
 4 | *.suo
 5 | *.user
 6 | bin
 7 | Bin
 8 | obj
 9 | _ReSharper*
10 | *.csproj.user
11 | *.resharper.user
12 | *.suo
13 | *.cache
14 | *.nupkg
15 | TestResult.xml
16 | src/TestResults/
17 | .vagrant
18 | packages*/
19 | *.exe
20 | !NuGet.exe
21 | .vs/


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/View/GenericView.xaml.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.View
 2 | {
 3 |     public partial class GenericView
 4 |     {
 5 |         public GenericView()
 6 |         {
 7 |             InitializeComponent();
 8 |         }
 9 |     }
10 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/MainWindow.xaml.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector
 2 | {
 3 |     using System.Windows;
 4 | 
 5 |     public partial class MainWindow : Window
 6 |     {
 7 |         public MainWindow()
 8 |         {
 9 |             InitializeComponent();
10 |         }
11 |     }
12 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/View/ReportView.xaml.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.View
 2 | {
 3 |     using System.Windows.Controls;
 4 | 
 5 |     public partial class ReportView : UserControl
 6 |     {
 7 |         public ReportView()
 8 |         {
 9 |             InitializeComponent();
10 |         }
11 |     }
12 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/View/PathListView.xaml.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.View
 2 | {
 3 |     using System.Windows.Controls;
 4 | 
 5 |     public partial class PathListView : UserControl
 6 |     {
 7 |         public PathListView()
 8 |         {
 9 |             InitializeComponent();
10 |         }
11 |     }
12 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Services/ISaveFileDialogService.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.Services
 2 | {
 3 |     using System.Windows.Forms;
 4 | 
 5 |     internal interface ISaveFileDialogService
 6 |     {
 7 |         string Filename { get; }
 8 | 
 9 |         DialogResult SaveFile(string title, string filename, string extension);
10 |     }
11 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Services/IOpenFileDialogService.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.Services
 2 | {
 3 |     using System.Windows.Forms;
 4 | 
 5 |     public interface IOpenFileDialogService
 6 |     {
 7 |         string[] SelectedPaths { get; }
 8 | 
 9 |         DialogResult Show(string title, string filename, string filter, bool multiselect);
10 |     }
11 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/ViewModel/GenericViewModel.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.ViewModel
 2 | {
 3 |     using System.Collections.ObjectModel;
 4 | 
 5 |     public class GenericViewModel : ViewModelBase
 6 |     {
 7 |         private ObservableCollection<ViewModelBase> workspaces;
 8 | 
 9 |         public ObservableCollection<ViewModelBase> Workspaces
10 |         {
11 |             get { return workspaces ?? (workspaces = new ObservableCollection<ViewModelBase>()); }
12 |         }
13 |     }
14 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/app.config:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <configuration>
 3 | 
 4 |   <configSections>
 5 |     <section name="BassConfigurationSection" type="SoundFingerprinting.Audio.Bass.BassConfigurationSection, SoundFingerprinting.Audio.Bass" />
 6 |   </configSections>
 7 | 
 8 |   <BassConfigurationSection email = "gleb.godonoga@gmail.com" registrationKey = "2X155323152222" />
 9 | 
10 |   <startup>
11 |     <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5"/>
12 |   </startup>
13 | </configuration>
14 | 


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Services/IWindowService.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.Services
 2 | {
 3 |     using System;
 4 | 
 5 |     /// <summary>
 6 |     ///   Window service works as mediator between the View and View/Model
 7 |     /// </summary>
 8 |     public interface IWindowService
 9 |     {
10 |         void ShowDialog<TViewModel>(IGenericViewWindow view, TViewModel viewModel, Action<object, EventArgs> onDialogClose);
11 | 
12 |         void ShowDialog<TDialogViewModel>(IGenericViewWindow view, TDialogViewModel viewModel);
13 |     }
14 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Themes/Converters.xaml:
--------------------------------------------------------------------------------
1 | <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:vm="clr-namespace:SoundFingerprinting.DuplicatesDetector.ViewModel" x:Class="SoundFingerprinting.DuplicatesDetector.Themes.i__ahtung_sound_fingerprinting_soundfingerprintinggit_src_soundfingerprinting_duplicatesdetector_themes_converters_xaml">
2 | 	<!--Boolean to ProgressBar visibility converter used in PathListViewModel-->
3 | 	<vm:BooleanToVisibilityConverter x:Key="BooleanToVisibilityConverter"></vm:BooleanToVisibilityConverter>
4 | </ResourceDictionary>


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Services/IFolderBrowserDialogService.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.Services
 2 | {
 3 |     using System.Windows.Forms;
 4 | 
 5 |     /// <summary>
 6 |     ///   Contract for FolderBrowserDialog service
 7 |     /// </summary>
 8 |     public interface IFolderBrowserDialogService
 9 |     {
10 |         /// <summary>
11 |         ///   Gets selected path
12 |         /// </summary>
13 |         string SelectedPath { get; }
14 | 
15 |         /// <summary>
16 |         ///   Show FolderBrowserDialog
17 |         /// </summary>
18 |         /// <returns>Dialog results</returns>
19 |         DialogResult Show();
20 |     }
21 | }


--------------------------------------------------------------------------------
/licence.txt:
--------------------------------------------------------------------------------
1 | This file is part of Soundfingerprinting project - https://github.com/AddictedCS/soundfingerprinting
2 |  
3 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
4 |  
5 | You should have received a copy of the MIT along with Soundfingerprinting If not, see <https://opensource.org/licenses/MIT>.


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Services/FolderBrowserDialogService.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.Services
 2 | {
 3 |     using System.Windows.Forms;
 4 | 
 5 |     public class FolderBrowserDialogService : IFolderBrowserDialogService
 6 |     {
 7 |         #region IFolderBrowserDialogService Members
 8 | 
 9 |         public string SelectedPath { get; private set; }
10 | 
11 |         public DialogResult Show()
12 |         {
13 |             using (FolderBrowserDialog dlg = new FolderBrowserDialog())
14 |             {
15 |                 DialogResult result = dlg.ShowDialog();
16 |                 SelectedPath = dlg.SelectedPath;
17 |                 return result;
18 |             }
19 |         }
20 | 
21 |         #endregion
22 |     }
23 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/App.xaml.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector
 2 | {
 3 |     using System.Windows;
 4 | 
 5 |     using SoundFingerprinting.DuplicatesDetector.Infrastructure;
 6 |     using SoundFingerprinting.DuplicatesDetector.Services;
 7 |     using SoundFingerprinting.DuplicatesDetector.ViewModel;
 8 | 
 9 |     public partial class App
10 |     {
11 |         protected override void OnStartup(StartupEventArgs e)
12 |         {
13 |             base.OnStartup(e);
14 |             MainWindow window = new MainWindow();
15 |             ServiceInjector.InjectServices();
16 |             ViewModelBase mainViewModel = new MainWindowViewModel();
17 |             window.DataContext = mainViewModel;
18 |             window.Show();
19 |         }
20 |     }
21 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Infrastructure/ServiceContainer.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.Infrastructure
 2 | {
 3 |     using Ninject;
 4 | 
 5 |     /// <summary>
 6 |     ///   Class which will hold services injected by dependency injection on Application startup
 7 |     ///   Ninject lib is used for cross class injection
 8 |     /// </summary>
 9 |     /// <remarks>
10 |     ///   Follows the Service Locator pattern.
11 |     ///   More details can be found here:
12 |     ///   http://martinfowler.com/articles/injection.html
13 |     /// </remarks>
14 |     public static class ServiceContainer
15 |     {
16 |         /// <summary>
17 |         ///   Actual service container
18 |         /// </summary>
19 |         public static readonly IKernel Kernel = new StandardKernel();
20 |     }
21 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Services/IGenericViewWindow.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.Services
 2 | {
 3 |     using System;
 4 |     using System.ComponentModel;
 5 | 
 6 |     /// <summary>
 7 |     ///   Interface to be implemented by views
 8 |     /// </summary>
 9 |     /// <remarks>
10 |     ///   The binding between the views and view-models will be performed by a 
11 |     ///   mediator IWindowService which will take care of the abstraction
12 |     /// </remarks>
13 |     public interface IGenericViewWindow
14 |     {
15 |         event EventHandler Closed;
16 | 
17 |         event CancelEventHandler Closing;
18 | 
19 |         bool? DialogResult { get; set; }
20 | 
21 |         object DataContext { get; set; }
22 | 
23 |         void Show();
24 | 
25 |         void Close();
26 |     }
27 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/MainWindowResourceDictionary.xaml:
--------------------------------------------------------------------------------
 1 | <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:ViewModel="clr-namespace:SoundFingerprinting.DuplicatesDetector.ViewModel" xmlns:View="clr-namespace:SoundFingerprinting.DuplicatesDetector.View" x:Class="SoundFingerprinting.DuplicatesDetector.i__ahtung_sound_fingerprinting_soundfingerprintinggit_src_soundfingerprinting_duplicatesdetector_mainwindowresourcedictionary_xaml">
 2 | 
 3 | 	<!-- 
 4 |   This template applies an AllCustomersView to an instance 
 5 |   of the AllCustomersViewModel class shown in the main window.
 6 |   -->
 7 | 	<DataTemplate DataType="{x:Type ViewModel:PathListViewModel}">
 8 | 		<View:PathListView />
 9 | 	</DataTemplate>
10 | </ResourceDictionary>


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Services/SaveFileDialogService.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.Services
 2 | {
 3 |     using System.Windows.Forms;
 4 | 
 5 |     internal class SaveFileDialogService : ISaveFileDialogService
 6 |     {
 7 |         #region ISaveFileDialogService Members
 8 | 
 9 |         public string Filename { get; private set; }
10 | 
11 |         public DialogResult SaveFile(string title, string filename, string extension)
12 |         {
13 |             using (SaveFileDialog sfd = new SaveFileDialog { Title = title, FileName = filename, Filter = extension })
14 |             {
15 |                 DialogResult result = sfd.ShowDialog();
16 |                 Filename = sfd.FileName;
17 |                 return result;
18 |             }
19 |         }
20 | 
21 |         #endregion
22 |     }
23 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Themes/TextBlock.xaml:
--------------------------------------------------------------------------------
 1 | <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" x:Class="SoundFingerprinting.DuplicatesDetector.Themes.i__ahtung_sound_fingerprinting_soundfingerprintinggit_src_soundfingerprinting_duplicatesdetector_themes_textblock_xaml">
 2 | 	<ResourceDictionary.MergedDictionaries>
 3 | 		<ResourceDictionary Source="Brushes.xaml" />
 4 | 	</ResourceDictionary.MergedDictionaries>
 5 | 	<Style TargetType="TextBlock" x:Key="TextBlockStyle">
 6 | 		<Setter Property="Foreground" Value="{StaticResource DefaultControlForegroundBrush}"></Setter>
 7 | 		<Setter Property="FontFamily" Value="Courier New"></Setter>
 8 | 		<Setter Property="FontSize" Value="12"></Setter>
 9 | 	</Style>
10 | 
11 | </ResourceDictionary>


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.InteropServices;
 3 | using System.Windows;
 4 | 
 5 | [assembly: AssemblyTitle("DuplicateTracks")]
 6 | [assembly: AssemblyDescription("Duplicate audio files detector. Tool for finding duplicate audio file by their perceptual identity.")]
 7 | [assembly: AssemblyConfiguration("")]
 8 | [assembly: AssemblyCompany("Ciumac Sergiu")]
 9 | [assembly: AssemblyProduct("DuplicateTracks")]
10 | [assembly: AssemblyCopyright("Copyright © Ciumac Sergiu 2017")]
11 | [assembly: AssemblyTrademark("")]
12 | [assembly: AssemblyCulture("")]
13 | [assembly: ComVisible(false)]
14 | [assembly: ThemeInfo(ResourceDictionaryLocation.None, ResourceDictionaryLocation.SourceAssembly)]
15 | [assembly: AssemblyVersion("2.0.0")]
16 | [assembly: AssemblyFileVersion("2.0.0")]


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/ViewModel/MainWindowViewModel.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.ViewModel
 2 | {
 3 |     using System.Collections.ObjectModel;
 4 | 
 5 |     /// <summary>
 6 |     ///   Main window view model
 7 |     /// </summary>
 8 |     public class MainWindowViewModel : ViewModelBase
 9 |     {
10 |         private ObservableCollection<ViewModelBase> workspaces;
11 | 
12 |         public MainWindowViewModel()
13 |         {
14 |             /*Adding PathList view model to workspaces collection*/
15 |             ViewModelBase pathList = new PathListViewModel();
16 |             Workspaces.Add(pathList);
17 |         }
18 | 
19 |         public ObservableCollection<ViewModelBase> Workspaces
20 |         {
21 |             get { return workspaces ?? (workspaces = new ObservableCollection<ViewModelBase>()); }
22 |         }
23 |     }
24 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Services/WindowService.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.Services
 2 | {
 3 |     using System;
 4 | 
 5 |     public class WindowService : IWindowService
 6 |     {
 7 |         #region IWindowService Members
 8 | 
 9 |         public void ShowDialog<TViewModel>(IGenericViewWindow view, TViewModel viewModel, Action<object, EventArgs> onDialogClose)
10 |         {
11 |             view.DataContext = viewModel;
12 |             if (onDialogClose != null)
13 |             {
14 |                 view.Closing += (o, args) => onDialogClose(o, args);
15 |             }
16 | 
17 |             view.Show();
18 |         }
19 | 
20 |         public void ShowDialog<TViewModel>(IGenericViewWindow view, TViewModel viewModel)
21 |         {
22 |             ShowDialog(view, viewModel, null);
23 |         }
24 | 
25 |         #endregion
26 |     }
27 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Model/ResultItem.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.Model
 2 | {
 3 |     using SoundFingerprinting.DAO.Data;
 4 | 
 5 |     public class ResultItem
 6 |     {
 7 |         private readonly TrackData track;
 8 | 
 9 |         public ResultItem(int setId, TrackData track)
10 |         {
11 |             SetId = setId;
12 |             this.track = track;
13 |         }
14 | 
15 |         public int SetId { get; private set; }
16 | 
17 |         public string FileName
18 |         {
19 |             get { return System.IO.Path.GetFileName(track.MetaFields["FilePath"]); }
20 |         }
21 | 
22 |         public string Path
23 |         {
24 |             get { return track.MetaFields["FilePath"]; }
25 |         }
26 |         
27 |         public double TrackLength
28 |         {
29 |             get { return track.Length; }
30 |         }
31 |     }
32 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Services/IMessageBoxService.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.Services
 2 | {
 3 |     using System.Windows;
 4 | 
 5 |     /// <summary>
 6 |     ///   Service Contract to be implemented by the types which would like to provide MessageBox.Show services
 7 |     /// </summary>
 8 |     public interface IMessageBoxService
 9 |     {
10 |         /// <summary>
11 |         ///   Show the MessageBox to the client
12 |         /// </summary>
13 |         /// <param name = "message">Message to be shown</param>
14 |         /// <param name = "title">Title of the MessageBox</param>
15 |         /// <param name = "buttons">Buttons</param>
16 |         /// <param name = "image">Image to be shown</param>
17 |         /// <returns>MessageBox results</returns>
18 |         MessageBoxResult Show(string message, string title, MessageBoxButton buttons, MessageBoxImage image);
19 |     }
20 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Themes/ItemContStyle.xaml:
--------------------------------------------------------------------------------
 1 | <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:WPFToolkit="http://schemas.microsoft.com/wpf/2008/toolkit" xmlns:Themes="clr-namespace:SoundFingerprinting.DuplicatesDetector.Themes" x:Class="SoundFingerprinting.DuplicatesDetector.Themes.i__ahtung_sound_fingerprinting_soundfingerprintinggit_src_soundfingerprinting_duplicatesdetector_themes_itemcontstyle_xaml">
 2 | 
 3 | 	<Style x:Key="ItemContStyle" TargetType="{x:Type WPFToolkit:DataGridRow}">
 4 | 		<Style.Resources>
 5 | 			<Themes:SetIdConverter x:Key="BackgroundConverter" />
 6 | 		</Style.Resources>
 7 | 		<Setter Property="WPFToolkit:DataGrid.Background">
 8 | 			<Setter.Value>
 9 | 				<Binding Path="SetId" Converter="{StaticResource BackgroundConverter}"></Binding>
10 | 			</Setter.Value>
11 | 		</Setter>
12 | 	</Style>
13 | 
14 | </ResourceDictionary>


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/App.xaml:
--------------------------------------------------------------------------------
 1 | <Application xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" x:Class="SoundFingerprinting.DuplicatesDetector.App">
 2 | 	<Application.Resources>
 3 | 		<!-- Resources scoped at the Application level should be defined here. -->
 4 | 		<ResourceDictionary>
 5 | 			<ResourceDictionary.MergedDictionaries>
 6 | 				<ResourceDictionary Source="Themes/Datagrid.xaml" />
 7 | 				<ResourceDictionary Source="Themes/Brushes.xaml" />
 8 | 				<ResourceDictionary Source="Themes/RoundedButton.xaml" />
 9 | 				<ResourceDictionary Source="Themes/TextBlock.xaml" />
10 | 				<ResourceDictionary Source="Themes/Converters.xaml" />
11 | 				<ResourceDictionary Source="Themes/ProgressBar.xaml" />
12 | 				<ResourceDictionary Source="Themes/ItemContStyle.xaml" />
13 | 			</ResourceDictionary.MergedDictionaries>
14 | 		</ResourceDictionary>
15 | 	</Application.Resources>
16 | </Application>


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Services/MessageBoxService.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.Services
 2 | {
 3 |     using System.Windows;
 4 | 
 5 |     /// <summary>
 6 |     ///   MessageBox service
 7 |     /// </summary>
 8 |     public class MessageBoxService : IMessageBoxService
 9 |     {
10 |         #region IMessageBoxService Members
11 | 
12 |         /// <summary>
13 |         ///   Show actual MessageBox
14 |         /// </summary>
15 |         /// <param name = "message">Message to be shown</param>
16 |         /// <param name = "title">Title of the MessageBox</param>
17 |         /// <param name = "buttons">Buttons in the MessageBox</param>
18 |         /// <param name = "image">Image on the MessageBox</param>
19 |         /// <returns>MessageBox results</returns>
20 |         public MessageBoxResult Show(string message, string title, MessageBoxButton buttons, MessageBoxImage image)
21 |         {
22 |             return MessageBox.Show(message, title, buttons, image);
23 |         }
24 | 
25 |         #endregion
26 |     }
27 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Themes/SetIdConverter.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.Themes
 2 | {
 3 |     using System;
 4 |     using System.Globalization;
 5 |     using System.Windows.Data;
 6 |     using System.Windows.Media;
 7 | 
 8 |     /// <summary>
 9 |     ///   Converter which alternates the color on duplicate sets
10 |     /// </summary>
11 |     [ValueConversion(typeof(object), typeof(int))]
12 |     public class SetIdConverter : IValueConverter
13 |     {
14 |         #region IValueConverter Members
15 | 
16 |         public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
17 |         {
18 |             if (value is int)
19 |             {
20 |                 int setId = (int)value;
21 |                 return setId % 2 == 0 ? new SolidColorBrush(Color.FromArgb(100, 0, 100, 150)) : new SolidColorBrush(Colors.Transparent);
22 |             }
23 | 
24 |             return new SolidColorBrush(Colors.Transparent);
25 |         }
26 | 
27 |         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
28 |         {
29 |             throw new NotImplementedException();
30 |         }
31 | 
32 |         #endregion
33 |     }
34 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/ViewModel/BooleanToVisibilityConverter.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.ViewModel
 2 | {
 3 |     using System;
 4 |     using System.Globalization;
 5 |     using System.Windows;
 6 |     using System.Windows.Data;
 7 | 
 8 |     [ValueConversion(typeof(bool), typeof(Visibility))]
 9 |     public class BooleanToVisibilityConverter : IValueConverter
10 |     {
11 |         #region IValueConverter Members
12 | 
13 |         public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
14 |         {
15 |             bool isprocessing = (bool)value;
16 |             return isprocessing ? Visibility.Visible : Visibility.Hidden;
17 |         }
18 | 
19 |         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
20 |         {
21 |             Visibility v = (Visibility)value;
22 |             switch (v)
23 |             {
24 |                 case Visibility.Hidden:
25 |                     return false;
26 |                 case Visibility.Collapsed:
27 |                     return false;
28 |                 case Visibility.Visible:
29 |                     return true;
30 |             }
31 | 
32 |             return DependencyProperty.UnsetValue;
33 |         }
34 | 
35 |         #endregion
36 |     }
37 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/MainWindow.xaml:
--------------------------------------------------------------------------------
 1 | <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" x:Class="SoundFingerprinting.DuplicatesDetector.MainWindow" x:Name="Window" Title="Duplicates Detector" Width="640" Height="450" MinWidth="600" MinHeight="450" mc:Ignorable="d" Icon="Images\icon.png">
 2 | 	<Window.Resources>
 3 | 		<ResourceDictionary Source="MainWindowResourceDictionary.xaml" />
 4 | 	</Window.Resources>
 5 | 
 6 | 	<Grid x:Name="_wndMain">
 7 | 		<Grid.Background>
 8 | 			<LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0" MappingMode="RelativeToBoundingBox">
 9 | 				<GradientStop Color="Black" />
10 | 				<GradientStop Color="#FF140C49" Offset="1" />
11 | 				<GradientStop Color="#FF0A0626" Offset="0.6" />
12 | 			</LinearGradientBrush>
13 | 		</Grid.Background>
14 | 		<Border CornerRadius="5">
15 | 			<Grid>
16 | 				<ItemsControl ItemsSource="{Binding Workspaces}" Margin="10,10,10,10">
17 | 					<ItemsControl.ItemsPanel>
18 | 						<ItemsPanelTemplate>
19 | 							<Grid />
20 | 						</ItemsPanelTemplate>
21 | 					</ItemsControl.ItemsPanel>
22 | 				</ItemsControl>
23 | 			</Grid>
24 | 		</Border>
25 | 	</Grid>
26 | 
27 | </Window>


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/View/GenericView.xaml:
--------------------------------------------------------------------------------
 1 | <Window x:Class="SoundFingerprinting.DuplicatesDetector.View.GenericView" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:ViewModel="clr-namespace:SoundFingerprinting.DuplicatesDetector.ViewModel" xmlns:View="clr-namespace:SoundFingerprinting.DuplicatesDetector.View" Title="Results" Width="640" Height="450" MinWidth="640" MinHeight="450" Icon="..\Images\icon.png">
 2 | 	<Window.Resources>
 3 | 		<DataTemplate DataType="{x:Type ViewModel:ReportViewModel}">
 4 | 			<View:ReportView />
 5 | 		</DataTemplate>
 6 | 	</Window.Resources>
 7 | 
 8 | 	<Grid>
 9 | 		<Grid.Background>
10 | 			<LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0" MappingMode="RelativeToBoundingBox">
11 | 				<GradientStop Color="Black" />
12 | 				<GradientStop Color="#FF140C49" Offset="1" />
13 | 				<GradientStop Color="#FF0A0626" Offset="0.6" />
14 | 			</LinearGradientBrush>
15 | 		</Grid.Background>
16 | 		<Border CornerRadius="5">
17 | 			<Grid>
18 | 				<ItemsControl ItemsSource="{Binding Workspaces}" Margin="10,10,10,10">
19 | 					<ItemsControl.ItemsPanel>
20 | 						<ItemsPanelTemplate>
21 | 							<Grid />
22 | 						</ItemsPanelTemplate>
23 | 					</ItemsControl.ItemsPanel>
24 | 				</ItemsControl>
25 | 			</Grid>
26 | 		</Border>
27 | 	</Grid>
28 | </Window>


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Themes/Brushes.xaml:
--------------------------------------------------------------------------------
 1 | <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" x:Class="SoundFingerprinting.DuplicatesDetector.Themes.i__ahtung_sound_fingerprinting_soundfingerprintinggit_src_soundfingerprinting_duplicatesdetector_themes_brushes_xaml">
 2 | 	<!-- Generic brushes -->
 3 | 	<SolidColorBrush x:Key="ControlBorderBrush" Color="#FF600855" />
 4 | 	<SolidColorBrush x:Key="ControlForegroundBrush" Color="#FF10257F" />
 5 | 	<SolidColorBrush x:Key="TextColorBrush" Color="#FF45C4F5" />
 6 | 	<SolidColorBrush x:Key="ControlBackgroundBrush" Color="Black" />
 7 | 
 8 | 	<!-- Generic brushes -->
 9 | 	<SolidColorBrush x:Key="DefaultControlBorderBrush" Color="#FF688CAF" />
10 | 	<SolidColorBrush x:Key="DefaultControlBackgroundBrush" Color="Black" />
11 | 	<SolidColorBrush x:Key="DefaultControlForegroundBrush" Color="#FF21D821" />
12 | 
13 | 	<!-- DataGrid related brushes -->
14 | 	<SolidColorBrush x:Key="GridLineColorBrush" Color="Black" />
15 | 	<SolidColorBrush x:Key="AlternateGridLineColorBrush" Color="#FF031F2E" />
16 |         
17 | 	<!--Button related brushes-->
18 | 	<SolidColorBrush x:Key="DefaultButtonBackground" Color="#FF260055"></SolidColorBrush>
19 | 	<SolidColorBrush x:Key="DefaultButtonBorder" Color="#42060A"></SolidColorBrush>
20 | 
21 | </ResourceDictionary>


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Services/OpenFileDialogService.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.Services
 2 | {
 3 |     using System.Windows.Forms;
 4 | 
 5 |     /// <summary>
 6 |     ///   Open file dialog service
 7 |     /// </summary>
 8 |     public class OpenFileDialogService : IOpenFileDialogService
 9 |     {
10 |         #region IOpenFileDialogService Members
11 | 
12 |         public string[] SelectedPaths { get; private set; }
13 | 
14 |         /// <summary>
15 |         ///   Show open file dialog
16 |         /// </summary>
17 |         /// <param name = "title">Title of the dialog</param>
18 |         /// <param name = "filename">Default filename</param>
19 |         /// <param name = "filter">Filter of the file dialog</param>
20 |         /// <param name = "multiselect">Multi-select enabled</param>
21 |         /// <returns>Dialog result</returns>
22 |         public DialogResult Show(string title, string filename, string filter, bool multiselect)
23 |         {
24 |             using (OpenFileDialog ofd = new OpenFileDialog { Title = title, FileName = filename, Filter = filter, Multiselect = multiselect })
25 |             {
26 |                 DialogResult result = ofd.ShowDialog();
27 |                 SelectedPaths = ofd.FileNames;
28 |                 return result;
29 |             }
30 |         }
31 |         
32 |         #endregion
33 |     }
34 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 2012
 4 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SoundFingerprinting.DuplicatesDetector", "SoundFingerprinting.DuplicatesDetector\SoundFingerprinting.DuplicatesDetector.csproj", "{572367D4-0F0C-4DC9-BE1C-4D037530D785}"
 5 | EndProject
 6 | Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".nuget", ".nuget", "{117D487C-9775-4689-B639-5B80E73DA38A}"
 7 | 	ProjectSection(SolutionItems) = preProject
 8 | 		.nuget\NuGet.Config = .nuget\NuGet.Config
 9 | 		.nuget\NuGet.exe = .nuget\NuGet.exe
10 | 		.nuget\NuGet.targets = .nuget\NuGet.targets
11 | 	EndProjectSection
12 | EndProject
13 | Global
14 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
15 | 		Debug|Any CPU = Debug|Any CPU
16 | 		Release|Any CPU = Release|Any CPU
17 | 	EndGlobalSection
18 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
19 | 		{572367D4-0F0C-4DC9-BE1C-4D037530D785}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
20 | 		{572367D4-0F0C-4DC9-BE1C-4D037530D785}.Debug|Any CPU.Build.0 = Debug|Any CPU
21 | 		{572367D4-0F0C-4DC9-BE1C-4D037530D785}.Release|Any CPU.ActiveCfg = Release|Any CPU
22 | 		{572367D4-0F0C-4DC9-BE1C-4D037530D785}.Release|Any CPU.Build.0 = Release|Any CPU
23 | 	EndGlobalSection
24 | 	GlobalSection(SolutionProperties) = preSolution
25 | 		HideSolutionNode = FALSE
26 | 	EndGlobalSection
27 | EndGlobal
28 | 


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Infrastructure/ServiceInjector.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.Infrastructure
 2 | {
 3 |     using SoundFingerprinting.Audio;
 4 |     using SoundFingerprinting.Audio.Bass;
 5 |     using SoundFingerprinting.Builder;
 6 |     using SoundFingerprinting.DuplicatesDetector.Services;
 7 |     using SoundFingerprinting.InMemory;
 8 | 
 9 |     public static class ServiceInjector
10 |     {
11 |         public static void InjectServices()
12 |         {
13 |             ServiceContainer.Kernel.Bind<IFolderBrowserDialogService>().To<FolderBrowserDialogService>();
14 |             ServiceContainer.Kernel.Bind<IMessageBoxService>().To<MessageBoxService>();
15 |             ServiceContainer.Kernel.Bind<IOpenFileDialogService>().To<OpenFileDialogService>();
16 |             ServiceContainer.Kernel.Bind<ISaveFileDialogService>().To<SaveFileDialogService>();
17 |             ServiceContainer.Kernel.Bind<IWindowService>().To<WindowService>();
18 |             ServiceContainer.Kernel.Bind<IGenericViewWindow>().To<GenericViewWindowService>();
19 | 
20 |             ServiceContainer.Kernel.Bind<IFingerprintCommandBuilder>().ToConstant(FingerprintCommandBuilder.Instance).InSingletonScope();
21 |             ServiceContainer.Kernel.Bind<IQueryFingerprintService>().ToConstant(QueryFingerprintService.Instance).InSingletonScope();
22 |             ServiceContainer.Kernel.Bind<DuplicatesDetectorFacade>().ToSelf().InSingletonScope();
23 |             ServiceContainer.Kernel.Bind<TrackHelper>().ToSelf().InSingletonScope();
24 |             ServiceContainer.Kernel.Bind<IAudioService>().To<BassAudioService>().InSingletonScope();
25 |             ServiceContainer.Kernel.Bind<IPlayAudioFileService>().To<BassPlayAudioFileService>().InSingletonScope();
26 |             ServiceContainer.Kernel.Bind<IAdvancedModelService>().To<InMemoryModelService>().InSingletonScope();
27 |         }
28 |     }
29 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Infrastructure/TrackHelper.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.Infrastructure
 2 | {
 3 |     using System.Collections.Generic;
 4 |     using System.IO;
 5 | 
 6 |     using SoundFingerprinting.Audio;
 7 |     using SoundFingerprinting.DAO.Data;
 8 |     using SoundFingerprinting.Data;
 9 | 
10 |     public class TrackHelper
11 |     {
12 |         private readonly IAudioService audioService;
13 | 
14 |         public TrackHelper(IAudioService audioService)
15 |         {
16 |             this.audioService = audioService;
17 |         }
18 | 
19 |         public AudioSamples GetTrackSamples(TrackInfo track, int sampleRate, int secondsToRead, int startAtSecond)
20 |         {
21 |             string filePath = track.MetaFields["FilePath"];
22 |             if (track == null || filePath == null)
23 |             {
24 |                 return null;
25 |             }
26 | 
27 |             return audioService.ReadMonoSamplesFromFile(filePath, sampleRate, secondsToRead, startAtSecond);
28 |         }
29 | 
30 |         public TrackInfo GetTrack(int mintracklen, int maxtracklen, string filename)
31 |         {
32 |             string artist, title, isrc;
33 |             /*The song does not contain any tags*/
34 |             artist = "Unknown Artist";
35 |             title = "Unknown Title";
36 |             isrc = Path.GetFileNameWithoutExtension(filename);
37 |             var meta = new Dictionary<string, string>();
38 |             meta["FilePath"] = Path.GetFullPath(filename);
39 | 
40 |             double duration = audioService.GetLengthInSeconds(Path.GetFullPath(filename));
41 |             /*check the duration of a music file*/
42 |             if (duration < mintracklen || duration > maxtracklen)
43 |             {
44 |                 return null;
45 |             }
46 | 
47 |             return new TrackInfo(isrc, title, artist, meta, MediaType.Audio);
48 |         }
49 |     }
50 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Model/Item.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.Model
 2 | {
 3 |     using System;
 4 |     using System.ComponentModel;
 5 | 
 6 |     /// <summary>
 7 |     ///   Class for folder representation in the UI element
 8 |     /// </summary>
 9 |     [Serializable]
10 |     public class Item : INotifyPropertyChanged
11 |     {
12 |         /// <summary>
13 |         ///   Number of music files within the folder
14 |         /// </summary>
15 |         private int count;
16 | 
17 |         /// <summary>
18 |         ///   Path to folder
19 |         /// </summary>
20 |         private string path;
21 | 
22 |         #region INotifyPropertyChanged Members
23 | 
24 |         public event PropertyChangedEventHandler PropertyChanged;
25 | 
26 |         #endregion
27 | 
28 |         public bool IsFolder { get; set; }
29 | 
30 |         public string Path
31 |         {
32 |             get
33 |             {
34 |                 return path;
35 |             }
36 | 
37 |             set
38 |             {
39 |                 if (path != value)
40 |                 {
41 |                     path = value;
42 |                     OnPropertyChanged("Path");
43 |                 }
44 |             }
45 |         }
46 | 
47 |         public int Count
48 |         {
49 |             get
50 |             {
51 |                 return count;
52 |             }
53 | 
54 |             set
55 |             {
56 |                 if (count != value)
57 |                 {
58 |                     count = value;
59 |                     OnPropertyChanged("Count");
60 |                 }
61 |             }
62 |         }
63 |         
64 |         private void OnPropertyChanged(string property)
65 |         {
66 |             PropertyChangedEventHandler temp = PropertyChanged;
67 |             if (temp != null)
68 |             {
69 |                 PropertyChanged(this, new PropertyChangedEventArgs(property));
70 |             }
71 |         }
72 |     }
73 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/RelayCommand.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector
 2 | {
 3 |     using System;
 4 |     using System.Windows.Input;
 5 | 
 6 |     public class RelayCommand : ICommand
 7 |     {
 8 |         /// <summary>
 9 |         ///   Method which verifies whether the command can execute
10 |         /// </summary>
11 |         private readonly Predicate<object> canExecute;
12 | 
13 |         /// <summary>
14 |         ///   Method to execute
15 |         /// </summary>
16 |         private readonly Action<object> execute;
17 | 
18 |         public RelayCommand(Action<object> execute)
19 |             : this(execute, null)
20 |         {
21 |         }
22 | 
23 |         public RelayCommand(Action<object> execute, Predicate<object> canExecute)
24 |         {
25 |             this.execute = execute;
26 |             this.canExecute = canExecute;
27 |         }
28 | 
29 |         /// <summary>
30 |         ///   Fires when the CanExecute status of this command changes.
31 |         /// </summary>
32 |         public event EventHandler CanExecuteChanged
33 |         {
34 |             add
35 |             {
36 |                 CommandManager.RequerySuggested += value;
37 |             }
38 | 
39 |             remove
40 |             {
41 |                 CommandManager.RequerySuggested -= value;
42 |             }
43 |         }
44 | 
45 |         /// <summary>
46 |         ///   Check if the method can be executed
47 |         /// </summary>
48 |         /// <param name = "parameter">Parameter</param>
49 |         /// <returns>True/False</returns>
50 |         public bool CanExecute(object parameter)
51 |         {
52 |             return canExecute == null || canExecute.Invoke(parameter);
53 |         }
54 | 
55 |         /// <summary>
56 |         ///   Execute the method
57 |         /// </summary>
58 |         /// <param name = "parameter">Parameter for execution</param>
59 |         public void Execute(object parameter)
60 |         {
61 |             execute(parameter);
62 |         }
63 |     }
64 | }


--------------------------------------------------------------------------------
/src/Settings.StyleCop:
--------------------------------------------------------------------------------
 1 | <StyleCopSettings Version="105">
 2 |   <Analyzers>
 3 |     <Analyzer AnalyzerId="StyleCop.CSharp.DocumentationRules">
 4 |       <Rules>
 5 |         <Rule Name="ElementsMustBeDocumented">
 6 |           <RuleSettings>
 7 |             <BooleanProperty Name="Enabled">False</BooleanProperty>
 8 |           </RuleSettings>
 9 |         </Rule>
10 |         <Rule Name="FileMustHaveHeader">
11 |           <RuleSettings>
12 |             <BooleanProperty Name="Enabled">False</BooleanProperty>
13 |           </RuleSettings>
14 |         </Rule>
15 |         <Rule Name="EnumerationItemsMustBeDocumented">
16 |           <RuleSettings>
17 |             <BooleanProperty Name="Enabled">False</BooleanProperty>
18 |           </RuleSettings>
19 |         </Rule>
20 |         <Rule Name="PartialElementsMustBeDocumented">
21 |           <RuleSettings>
22 |             <BooleanProperty Name="Enabled">False</BooleanProperty>
23 |           </RuleSettings>
24 |         </Rule>
25 |         <Rule Name="ElementDocumentationMustBeSpelledCorrectly">
26 |           <RuleSettings>
27 |             <BooleanProperty Name="Enabled">False</BooleanProperty>
28 |           </RuleSettings>
29 |         </Rule>
30 |         <Rule Name="DocumentationTextMustContainWhitespace">
31 |           <RuleSettings>
32 |             <BooleanProperty Name="Enabled">False</BooleanProperty>
33 |           </RuleSettings>
34 |         </Rule>
35 |       </Rules>
36 |       <AnalyzerSettings />
37 |     </Analyzer>
38 |     <Analyzer AnalyzerId="StyleCop.CSharp.ReadabilityRules">
39 |       <Rules>
40 |         <Rule Name="PrefixCallsCorrectly">
41 |           <RuleSettings>
42 |             <BooleanProperty Name="Enabled">False</BooleanProperty>
43 |           </RuleSettings>
44 |         </Rule>
45 |         <Rule Name="PrefixLocalCallsWithThis">
46 |           <RuleSettings>
47 |             <BooleanProperty Name="Enabled">False</BooleanProperty>
48 |           </RuleSettings>
49 |         </Rule>
50 |       </Rules>
51 |       <AnalyzerSettings />
52 |     </Analyzer>
53 |   </Analyzers>
54 | </StyleCopSettings>


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Infrastructure/CSVWriter.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.Infrastructure
 2 | {
 3 |     using System.Diagnostics;
 4 |     using System.IO;
 5 |     using System.Security.Permissions;
 6 |     using System.Text;
 7 | 
 8 |     /// <summary>
 9 |     ///   Class for writing any object values in comma separated file
10 |     /// </summary>
11 |     [DebuggerDisplay("Path={pathToFile}")]
12 |     public class CSVWriter
13 |     {
14 |         /// <summary>
15 |         ///   Separator used while writing to CVS
16 |         /// </summary>
17 |         private const char Separator = ',';
18 | 
19 |         /// <summary>
20 |         ///   Carriage return line feed
21 |         /// </summary>
22 |         private const string Crlf = "\r\n";
23 | 
24 |         /// <summary>
25 |         ///   Path to file
26 |         /// </summary>
27 |         private readonly string pathToFile;
28 | 
29 |         /// <summary>
30 |         ///   Writer
31 |         /// </summary>
32 |         private StreamWriter writer;
33 | 
34 |         public CSVWriter(string pathToFile)
35 |         {
36 |             this.pathToFile = pathToFile;
37 |         }
38 | 
39 |         /// <summary>
40 |         ///   Write the data into CSV
41 |         /// </summary>
42 |         /// <param name = "data">Data to be written</param>
43 |         [FileIOPermission(SecurityAction.Demand)]
44 |         public void Write(object[][] data)
45 |         {
46 |             if (data == null)
47 |             {
48 |                 return;
49 |             }
50 | 
51 |             using (writer = new StreamWriter(pathToFile))
52 |             {
53 |                 int cols = data[0].Length;
54 |                 StringBuilder builder = new StringBuilder();
55 |                 for (int i = 0, n = data.Length; i < n; i++)
56 |                 {
57 |                     for (int j = 0; j < cols; j++)
58 |                     {
59 |                         builder.Append(data[i][j]);
60 |                         if (j != cols - 1)
61 |                         {
62 |                             builder.Append(Separator);
63 |                         }
64 |                     }
65 | 
66 |                     builder.Append(Crlf);
67 |                 }
68 | 
69 |                 writer.Write(builder.ToString());
70 |                 writer.Close();
71 |             }
72 |         }
73 |     }
74 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Themes/Datagrid.xaml:
--------------------------------------------------------------------------------
 1 | <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:WpfToolkit="http://schemas.microsoft.com/wpf/2008/toolkit" xmlns:Primitives="clr-namespace:Microsoft.Windows.Controls.Primitives;assembly=WPFToolkit" x:Class="SoundFingerprinting.DuplicatesDetector.Themes.i__ahtung_sound_fingerprinting_soundfingerprintinggit_src_soundfingerprinting_duplicatesdetector_themes_datagrid_xaml">
 2 | 
 3 | 	<ResourceDictionary.MergedDictionaries>
 4 | 		<ResourceDictionary Source="Brushes.xaml" />
 5 | 	</ResourceDictionary.MergedDictionaries>
 6 | 
 7 | 	<!-- DataGrid Style -->
 8 | 	<!-- Created Ciumac Sergiu 19.01.2009 -->
 9 | 	<Style TargetType="WpfToolkit:DataGridCell">
10 | 		<Style.Triggers>
11 | 			<Trigger Property="IsSelected" Value="True">
12 | 				<Setter Property="Background" Value="#1C1026" />
13 | 				<Setter Property="Foreground" Value="Yellow" />
14 | 				<Setter Property="BorderBrush" Value="Black"></Setter>
15 | 			</Trigger>
16 | 		</Style.Triggers>
17 | 	</Style>
18 | 	<Style x:Key="DataGrid" TargetType="{x:Type WpfToolkit:DataGrid}">
19 | 		<Setter Property="Background" Value="{StaticResource DefaultControlBackgroundBrush}" />
20 | 		<Setter Property="Foreground" Value="{StaticResource DefaultControlForegroundBrush}" />
21 | 		<Setter Property="BorderBrush" Value="{StaticResource DefaultControlBorderBrush}" />
22 | 		<Setter Property="HorizontalGridLinesBrush" Value="{StaticResource GridLineColorBrush}" />
23 | 		<Setter Property="VerticalGridLinesBrush" Value="{StaticResource GridLineColorBrush}" />
24 | 		<Setter Property="AlternatingRowBackground" Value="{StaticResource AlternateGridLineColorBrush}" />
25 | 		<Setter Property="RowBackground" Value="{StaticResource DefaultControlBackgroundBrush}"></Setter>
26 | 		<Setter Property="BorderThickness" Value="1" />
27 | 		<!-- This is needed to force DG to have a non-default value.  Otherwise the DGR.DetailsVisibility cannot have a value of VisibleWhenSelected by default. -->
28 | 		<Setter Property="RowDetailsVisibilityMode" Value="VisibleWhenSelected" />
29 | 		<Setter Property="ScrollViewer.CanContentScroll" Value="False" />
30 | 		<Setter Property="RowHeaderWidth" Value="0"></Setter>
31 | 		<Setter Property="FontFamily" Value="Courier New"></Setter>
32 | 		<Style.Resources>
33 | 			<Style TargetType="ScrollBar">
34 | 				<Setter Property="Background" Value="{StaticResource DefaultControlBackgroundBrush}"></Setter>
35 | 			</Style>
36 | 		</Style.Resources>
37 | 	</Style>
38 | 
39 | </ResourceDictionary>


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Services/GenericViewWindowService.cs:
--------------------------------------------------------------------------------
 1 | namespace SoundFingerprinting.DuplicatesDetector.Services
 2 | {
 3 |     using System;
 4 |     using System.ComponentModel;
 5 | 
 6 |     using SoundFingerprinting.DuplicatesDetector.View;
 7 | 
 8 |     /// <summary>
 9 |     ///   Generic view window service
10 |     /// </summary>
11 |     public class GenericViewWindowService : IGenericViewWindow
12 |     {
13 |         /// <summary>
14 |         ///   Lock object
15 |         /// </summary>
16 |         private static readonly object LockObject = new object();
17 | 
18 |         /// <summary>
19 |         ///   Actual view (uninitialized)
20 |         /// </summary>
21 |         private GenericView view;
22 | 
23 |         #region IGenericViewWindow Members
24 | 
25 |         public event EventHandler Closed;
26 | 
27 |         public event CancelEventHandler Closing;
28 | 
29 |         public bool? DialogResult
30 |         {
31 |             get { return GetView().DialogResult; }
32 |             set { GetView().DialogResult = value; }
33 |         }
34 | 
35 |         public object DataContext
36 |         {
37 |             get { return GetView().DataContext; }
38 |             set { GetView().DataContext = value; }
39 |         }
40 |         
41 |         public void Show()
42 |         {
43 |             GetView().Show();
44 |         }
45 | 
46 |         public void Close()
47 |         {
48 |             GetView().Close();
49 |             view = null;
50 |         }
51 | 
52 |         #endregion
53 | 
54 |         /// <summary>
55 |         ///   Lazy initialization of the view
56 |         /// </summary>
57 |         /// <returns>Actual view</returns>
58 |         private GenericView GetView()
59 |         {
60 |             lock (LockObject)
61 |             {
62 |                 if (view != null)
63 |                 {
64 |                     return view;
65 |                 }
66 | 
67 |                 view = new GenericView();
68 |                 view.Closed += (sender, e) =>
69 |                     {
70 |                         if (Closed != null)
71 |                         {
72 |                             Closed(sender, e);
73 |                         }
74 | 
75 |                         view = null;
76 |                     };
77 |                 view.Closing += (sender, e) =>
78 |                     {
79 |                         if (Closing != null)
80 |                         {
81 |                             Closing(sender, e);
82 |                         }
83 |                     };
84 |                 return view;
85 |             }
86 |         }
87 |     }
88 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/View/PathListView.xaml:
--------------------------------------------------------------------------------
 1 | <UserControl x:Class="SoundFingerprinting.DuplicatesDetector.View.PathListView" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" mc:Ignorable="d" xmlns:WpfToolkit="http://schemas.microsoft.com/wpf/2008/toolkit" d:DesignHeight="600" d:DesignWidth="900">
 2 | 	<Grid>
 3 | 		<Grid.RowDefinitions>
 4 | 			<RowDefinition Height="6*" />
 5 | 			<RowDefinition Height="Auto" />
 6 | 		</Grid.RowDefinitions>
 7 | 
 8 | 		<WpfToolkit:DataGrid Grid.Row="0" Style="{StaticResource DataGrid}" ItemsSource="{Binding Paths, UpdateSourceTrigger=PropertyChanged}" AutoGenerateColumns="False" MinHeight="300" MinWidth="500" VerticalAlignment="Stretch">
 9 | 			<WpfToolkit:DataGrid.Columns>
10 | 				<WpfToolkit:DataGridTextColumn Header="Path" Binding="{Binding Path, UpdateSourceTrigger=PropertyChanged}" Width="4*" />
11 | 				<WpfToolkit:DataGridTextColumn Header="Count" Binding="{Binding Count, UpdateSourceTrigger=PropertyChanged}" Width="1*" />
12 | 			</WpfToolkit:DataGrid.Columns>
13 | 			<WpfToolkit:DataGrid.ColumnHeaderStyle>
14 | 				<Style TargetType="{x:Type WpfToolkit:DataGridColumnHeader}">
15 | 					<Setter Property="Background" Value="{StaticResource AlternateGridLineColorBrush}"></Setter>
16 | 				</Style>
17 | 			</WpfToolkit:DataGrid.ColumnHeaderStyle>
18 | 		</WpfToolkit:DataGrid>
19 | 		<Grid Grid.Row="1" VerticalAlignment="Stretch">
20 | 			<Button Style="{DynamicResource RoundedButton}" Command="{Binding AddMoreCommand}" Content="Add folders" Width="90" Height="25" VerticalAlignment="Bottom" HorizontalAlignment="Right" Margin="0,0,81,35" />
21 | 			<Button Style="{DynamicResource RoundedButton}" Command="{Binding StartCommand}" Content="Start" Height="25" HorizontalAlignment="Right" VerticalAlignment="Bottom" Width="75" Margin="0,0,0,35" />
22 | 			<Button Style="{DynamicResource RoundedButton}" Command="{Binding StopCommand}" Content="Stop" Height="25" HorizontalAlignment="Right" VerticalAlignment="Bottom" Width="75" Margin="0,0,0,6" />
23 | 			<Button Style="{DynamicResource RoundedButton}" Command="{Binding AddFileCommand}" Content="Add file" Height="25" HorizontalAlignment="Right" VerticalAlignment="Bottom" Width="90" Margin="0,0,81,6" />
24 | 			<TextBlock Style="{StaticResource TextBlockStyle}" Text="{Binding ProcessingStep}" Height="23" HorizontalAlignment="Left" VerticalAlignment="Bottom" Width="Auto" Margin="6,5,5,40" />
25 | 			<ProgressBar Style="{StaticResource ProgressBarStyle}" Height="25" Minimum="0" Maximum="100" HorizontalAlignment="Left" VerticalAlignment="Bottom" Width="150" Visibility="{Binding IsProcessing, Converter={StaticResource BooleanToVisibilityConverter}}" Value="{Binding CurrentProgress, Mode=OneWay}" Margin="6,0,0,6" />
26 | 		</Grid>
27 | 	</Grid>
28 | </UserControl>


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/View/ReportView.xaml:
--------------------------------------------------------------------------------
 1 | <UserControl x:Class="SoundFingerprinting.DuplicatesDetector.View.ReportView" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:WpfToolkit="http://schemas.microsoft.com/wpf/2008/toolkit" xmlns:Themes="clr-namespace:SoundFingerprinting.DuplicatesDetector.Themes" mc:Ignorable="d" d:DesignHeight="600" d:DesignWidth="900">
 2 | 	<UserControl.Resources>
 3 | 		<Themes:SetIdConverter x:Key="SetIdConverter"></Themes:SetIdConverter>
 4 | 	</UserControl.Resources>
 5 | 	<Grid>
 6 | 		<Grid.RowDefinitions>
 7 | 			<RowDefinition Height="6*" />
 8 | 			<RowDefinition Height="Auto" />
 9 | 		</Grid.RowDefinitions>
10 | 		<WpfToolkit:DataGrid Grid.Row="0" x:Name="_dgvResults" Style="{StaticResource DataGrid}" ItemContainerStyle="{StaticResource ItemContStyle}" SelectedItem="{Binding SelectedItem, UpdateSourceTrigger=PropertyChanged}" ItemsSource="{Binding Results, UpdateSourceTrigger=PropertyChanged}" AutoGenerateColumns="False" IsReadOnly="True" MinHeight="300" MinWidth="600" VerticalAlignment="Stretch">
11 | 			<WpfToolkit:DataGrid.Columns>
12 | 				<WpfToolkit:DataGridTextColumn Header="Set#" Binding="{Binding SetId, UpdateSourceTrigger=PropertyChanged}" Width="1.5*" />
13 | 				<WpfToolkit:DataGridTextColumn Header="Filename" Binding="{Binding FileName, UpdateSourceTrigger=PropertyChanged}" Width="8*" />
14 | 			</WpfToolkit:DataGrid.Columns>
15 | 			<WpfToolkit:DataGrid.ColumnHeaderStyle>
16 | 				<Style TargetType="{x:Type WpfToolkit:DataGridColumnHeader}">
17 | 					<Setter Property="Background" Value="{StaticResource AlternateGridLineColorBrush}"></Setter>
18 | 				</Style>
19 | 			</WpfToolkit:DataGrid.ColumnHeaderStyle>
20 | 		</WpfToolkit:DataGrid>
21 | 		<Grid Grid.Row="1">
22 | 			<TextBlock Style="{StaticResource TextBlockStyle}" Text="{Binding Status}" MinHeight="25" Height="Auto" HorizontalAlignment="Left" VerticalAlignment="Bottom" MinWidth="40" Width="Auto" Margin="6,0,0,31" />
23 | 			<Button Style="{DynamicResource RoundedButton}" Command="{Binding OpenFolderCommand}" CommandParameter="{Binding SelectedItem}" Content="Open Folder" Width="90" Height="25" HorizontalAlignment="Right" Margin="0,0,81,31" VerticalAlignment="Bottom" />
24 | 			<Button Style="{DynamicResource RoundedButton}" Command="{Binding PlayCommand}" Content="{Binding PlayingStatus}" Height="25" HorizontalAlignment="Right" VerticalAlignment="Bottom" Width="75" Margin="0,0,0,31" />
25 | 			<Button Style="{DynamicResource RoundedButton}" Command="{Binding SaveCommand}" Content="Save" Height="25" HorizontalAlignment="Right" VerticalAlignment="Top" Width="75" Margin="0,44,0,0" />
26 |             <Button Style="{DynamicResource RoundedButton}" Command="{Binding MoveItemsCommand}" Content="Move Items" Width="90" Height="25" HorizontalAlignment="Right" Margin="0,0,81,0" VerticalAlignment="Bottom" />
27 | 		</Grid>
28 | 
29 | 	</Grid>
30 | </UserControl>


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/ViewModel/ViewModelBase.cs:
--------------------------------------------------------------------------------
  1 | namespace SoundFingerprinting.DuplicatesDetector.ViewModel
  2 | {
  3 |     using System;
  4 |     using System.ComponentModel;
  5 |     using System.Diagnostics;
  6 | 
  7 |     using Ninject;
  8 | 
  9 |     using SoundFingerprinting.DuplicatesDetector.Infrastructure;
 10 |     using SoundFingerprinting.DuplicatesDetector.Services;
 11 | 
 12 |     /// <summary>
 13 |     ///   Base class for ViewModels
 14 |     /// </summary>
 15 |     public abstract class ViewModelBase : INotifyPropertyChanged, IDisposable
 16 |     {
 17 |         private bool alreadyDisposed;
 18 | 
 19 |         ~ViewModelBase()
 20 |         {
 21 |             Dispose(false);
 22 |         }
 23 | 
 24 |         #region INotifyPropertyChanged Members
 25 | 
 26 |         /// <summary>
 27 |         ///   Property changed event
 28 |         /// </summary>
 29 |         /// <remarks>
 30 |         ///   Whenever a property on a ViewModel object has a new value, 
 31 |         ///   it can raise the PropertyChanged event to notify the WPF binding 
 32 |         ///   system of the new value. Upon receiving that notification, the 
 33 |         ///   binding system queries the property, and the bound property on 
 34 |         ///   some UI element receives the new value.
 35 |         /// </remarks>
 36 |         public event PropertyChangedEventHandler PropertyChanged;
 37 | 
 38 |         #endregion
 39 | 
 40 |         /// <summary>
 41 |         ///   Dispose resources
 42 |         /// </summary>
 43 |         public void Dispose()
 44 |         {
 45 |             Dispose(true);
 46 |             GC.SuppressFinalize(this);
 47 |         }
 48 | 
 49 |         [Conditional("DEBUG")]
 50 |         [DebuggerStepThrough]
 51 |         public void VerifyPropertyName(string propertyName)
 52 |         {
 53 |             // Verify that the property name matches a real,  
 54 |             // public, instance property on this object.
 55 |             if (TypeDescriptor.GetProperties(this)[propertyName] == null)
 56 |             {
 57 |                 string msg = "Invalid property name: " + propertyName;
 58 |                 throw new Exception(msg);
 59 |             }
 60 |         }
 61 | 
 62 |         /// <summary>
 63 |         ///   Get service contract implementation of a specific type
 64 |         /// </summary>
 65 |         /// <typeparam name = "TServiceContract">Type of the service contract</typeparam>
 66 |         /// <returns>Implementation of service contract</returns>
 67 |         public TServiceContract GetService<TServiceContract>()
 68 |         {
 69 |             return ServiceContainer.Kernel.Get<TServiceContract>();
 70 |         }
 71 | 
 72 |         /// <summary>
 73 |         ///   On property changed, tell UI to refresh binding elements
 74 |         /// </summary>
 75 |         /// <param name = "propertyName">Changed property</param>
 76 |         protected virtual void OnPropertyChanged(string propertyName)
 77 |         {
 78 |             VerifyPropertyName(propertyName);
 79 |             PropertyChangedEventHandler temp = PropertyChanged;
 80 |             if (temp != null)
 81 |             {
 82 |                 PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
 83 |             }
 84 |         }
 85 | 
 86 |         /// <summary>
 87 |         ///   Dispose
 88 |         /// </summary>
 89 |         /// <param name = "isDisposing">Is disposing by client call</param>
 90 |         protected virtual void Dispose(bool isDisposing)
 91 |         {
 92 |             if (!alreadyDisposed)
 93 |             {
 94 |                 if (!isDisposing)
 95 |                 {
 96 |                     /*Dispose managed resources*/
 97 |                 }
 98 | 
 99 |                 /*Dispose unmanaged resources*/
100 |             }
101 | 
102 |             alreadyDisposed = true;
103 |         }
104 |     }
105 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Themes/RoundedButton.xaml:
--------------------------------------------------------------------------------
  1 | <!-- RoundedButton.xaml -->
  2 | <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" x:Class="SoundFingerprinting.DuplicatesDetector.Themes.i__ahtung_sound_fingerprinting_soundfingerprintinggit_src_soundfingerprinting_duplicatesdetector_themes_roundedbutton_xaml">
  3 | 	<ResourceDictionary.MergedDictionaries>
  4 | 		<ResourceDictionary Source="Brushes.xaml" />
  5 | 	</ResourceDictionary.MergedDictionaries>
  6 | 	<Style x:Key="ButtonFocusVisual">
  7 | 		<Setter Property="Control.Template">
  8 | 			<Setter.Value>
  9 | 				<ControlTemplate>
 10 | 					<Border>
 11 | 						<Rectangle SnapsToDevicePixels="true" Margin="4" Stroke="Black" StrokeDashArray="1 2" StrokeThickness="1" />
 12 | 					</Border>
 13 | 				</ControlTemplate>
 14 | 			</Setter.Value>
 15 | 		</Setter>
 16 | 	</Style>
 17 | 
 18 | 	<Style x:Key="RoundedButton" TargetType="{x:Type Button}">
 19 | 		<Setter Property="FocusVisualStyle" Value="{StaticResource ButtonFocusVisual}" />
 20 | 		<Setter Property="Background" Value="{StaticResource DefaultButtonBackground}" />
 21 | 		<Setter Property="Foreground" Value="White" />
 22 | 		<Setter Property="BorderBrush" Value="{StaticResource DefaultButtonBorder}" />
 23 | 		<Setter Property="FontFamily" Value="Courier New" />
 24 | 		<Setter Property="BorderThickness" Value="3" />
 25 | 		<Setter Property="HorizontalContentAlignment" Value="Center" />
 26 | 		<Setter Property="VerticalContentAlignment" Value="Center" />
 27 | 		<Setter Property="Padding" Value="0,0,1,1" />
 28 | 		<Setter Property="Template">
 29 | 			<Setter.Value>
 30 | 				<ControlTemplate TargetType="{x:Type Button}">
 31 | 					<ControlTemplate.Resources>
 32 | 						<Storyboard x:Key="ShowShine">
 33 | 							<DoubleAnimationUsingKeyFrames BeginTime="00:00:00" Storyboard.TargetName="Shine" Storyboard.TargetProperty="(UIElement.Opacity)">
 34 | 								<SplineDoubleKeyFrame KeyTime="00:00:00.5000000" Value="1" />
 35 | 							</DoubleAnimationUsingKeyFrames>
 36 | 						</Storyboard>
 37 | 						<Storyboard x:Key="HideShine">
 38 | 							<DoubleAnimationUsingKeyFrames BeginTime="00:00:00" Storyboard.TargetName="Shine" Storyboard.TargetProperty="(UIElement.Opacity)">
 39 | 								<SplineDoubleKeyFrame KeyTime="00:00:00.3000000" Value="0" />
 40 | 							</DoubleAnimationUsingKeyFrames>
 41 | 						</Storyboard>
 42 | 					</ControlTemplate.Resources>
 43 | 					<Border CornerRadius="3,3,3,3" BorderThickness="1,1,1,1" RenderTransformOrigin="0.5,0.5" x:Name="border" BorderBrush="{StaticResource DefaultControlBorderBrush}">
 44 | 						<Border.RenderTransform>
 45 | 							<TransformGroup>
 46 | 								<ScaleTransform ScaleX="1" ScaleY="1" />
 47 | 								<SkewTransform AngleX="0" AngleY="0" />
 48 | 								<RotateTransform Angle="0" />
 49 | 								<TranslateTransform X="0" Y="0" />
 50 | 							</TransformGroup>
 51 | 						</Border.RenderTransform>
 52 | 						<Border Background="{TemplateBinding Background}" CornerRadius="2,2,2,2" x:Name="border1">
 53 | 							<Grid>
 54 | 								<Grid.RowDefinitions>
 55 | 									<RowDefinition Height="0.5*" />
 56 | 									<RowDefinition Height="0.5*" />
 57 | 								</Grid.RowDefinitions>
 58 | 								<Border Grid.Row="0" CornerRadius="5,5,0,0">
 59 | 									<Border.Background>
 60 | 										<LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
 61 | 											<GradientStop Color="#00FFFFFF" Offset="0" />
 62 | 											<GradientStop Color="#7EFFFFFF" Offset="1" />
 63 | 										</LinearGradientBrush>
 64 | 									</Border.Background>
 65 | 								</Border>
 66 | 								<Border Grid.Row="1" Opacity="0" x:Name="Shine" Width="Auto" Height="Auto" CornerRadius="0,0,5,5" Margin="1,0,-1,0" Background="{TemplateBinding BorderBrush}" />
 67 | 								<ContentPresenter VerticalAlignment="Center" Grid.RowSpan="2" HorizontalAlignment="Center" x:Name="contentPresenter" />
 68 | 							</Grid>
 69 | 						</Border>
 70 | 					</Border>
 71 | 					<ControlTemplate.Triggers>
 72 | 						<Trigger Property="IsEnabled" Value="False">
 73 | 							<Setter Property="Opacity" TargetName="border1" Value="0.5" />
 74 | 							<Setter Property="Opacity" TargetName="border" Value="1" />
 75 | 							<Setter Property="Opacity" TargetName="contentPresenter" Value="0.5" />
 76 | 						</Trigger>
 77 | 						<Trigger Property="IsPressed" Value="True">
 78 | 							<Setter Property="RenderTransform" TargetName="border">
 79 | 								<Setter.Value>
 80 | 									<TransformGroup>
 81 | 										<ScaleTransform ScaleX="0.9" ScaleY="0.9" />
 82 | 										<SkewTransform AngleX="0" AngleY="0" />
 83 | 										<RotateTransform Angle="0" />
 84 | 										<TranslateTransform X="0" Y="0" />
 85 | 									</TransformGroup>
 86 | 								</Setter.Value>
 87 | 							</Setter>
 88 | 						</Trigger>
 89 | 						<Trigger Property="IsMouseOver" Value="True">
 90 | 							<Trigger.ExitActions>
 91 | 								<BeginStoryboard Storyboard="{StaticResource HideShine}" x:Name="HideShine_BeginStoryboard" />
 92 | 							</Trigger.ExitActions>
 93 | 							<Trigger.EnterActions>
 94 | 								<BeginStoryboard x:Name="ShowShine_BeginStoryboard" Storyboard="{StaticResource ShowShine}" />
 95 | 							</Trigger.EnterActions>
 96 | 						</Trigger>
 97 | 					</ControlTemplate.Triggers>
 98 | 				</ControlTemplate>
 99 | 			</Setter.Value>
100 | 		</Setter>
101 | 	</Style>
102 | </ResourceDictionary>


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/DuplicatesDetectorService.cs:
--------------------------------------------------------------------------------
  1 | namespace SoundFingerprinting.DuplicatesDetector
  2 | {
  3 |     using System;
  4 |     using System.Collections.Generic;
  5 |     using System.Linq;
  6 | 
  7 |     using SoundFingerprinting.Audio;
  8 |     using SoundFingerprinting.Builder;
  9 |     using SoundFingerprinting.Configuration;
 10 |     using SoundFingerprinting.DAO.Data;
 11 |     using SoundFingerprinting.Data;
 12 |     using SoundFingerprinting.Strides;
 13 | 
 14 |     internal class DuplicatesDetectorService
 15 |     {
 16 |         private const double FalsePositivesThreshold = 0.4;
 17 | 
 18 |         private readonly IStride createStride = new IncrementalRandomStride(512, 1024);
 19 | 
 20 |         private readonly IAdvancedModelService modelService;
 21 | 
 22 |         private readonly IAudioService audioService;
 23 | 
 24 |         private readonly IFingerprintCommandBuilder fingerprintCommandBuilder;
 25 | 
 26 |         private readonly IQueryFingerprintService queryFingerprintService;
 27 | 
 28 | 
 29 |         public DuplicatesDetectorService(IAdvancedModelService modelService, IAudioService audioService, IFingerprintCommandBuilder fingerprintCommandBuilder, IQueryFingerprintService queryFingerprintService)
 30 |         {
 31 |             this.modelService = modelService;
 32 |             this.audioService = audioService;
 33 |             this.fingerprintCommandBuilder = fingerprintCommandBuilder;
 34 |             this.queryFingerprintService = queryFingerprintService;
 35 |         }
 36 | 
 37 |         /// <summary>
 38 |         ///   Create fingerprints out of down sampled samples
 39 |         /// </summary>
 40 |         /// <param name = "samples">Down sampled to 5512 samples</param>
 41 |         /// <param name = "track">Track</param>
 42 |         public void CreateInsertFingerprints(AudioSamples samples, TrackInfo track)
 43 |         {
 44 |             if (track == null)
 45 |             {
 46 |                 return; /*track is not eligible*/
 47 |             }
 48 | 
 49 |             /*Create fingerprints that will be used as initial fingerprints to be queried*/
 50 |             var hashes = fingerprintCommandBuilder.BuildFingerprintCommand()
 51 |                                                        .From(samples)
 52 |                                                        .WithFingerprintConfig(config =>
 53 |                                                        {
 54 |                                                             config.Stride = createStride;
 55 |                                                             return config;
 56 |                                                        })
 57 |                                                        .UsingServices(audioService)
 58 |                                                        .Hash()
 59 |                                                        .Result;
 60 | 
 61 |             modelService.Insert(track, hashes);
 62 |         }
 63 | 
 64 |         /// <summary>
 65 |         ///   Find duplicates between existing tracks in the database
 66 |         /// </summary>
 67 |         /// <param name = "callback">Callback invoked at each processed track</param>
 68 |         /// <returns>Sets of duplicates</returns>
 69 |         public HashSet<TrackData>[] FindDuplicates(Action<TrackData, int, int> callback)
 70 |         {
 71 |             var tracks = modelService.ReadAllTracks().ToList();
 72 |             var duplicates = new List<HashSet<TrackData>>();
 73 |             int total = tracks.Count, current = 0;
 74 |             var queryConfiguration = new DefaultQueryConfiguration { MaxTracksToReturn = int.MaxValue, ThresholdVotes = 4 };
 75 |             foreach (var track in tracks)
 76 |             {
 77 |                 var trackDuplicates = new HashSet<TrackData>();
 78 | 
 79 |                 var hashedFingerprints = modelService.ReadHashedFingerprintsByTrack(track.TrackReference);
 80 |                 var max = hashedFingerprints.Max(_ => _.StartsAt);
 81 |                 var min = hashedFingerprints.Min(_ => _.StartsAt);
 82 |                 var hashes = new Hashes(hashedFingerprints, GetLength(min, max, queryConfiguration.FingerprintConfiguration.FingerprintLengthInSeconds));
 83 |                 var result = queryFingerprintService.Query(hashes, queryConfiguration, modelService);
 84 | 
 85 |                 if (result.ContainsMatches)
 86 |                 {
 87 |                     foreach (var resultEntry in result.ResultEntries)
 88 |                     {
 89 |                         if (resultEntry.Confidence < FalsePositivesThreshold || track.Equals(resultEntry.Track))
 90 |                         {
 91 |                             continue;
 92 |                         }
 93 | 
 94 |                         trackDuplicates.Add(resultEntry.Track);
 95 |                     }
 96 | 
 97 |                     if (trackDuplicates.Any())
 98 |                     {
 99 |                         HashSet<TrackData> duplicatePair = new HashSet<TrackData>(trackDuplicates) { track };
100 |                         duplicates.Add(duplicatePair);
101 |                     }
102 |                 }
103 | 
104 |                 callback?.Invoke(track, total, ++current);
105 |             }
106 | 
107 |             for (int i = 0; i < duplicates.Count - 1; i++)
108 |             {
109 |                 HashSet<TrackData> set = duplicates[i];
110 |                 for (int j = i + 1; j < duplicates.Count; j++)
111 |                 {
112 |                     IEnumerable<TrackData> result = set.Intersect(duplicates[j]);
113 |                     if (result.Any())
114 |                     {
115 |                         foreach (var track in duplicates[j])
116 |                         {
117 |                             // collapse all duplicates in one set
118 |                             set.Add(track);
119 |                         }
120 | 
121 |                         duplicates.RemoveAt(j); /*Remove the duplicate set*/
122 |                         j--;
123 |                     }
124 |                 }
125 |             }
126 | 
127 |             return duplicates.ToArray();
128 |         }
129 | 
130 |         public void ClearStorage()
131 |         {
132 |             var tracks = modelService.ReadAllTracks();
133 |             foreach (var track in tracks)
134 |             {
135 |                 modelService.DeleteTrack(track.Id);
136 |             }
137 |         }
138 | 
139 |         private static double GetLength(double min, double max, double fingerprintLengthInSeconds)
140 |         {
141 |             return max - min + fingerprintLengthInSeconds;
142 |         }
143 |     }
144 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/ViewModel/Helper.cs:
--------------------------------------------------------------------------------
  1 | namespace SoundFingerprinting.DuplicatesDetector.ViewModel
  2 | {
  3 |     using System;
  4 |     using System.Collections.Generic;
  5 |     using System.IO;
  6 |     using System.Linq;
  7 |     using System.Security;
  8 |     using System.Text;
  9 | 
 10 |     public static class Helper
 11 |     {
 12 |         /// <summary>
 13 |         ///   Count the number of music files in the a specific folder and it's subdirectories
 14 |         /// </summary>
 15 |         /// <param name = "path">Path of the root folder</param>
 16 |         /// <param name = "filters">Search filters</param>
 17 |         /// <returns>Number of music files</returns>
 18 |         public static int CountNumberOfMusicFiles(string path, IEnumerable<string> filters)
 19 |         {
 20 |             int files = 0;
 21 |             DirectoryInfo root = new DirectoryInfo(path);
 22 |             var listOfFilters = filters as IList<string> ?? filters.ToList();
 23 |             foreach (string filter in listOfFilters)
 24 |             {
 25 |                 try
 26 |                 {
 27 |                     foreach (FileInfo file in root.GetFiles(filter, SearchOption.TopDirectoryOnly))
 28 |                     {
 29 |                         try
 30 |                         {
 31 |                             string temp = file.FullName; /*Dummy call to see if path does not exceed the limit*/
 32 |                         }
 33 |                         catch (PathTooLongException)
 34 |                         {
 35 |                             continue;
 36 |                         }
 37 | 
 38 |                         files++;
 39 |                     }
 40 |                 }
 41 |                 catch (SecurityException)
 42 |                 {
 43 |                     /*you don't have the permission of viewing this files*/
 44 |                 }
 45 |                 catch (DirectoryNotFoundException)
 46 |                 {
 47 |                     /*directory not found*/
 48 |                 }
 49 |                 catch (ArgumentNullException)
 50 |                 {
 51 |                     /*bad parameters*/
 52 |                 }
 53 |             }
 54 | 
 55 |             DirectoryInfo[] directories;
 56 |             try
 57 |             {
 58 |                 directories = root.GetDirectories();
 59 |             }
 60 |             catch (DirectoryNotFoundException)
 61 |             {
 62 |                 /*directory wasn't found*/
 63 |                 return files;
 64 |             }
 65 | 
 66 |             foreach (DirectoryInfo directory in directories)
 67 |             {
 68 |                 try
 69 |                 {
 70 |                     files += CountNumberOfMusicFiles(directory.FullName, listOfFilters);
 71 |                 }
 72 |                 catch (PathTooLongException)
 73 |                 {
 74 |                     // swalow
 75 |                 }
 76 |             }
 77 | 
 78 |             return files;
 79 |         }
 80 | 
 81 |         /// <summary>
 82 |         ///   Get music files from root folder and it's subdirectories
 83 |         /// </summary>
 84 |         /// <param name = "path">Path of the root folder</param>
 85 |         /// <param name = "filters">Search filters</param>
 86 |         /// <returns>List with the music files</returns>
 87 |         public static List<string> GetMusicFiles(string path, IEnumerable<string> filters)
 88 |         {
 89 |             List<string> files = new List<string>();
 90 |             DirectoryInfo root = new DirectoryInfo(path);
 91 |             var listOfFilters = filters as IList<string> ?? filters.ToList();
 92 |             foreach (string filter in listOfFilters)
 93 |             {
 94 |                 try
 95 |                 {
 96 |                     foreach (FileInfo file in root.GetFiles(filter, SearchOption.TopDirectoryOnly))
 97 |                     {
 98 |                         try
 99 |                         {
100 |                             files.Add(file.FullName);
101 |                         }
102 |                         catch (PathTooLongException)
103 |                         {
104 |                             /*255 item range is too long*/
105 |                         }
106 |                     }
107 |                 }
108 |                 catch (SecurityException)
109 |                 {
110 |                     /*you don't have the permission of viewing this files*/
111 |                 }
112 |                 catch (DirectoryNotFoundException)
113 |                 {
114 |                     /*directory not found*/
115 |                 }
116 |                 catch (ArgumentNullException)
117 |                 {
118 |                     /*bad parameters*/
119 |                 }
120 |             }
121 | 
122 |             DirectoryInfo[] directories;
123 |             try
124 |             {
125 |                 directories = root.GetDirectories();
126 |             }
127 |             catch (DirectoryNotFoundException)
128 |             {
129 |                 /*directory wasn't found*/
130 |                 return files;
131 |             }
132 | 
133 |             foreach (DirectoryInfo directory in directories)
134 |             {
135 |                 try
136 |                 {
137 |                     files.AddRange(GetMusicFiles(directory.FullName, listOfFilters));
138 |                 }
139 |                 catch (PathTooLongException)
140 |                 {
141 |                     // continue
142 |                 }
143 |             }
144 | 
145 |             return files;
146 |         }
147 | 
148 |         /// <summary>
149 |         ///   Get multiple filter for open file dialog
150 |         /// </summary>
151 |         /// <param name = "caption">Caption</param>
152 |         /// <param name = "filters">List of filters</param>
153 |         /// <returns>Multiple filter</returns>
154 |         public static string GetMultipleFilter(string caption, IEnumerable<string> filters)
155 |         {
156 |             StringBuilder filter = new StringBuilder(caption);
157 |             filter.Append(" (");
158 |             var listOfFilters = filters as IList<string> ?? filters.ToList();
159 |             for (int i = 0; i < listOfFilters.Count(); i++)
160 |             {
161 |                 filter.Append(listOfFilters.ElementAt(i));
162 |                 if (i != listOfFilters.Count - 1 /*last*/)
163 |                 {
164 |                     filter.Append(";");
165 |                 }
166 |                 else
167 |                 {
168 |                     filter.Append(")|");
169 |                     for (int j = 0; j < listOfFilters.Count(); j++)
170 |                     {
171 |                         filter.Append(listOfFilters.ElementAt(j));
172 |                         if (j != listOfFilters.Count - 1 /*last*/)
173 |                         {
174 |                             filter.Append(";");
175 |                         }
176 |                     }
177 |                 }
178 |             }
179 | 
180 |             return filter.ToString();
181 |         }
182 |     }
183 | }


--------------------------------------------------------------------------------
/src/.nuget/NuGet.targets:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |     <PropertyGroup>
  4 |         <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">$(MSBuildProjectDirectory)\..\</SolutionDir>
  5 |         
  6 |         <!-- Enable the restore command to run before builds -->
  7 |         <RestorePackages Condition="  '$(RestorePackages)' == '' ">false</RestorePackages>
  8 | 
  9 |         <!-- Property that enables building a package from a project -->
 10 |         <BuildPackage Condition=" '$(BuildPackage)' == '' ">false</BuildPackage>
 11 | 
 12 |         <!-- Determines if package restore consent is required to restore packages -->
 13 |         <RequireRestoreConsent Condition=" '$(RequireRestoreConsent)' != 'false' ">true</RequireRestoreConsent>
 14 |         
 15 |         <!-- Download NuGet.exe if it does not already exist -->
 16 |         <DownloadNuGetExe Condition=" '$(DownloadNuGetExe)' == '' ">false</DownloadNuGetExe>
 17 |     </PropertyGroup>
 18 |     
 19 |     <ItemGroup Condition=" '$(PackageSources)' == '' ">
 20 |         <!-- Package sources used to restore packages. By default, registered sources under %APPDATA%\NuGet\NuGet.Config will be used -->
 21 |         <!-- The official NuGet package source (https://www.nuget.org/api/v2/) will be excluded if package sources are specified and it does not appear in the list -->
 22 |         <!--
 23 |             <PackageSource Include="https://www.nuget.org/api/v2/" />
 24 |             <PackageSource Include="https://my-nuget-source/nuget/" />
 25 |         -->
 26 |     </ItemGroup>
 27 | 
 28 |     <PropertyGroup Condition=" '$(OS)' == 'Windows_NT'">
 29 |         <!-- Windows specific commands -->
 30 |         <NuGetToolsPath>$([System.IO.Path]::Combine($(SolutionDir), ".nuget"))</NuGetToolsPath>
 31 |         <PackagesConfig>$([System.IO.Path]::Combine($(ProjectDir), "packages.config"))</PackagesConfig>
 32 |     </PropertyGroup>
 33 |     
 34 |     <PropertyGroup Condition=" '$(OS)' != 'Windows_NT'">
 35 |         <!-- We need to launch nuget.exe with the mono command if we're not on windows -->
 36 |         <NuGetToolsPath>$(SolutionDir).nuget</NuGetToolsPath>
 37 |         <PackagesConfig>packages.config</PackagesConfig>
 38 |     </PropertyGroup>
 39 |     
 40 |     <PropertyGroup>
 41 |         <!-- NuGet command -->
 42 |         <NuGetExePath Condition=" '$(NuGetExePath)' == '' ">$(NuGetToolsPath)\NuGet.exe</NuGetExePath>
 43 |         <PackageSources Condition=" $(PackageSources) == '' ">@(PackageSource)</PackageSources>
 44 |         
 45 |         <NuGetCommand Condition=" '$(OS)' == 'Windows_NT'">"$(NuGetExePath)"</NuGetCommand>
 46 |         <NuGetCommand Condition=" '$(OS)' != 'Windows_NT' ">mono --runtime=v4.0.30319 $(NuGetExePath)</NuGetCommand>
 47 | 
 48 |         <PackageOutputDir Condition="$(PackageOutputDir) == ''">$(TargetDir.Trim('\\'))</PackageOutputDir>
 49 |         
 50 |         <RequireConsentSwitch Condition=" $(RequireRestoreConsent) == 'true' ">-RequireConsent</RequireConsentSwitch>
 51 |         <NonInteractiveSwitch Condition=" '$(VisualStudioVersion)' != '' AND '$(OS)' == 'Windows_NT' ">-NonInteractive</NonInteractiveSwitch>
 52 |         
 53 |         <PaddedSolutionDir Condition=" '$(OS)' == 'Windows_NT'">"$(SolutionDir) "</PaddedSolutionDir>
 54 |         <PaddedSolutionDir Condition=" '$(OS)' != 'Windows_NT' ">"$(SolutionDir)"</PaddedSolutionDir>
 55 | 
 56 |         <!-- Commands -->
 57 |         <RestoreCommand>$(NuGetCommand) install "$(PackagesConfig)" -source "$(PackageSources)"  $(NonInteractiveSwitch) $(RequireConsentSwitch) -solutionDir $(PaddedSolutionDir)</RestoreCommand>
 58 |         <BuildCommand>$(NuGetCommand) pack "$(ProjectPath)" -Properties "Configuration=$(Configuration);Platform=$(Platform)" $(NonInteractiveSwitch) -OutputDirectory "$(PackageOutputDir)" -symbols</BuildCommand>
 59 | 
 60 |         <!-- We need to ensure packages are restored prior to assembly resolve -->
 61 |         <BuildDependsOn Condition="$(RestorePackages) == 'true'">
 62 |             RestorePackages;
 63 |             $(BuildDependsOn);
 64 |         </BuildDependsOn>
 65 | 
 66 |         <!-- Make the build depend on restore packages -->
 67 |         <BuildDependsOn Condition="$(BuildPackage) == 'true'">
 68 |             $(BuildDependsOn);
 69 |             BuildPackage;
 70 |         </BuildDependsOn>
 71 |     </PropertyGroup>
 72 | 
 73 |     <Target Name="CheckPrerequisites">
 74 |         <!-- Raise an error if we're unable to locate nuget.exe  -->
 75 |         <Error Condition="'$(DownloadNuGetExe)' != 'true' AND !Exists('$(NuGetExePath)')" Text="Unable to locate '$(NuGetExePath)'" />
 76 |         <!--
 77 |         Take advantage of MsBuild's build dependency tracking to make sure that we only ever download nuget.exe once.
 78 |         This effectively acts as a lock that makes sure that the download operation will only happen once and all
 79 |         parallel builds will have to wait for it to complete.
 80 |         -->
 81 |         <MsBuild Targets="_DownloadNuGet" Projects="$(MSBuildThisFileFullPath)" Properties="Configuration=NOT_IMPORTANT;DownloadNuGetExe=$(DownloadNuGetExe)" />
 82 |     </Target>
 83 | 
 84 |     <Target Name="_DownloadNuGet">
 85 |         <DownloadNuGet OutputFilename="$(NuGetExePath)" Condition=" '$(DownloadNuGetExe)' == 'true' AND !Exists('$(NuGetExePath)')" />
 86 |     </Target>
 87 | 
 88 |     <Target Name="RestorePackages" DependsOnTargets="CheckPrerequisites">
 89 |         <Exec Command="$(RestoreCommand)"
 90 |               Condition="'$(OS)' != 'Windows_NT' And Exists('$(PackagesConfig)')" />
 91 |               
 92 |         <Exec Command="$(RestoreCommand)"
 93 |               LogStandardErrorAsError="true"
 94 |               Condition="'$(OS)' == 'Windows_NT' And Exists('$(PackagesConfig)')" />
 95 |     </Target>
 96 | 
 97 |     <Target Name="BuildPackage" DependsOnTargets="CheckPrerequisites">
 98 |         <Exec Command="$(BuildCommand)" 
 99 |               Condition=" '$(OS)' != 'Windows_NT' " />
100 |               
101 |         <Exec Command="$(BuildCommand)"
102 |               LogStandardErrorAsError="true"
103 |               Condition=" '$(OS)' == 'Windows_NT' " />
104 |     </Target>
105 |     
106 |     <UsingTask TaskName="DownloadNuGet" TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll">
107 |         <ParameterGroup>
108 |             <OutputFilename ParameterType="System.String" Required="true" />
109 |         </ParameterGroup>
110 |         <Task>
111 |             <Reference Include="System.Core" />
112 |             <Using Namespace="System" />
113 |             <Using Namespace="System.IO" />
114 |             <Using Namespace="System.Net" />
115 |             <Using Namespace="Microsoft.Build.Framework" />
116 |             <Using Namespace="Microsoft.Build.Utilities" />
117 |             <Code Type="Fragment" Language="cs">
118 |                 <![CDATA[
119 |                 try {
120 |                     OutputFilename = Path.GetFullPath(OutputFilename);
121 | 
122 |                     Log.LogMessage("Downloading latest version of NuGet.exe...");
123 |                     WebClient webClient = new WebClient();
124 |                     webClient.DownloadFile("https://www.nuget.org/nuget.exe", OutputFilename);
125 | 
126 |                     return true;
127 |                 }
128 |                 catch (Exception ex) {
129 |                     Log.LogErrorFromException(ex);
130 |                     return false;
131 |                 }
132 |             ]]>
133 |             </Code>
134 |         </Task>
135 |     </UsingTask>
136 | </Project>


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/Themes/ProgressBar.xaml:
--------------------------------------------------------------------------------
  1 | <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" x:Class="SoundFingerprinting.DuplicatesDetector.Themes.i__ahtung_sound_fingerprinting_soundfingerprintinggit_src_soundfingerprinting_duplicatesdetector_themes_progressbar_xaml">
  2 | 	<LinearGradientBrush x:Key="ProgressBarBorderBrush" EndPoint="0,1" StartPoint="0,0">
  3 | 		<LinearGradientBrush.GradientStops>
  4 | 			<GradientStop Color="#000630" Offset="0" />
  5 | 			<GradientStop Color="#000630" Offset="1" />
  6 | 		</LinearGradientBrush.GradientStops>
  7 | 	</LinearGradientBrush>
  8 | 	<LinearGradientBrush x:Key="ProgressBarBackground" EndPoint="1,0" StartPoint="0,0">
  9 | 		<LinearGradientBrush.GradientStops>
 10 | 			<GradientStop Color="#000630" Offset="0" />
 11 | 			<GradientStop Color="#FF6351F2" Offset="0.5" />
 12 | 			<GradientStop Color="#000630" Offset="1" />
 13 | 		</LinearGradientBrush.GradientStops>
 14 | 	</LinearGradientBrush>
 15 | 	<LinearGradientBrush x:Key="ProgressBarTopHighlight" StartPoint="0,0" EndPoint="0,1">
 16 | 		<LinearGradientBrush.GradientStops>
 17 | 			<GradientStop Color="#80FFFFFF" Offset="0.05" />
 18 | 			<GradientStop Color="#00FFFFFF" Offset="0.25" />
 19 | 		</LinearGradientBrush.GradientStops>
 20 | 	</LinearGradientBrush>
 21 | 	<LinearGradientBrush x:Key="ProgressBarGlassyHighlight" StartPoint="0,0" EndPoint="0,1">
 22 | 		<LinearGradientBrush.GradientStops>
 23 | 			<GradientStop Color="#50FFFFFF" Offset="0.5385" />
 24 | 			<GradientStop Color="#00FFFFFF" Offset="0.5385" />
 25 | 		</LinearGradientBrush.GradientStops>
 26 | 	</LinearGradientBrush>
 27 | 	<LinearGradientBrush x:Key="ProgressBarIndicatorGlassyHighlight" StartPoint="0,0" EndPoint="0,1">
 28 | 		<LinearGradientBrush.GradientStops>
 29 | 			<GradientStop Color="#90FFFFFF" Offset="0.5385" />
 30 | 			<GradientStop Color="#00FFFFFF" Offset="0.5385" />
 31 | 		</LinearGradientBrush.GradientStops>
 32 | 	</LinearGradientBrush>
 33 | 	<RadialGradientBrush x:Key="ProgressBarIndicatorLightingEffectLeft" RadiusX="1" RadiusY="1" RelativeTransform="1,0,0,1,0.5,0.5">
 34 | 		<RadialGradientBrush.GradientStops>
 35 | 			<GradientStop Color="#60FFFFC4" Offset="0" />
 36 | 			<GradientStop Color="#00FFFFC4" Offset="1" />
 37 | 		</RadialGradientBrush.GradientStops>
 38 | 	</RadialGradientBrush>
 39 | 	<LinearGradientBrush x:Key="ProgressBarIndicatorLightingEffect" StartPoint="0,1" EndPoint="0,0">
 40 | 		<LinearGradientBrush.GradientStops>
 41 | 			<GradientStop Color="#60FFFFC4" Offset="0" />
 42 | 			<GradientStop Color="#00FFFFC4" Offset="1" />
 43 | 		</LinearGradientBrush.GradientStops>
 44 | 	</LinearGradientBrush>
 45 | 	<RadialGradientBrush x:Key="ProgressBarIndicatorLightingEffectRight" RadiusX="1" RadiusY="1" RelativeTransform="1,0,0,1,-0.5,0.5">
 46 | 		<RadialGradientBrush.GradientStops>
 47 | 			<GradientStop Color="#60FFFFC4" Offset="0" />
 48 | 			<GradientStop Color="#00FFFFC4" Offset="1" />
 49 | 		</RadialGradientBrush.GradientStops>
 50 | 	</RadialGradientBrush>
 51 | 
 52 | 	<LinearGradientBrush x:Key="ProgressBarIndicatorDarkEdgeLeft" StartPoint="0,0" EndPoint="1,0">
 53 | 		<LinearGradientBrush.GradientStops>
 54 | 			<GradientStop Color="#0C000000" Offset="0" />
 55 | 			<GradientStop Color="#20000000" Offset="0.3" />
 56 | 			<GradientStop Color="#00000000" Offset="1" />
 57 | 		</LinearGradientBrush.GradientStops>
 58 | 	</LinearGradientBrush>
 59 | 	<LinearGradientBrush x:Key="ProgressBarIndicatorDarkEdgeRight" StartPoint="0,0" EndPoint="1,0">
 60 | 		<LinearGradientBrush.GradientStops>
 61 | 			<GradientStop Color="#00000000" Offset="0" />
 62 | 			<GradientStop Color="#20000000" Offset="0.7" />
 63 | 			<GradientStop Color="#0C000000" Offset="1" />
 64 | 		</LinearGradientBrush.GradientStops>
 65 | 	</LinearGradientBrush>
 66 | 
 67 | 	<LinearGradientBrush x:Key="ProgressBarIndicatorAnimatedFill" StartPoint="0,0" EndPoint="1,0">
 68 | 		<LinearGradientBrush.GradientStops>
 69 | 			<GradientStop Color="#00FFFFFF" Offset="0" />
 70 | 			<GradientStop Color="#60FFFFFF" Offset="0.4" />
 71 | 			<GradientStop Color="#60FFFFFF" Offset="0.6" />
 72 | 			<GradientStop Color="#00FFFFFF" Offset="1" />
 73 | 		</LinearGradientBrush.GradientStops>
 74 | 	</LinearGradientBrush>
 75 | 
 76 | 	<Style x:Key="ProgressBarStyle" TargetType="{x:Type ProgressBar}">
 77 | 		<Setter Property="Foreground" Value="#01D328" />
 78 | 		<Setter Property="Background" Value="{StaticResource ProgressBarBackground}" />
 79 | 		<Setter Property="BorderBrush" Value="{StaticResource ProgressBarBorderBrush}" />
 80 | 		<Setter Property="BorderThickness" Value="1" />
 81 | 		<Setter Property="Template">
 82 | 			<Setter.Value>
 83 | 				<ControlTemplate TargetType="{x:Type ProgressBar}">
 84 | 					<Grid Name="TemplateRoot" SnapsToDevicePixels="true">
 85 | 						<Rectangle Fill="{TemplateBinding Background}" RadiusX="2" RadiusY="2" />
 86 | 						<Border Background="{StaticResource ProgressBarGlassyHighlight}" Margin="1" CornerRadius="1" />
 87 | 						<Border BorderBrush="#80FFFFFF" Background="{StaticResource ProgressBarTopHighlight}" BorderThickness="1,0,1,1" Margin="1" />
 88 | 						<Rectangle Name="PART_Track" Margin="1" />
 89 | 
 90 | 						<Decorator x:Name="PART_Indicator" HorizontalAlignment="Left" Margin="1">
 91 | 							<Grid Name="Foreground">
 92 | 								<Rectangle x:Name="Indicator" Fill="{TemplateBinding Foreground}" />
 93 | 								<Grid x:Name="Animation" ClipToBounds="true">
 94 | 									<Rectangle x:Name="PART_GlowRect" Width="100" Fill="{StaticResource ProgressBarIndicatorAnimatedFill}" Margin="-100,0,0,0" HorizontalAlignment="Left"></Rectangle>
 95 | 								</Grid>
 96 | 								<Grid x:Name="Overlay">
 97 | 									<Grid.ColumnDefinitions>
 98 | 										<ColumnDefinition MaxWidth="15" />
 99 | 										<ColumnDefinition Width="0.1*" />
100 | 										<ColumnDefinition MaxWidth="15" />
101 | 									</Grid.ColumnDefinitions>
102 | 									<Grid.RowDefinitions>
103 | 										<RowDefinition />
104 | 										<RowDefinition />
105 | 									</Grid.RowDefinitions>
106 | 									<Rectangle x:Name="LeftDark" Grid.RowSpan="2" Fill="{StaticResource ProgressBarIndicatorDarkEdgeLeft}" RadiusX="1" RadiusY="1" Margin="1,1,0,1" />
107 | 									<Rectangle x:Name="RightDark" Grid.RowSpan="2" Grid.Column="2" RadiusX="1" RadiusY="1" Fill="{StaticResource ProgressBarIndicatorDarkEdgeRight}" Margin="0,1,1,1" />
108 | 									<Rectangle x:Name="LeftLight" Grid.Column="0" Grid.Row="2" Fill="{StaticResource ProgressBarIndicatorLightingEffectLeft}" />
109 | 									<Rectangle x:Name="CenterLight" Grid.Column="1" Grid.Row="2" Fill="{StaticResource ProgressBarIndicatorLightingEffect}" />
110 | 									<Rectangle x:Name="RightLight" Grid.Column="2" Grid.Row="2" Fill="{StaticResource ProgressBarIndicatorLightingEffectRight}" />
111 | 									<Border x:Name="Highlight1" Grid.RowSpan="2" Grid.ColumnSpan="3" Background="{StaticResource ProgressBarIndicatorGlassyHighlight}" />
112 | 									<Border x:Name="Highlight2" Grid.RowSpan="2" Grid.ColumnSpan="3" Background="{StaticResource ProgressBarTopHighlight}" />
113 | 								</Grid>
114 | 							</Grid>
115 | 						</Decorator>
116 | 
117 | 						<Border BorderThickness="{TemplateBinding BorderThickness}" BorderBrush="{TemplateBinding BorderBrush}" CornerRadius="2" />
118 | 					</Grid>
119 | 					<ControlTemplate.Triggers>
120 | 						<Trigger Property="Orientation" Value="Vertical">
121 | 							<Setter TargetName="TemplateRoot" Property="LayoutTransform">
122 | 								<Setter.Value>
123 | 									<RotateTransform Angle="-90" />
124 | 								</Setter.Value>
125 | 							</Setter>
126 | 						</Trigger>
127 | 
128 | 						<Trigger Property="IsIndeterminate" Value="true">
129 | 							<Setter TargetName="LeftDark" Property="Visibility" Value="Collapsed" />
130 | 							<Setter TargetName="RightDark" Property="Visibility" Value="Collapsed" />
131 | 							<Setter TargetName="LeftLight" Property="Visibility" Value="Collapsed" />
132 | 							<Setter TargetName="CenterLight" Property="Visibility" Value="Collapsed" />
133 | 							<Setter TargetName="RightLight" Property="Visibility" Value="Collapsed" />
134 | 							<Setter TargetName="Indicator" Property="Visibility" Value="Collapsed" />
135 | 						</Trigger>
136 | 						<Trigger Property="IsIndeterminate" Value="false">
137 | 							<Setter TargetName="Animation" Property="Background" Value="#80B5FFA9" />
138 | 						</Trigger>
139 | 					</ControlTemplate.Triggers>
140 | 				</ControlTemplate>
141 | 			</Setter.Value>
142 | 		</Setter>
143 | 	</Style>
144 | </ResourceDictionary>


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/SoundFingerprinting.DuplicatesDetector.csproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <PropertyGroup>
  4 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
  5 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
  6 |     <ExpressionBlendVersion>3.0.1927.0</ExpressionBlendVersion>
  7 |     <ProjectGuid>{572367D4-0F0C-4DC9-BE1C-4D037530D785}</ProjectGuid>
  8 |     <OutputType>WinExe</OutputType>
  9 |     <AppDesignerFolder>Properties</AppDesignerFolder>
 10 |     <DefaultClrNameSpace>Soundfingerprinting.DuplicatesDetector</DefaultClrNameSpace>
 11 |     <RootNamespace>SoundFingerprinting.DuplicatesDetector</RootNamespace>
 12 |     <AssemblyName>SoundFingerprinting.DuplicatesDetector</AssemblyName>
 13 |     <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
 14 |     <AlwaysCompileMarkupFilesInSeparateDomain>false</AlwaysCompileMarkupFilesInSeparateDomain>
 15 |     <ApplicationIcon>Application.ico</ApplicationIcon>
 16 |     <FileAlignment>512</FileAlignment>
 17 |     <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
 18 |     <WarningLevel>4</WarningLevel>
 19 |     <FileUpgradeFlags>
 20 |     </FileUpgradeFlags>
 21 |     <OldToolsVersion>3.5</OldToolsVersion>
 22 |     <UpgradeBackupLocation />
 23 |     <PublishUrl>publish\</PublishUrl>
 24 |     <Install>true</Install>
 25 |     <InstallFrom>Disk</InstallFrom>
 26 |     <UpdateEnabled>false</UpdateEnabled>
 27 |     <UpdateMode>Foreground</UpdateMode>
 28 |     <UpdateInterval>7</UpdateInterval>
 29 |     <UpdateIntervalUnits>Days</UpdateIntervalUnits>
 30 |     <UpdatePeriodically>false</UpdatePeriodically>
 31 |     <UpdateRequired>false</UpdateRequired>
 32 |     <MapFileExtensions>true</MapFileExtensions>
 33 |     <ApplicationRevision>0</ApplicationRevision>
 34 |     <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
 35 |     <IsWebBootstrapper>false</IsWebBootstrapper>
 36 |     <UseApplicationTrust>false</UseApplicationTrust>
 37 |     <BootstrapperEnabled>true</BootstrapperEnabled>
 38 |     <SccProjectName>
 39 |     </SccProjectName>
 40 |     <SccLocalPath>
 41 |     </SccLocalPath>
 42 |     <SccAuxPath>
 43 |     </SccAuxPath>
 44 |     <SccProvider>
 45 |     </SccProvider>
 46 |     <TargetFrameworkProfile />
 47 |     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
 48 |     <RestorePackages>true</RestorePackages>
 49 |   </PropertyGroup>
 50 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
 51 |     <DebugSymbols>true</DebugSymbols>
 52 |     <DebugType>full</DebugType>
 53 |     <Optimize>false</Optimize>
 54 |     <OutputPath>bin\Debug\</OutputPath>
 55 |     <DefineConstants>TRACE;DEBUG</DefineConstants>
 56 |     <ErrorReport>prompt</ErrorReport>
 57 |     <WarningLevel>4</WarningLevel>
 58 |     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
 59 |     <PlatformTarget>x86</PlatformTarget>
 60 |     <Prefer32Bit>false</Prefer32Bit>
 61 |   </PropertyGroup>
 62 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
 63 |     <DebugType>pdbonly</DebugType>
 64 |     <Optimize>true</Optimize>
 65 |     <OutputPath>bin\Release\</OutputPath>
 66 |     <DefineConstants>TRACE</DefineConstants>
 67 |     <ErrorReport>prompt</ErrorReport>
 68 |     <WarningLevel>4</WarningLevel>
 69 |     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
 70 |     <PlatformTarget>x86</PlatformTarget>
 71 |     <Prefer32Bit>false</Prefer32Bit>
 72 |   </PropertyGroup>
 73 |   <ItemGroup>
 74 |     <Reference Include="System" />
 75 |     <Reference Include="System.Core">
 76 |       <RequiredTargetFramework>3.5</RequiredTargetFramework>
 77 |     </Reference>
 78 |     <Reference Include="System.Numerics" />
 79 |     <Reference Include="System.Windows.Forms" />
 80 |     <Reference Include="System.Xaml" />
 81 |     <Reference Include="System.Xml" />
 82 |     <Reference Include="WindowsBase" />
 83 |     <Reference Include="PresentationCore" />
 84 |     <Reference Include="PresentationFramework" />
 85 |   </ItemGroup>
 86 |   <ItemGroup>
 87 |     <ApplicationDefinition Include="App.xaml">
 88 |       <Generator>MSBuild:Compile</Generator>
 89 |       <SubType>Designer</SubType>
 90 |       <Generator>MSBuild:Compile</Generator>
 91 |       <SubType>Designer</SubType>
 92 |     </ApplicationDefinition>
 93 |     <Compile Include="App.xaml.cs">
 94 |       <DependentUpon>App.xaml</DependentUpon>
 95 |     </Compile>
 96 |     <Compile Include="DuplicatesDetectorService.cs" />
 97 |     <Compile Include="Infrastructure\TrackHelper.cs" />
 98 |     <Compile Include="Model\Item.cs" />
 99 |     <Compile Include="Model\ResultItem.cs" />
100 |     <Compile Include="Properties\AssemblyInfo.cs" />
101 |     <Compile Include="MainWindow.xaml.cs">
102 |       <DependentUpon>MainWindow.xaml</DependentUpon>
103 |     </Compile>
104 |     <Compile Include="RelayCommand.cs" />
105 |     <Compile Include="Infrastructure\CSVWriter.cs" />
106 |     <Compile Include="Services\FolderBrowserDialogService.cs" />
107 |     <Compile Include="Services\GenericViewWindowService.cs" />
108 |     <Compile Include="Services\IFolderBrowserDialogService.cs" />
109 |     <Compile Include="Services\IMessageBoxService.cs" />
110 |     <Compile Include="Services\IOpenFileDialogService.cs" />
111 |     <Compile Include="Services\IGenericViewWindow.cs" />
112 |     <Compile Include="Services\ISaveFileDialogService.cs" />
113 |     <Compile Include="Services\IWindowService.cs" />
114 |     <Compile Include="Services\MessageBoxService.cs" />
115 |     <Compile Include="Services\OpenFileDialogService.cs" />
116 |     <Compile Include="Services\SaveFileDialogService.cs" />
117 |     <Compile Include="Infrastructure\ServiceContainer.cs" />
118 |     <Compile Include="Infrastructure\ServiceInjector.cs" />
119 |     <Compile Include="Services\WindowService.cs" />
120 |     <Compile Include="Themes\SetIdConverter.cs" />
121 |     <Compile Include="ViewModel\BooleanToVisibilityConverter.cs" />
122 |     <Compile Include="ViewModel\GenericViewModel.cs" />
123 |     <Compile Include="ViewModel\Helper.cs" />
124 |     <Compile Include="ViewModel\MainWindowViewModel.cs" />
125 |     <Compile Include="ViewModel\PathListViewModel.cs" />
126 |     <Compile Include="ViewModel\ReportViewModel.cs" />
127 |     <Compile Include="DuplicatesDetectorFacade.cs" />
128 |     <Compile Include="ViewModel\ViewModelBase.cs" />
129 |     <Compile Include="View\GenericView.xaml.cs">
130 |       <DependentUpon>GenericView.xaml</DependentUpon>
131 |     </Compile>
132 |     <Compile Include="View\PathListView.xaml.cs">
133 |       <DependentUpon>PathListView.xaml</DependentUpon>
134 |     </Compile>
135 |     <Compile Include="View\ReportView.xaml.cs">
136 |       <DependentUpon>ReportView.xaml</DependentUpon>
137 |     </Compile>
138 |     <Page Include="MainWindowResourceDictionary.xaml">
139 |       <SubType>Designer</SubType>
140 |       <Generator>MSBuild:Compile</Generator>
141 |     </Page>
142 |     <Page Include="Themes\Brushes.xaml">
143 |       <Generator>MSBuild:Compile</Generator>
144 |       <SubType>Designer</SubType>
145 |       <Generator>MSBuild:Compile</Generator>
146 |       <SubType>Designer</SubType>
147 |     </Page>
148 |     <Page Include="Themes\Converters.xaml">
149 |       <SubType>Designer</SubType>
150 |       <Generator>MSBuild:Compile</Generator>
151 |     </Page>
152 |     <Page Include="Themes\Datagrid.xaml">
153 |       <Generator>MSBuild:Compile</Generator>
154 |       <SubType>Designer</SubType>
155 |       <Generator>MSBuild:Compile</Generator>
156 |       <SubType>Designer</SubType>
157 |     </Page>
158 |     <Page Include="MainWindow.xaml">
159 |       <Generator>MSBuild:Compile</Generator>
160 |       <SubType>Designer</SubType>
161 |       <Generator>MSBuild:Compile</Generator>
162 |       <SubType>Designer</SubType>
163 |     </Page>
164 |     <AppDesigner Include="Properties\" />
165 |     <None Include="app.config" />
166 |     <None Include="Application.ico">
167 |       <Visible>false</Visible>
168 |     </None>
169 |     <Page Include="Themes\ItemContStyle.xaml">
170 |       <SubType>Designer</SubType>
171 |       <Generator>MSBuild:Compile</Generator>
172 |     </Page>
173 |     <Page Include="Themes\ProgressBar.xaml">
174 |       <SubType>Designer</SubType>
175 |       <Generator>MSBuild:Compile</Generator>
176 |     </Page>
177 |     <Page Include="Themes\RoundedButton.xaml">
178 |       <SubType>Designer</SubType>
179 |       <Generator>MSBuild:Compile</Generator>
180 |     </Page>
181 |     <Page Include="Themes\TextBlock.xaml">
182 |       <SubType>Designer</SubType>
183 |       <Generator>MSBuild:Compile</Generator>
184 |     </Page>
185 |     <Page Include="View\GenericView.xaml">
186 |       <SubType>Designer</SubType>
187 |       <Generator>MSBuild:Compile</Generator>
188 |     </Page>
189 |     <Page Include="View\PathListView.xaml">
190 |       <SubType>Designer</SubType>
191 |       <Generator>MSBuild:Compile</Generator>
192 |     </Page>
193 |     <Page Include="View\ReportView.xaml">
194 |       <SubType>Designer</SubType>
195 |       <Generator>MSBuild:Compile</Generator>
196 |     </Page>
197 |   </ItemGroup>
198 |   <ItemGroup>
199 |     <Resource Include="Images\icon.png" />
200 |   </ItemGroup>
201 |   <ItemGroup>
202 |     <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
203 |       <Visible>False</Visible>
204 |       <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
205 |       <Install>false</Install>
206 |     </BootstrapperPackage>
207 |     <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
208 |       <Visible>False</Visible>
209 |       <ProductName>.NET Framework 3.5 SP1</ProductName>
210 |       <Install>true</Install>
211 |     </BootstrapperPackage>
212 |     <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
213 |       <Visible>False</Visible>
214 |       <ProductName>Windows Installer 3.1</ProductName>
215 |       <Install>true</Install>
216 |     </BootstrapperPackage>
217 |   </ItemGroup>
218 |   <ItemGroup>
219 |     <PackageReference Include="Ninject">
220 |       <Version>3.3.4</Version>
221 |     </PackageReference>
222 |     <PackageReference Include="SoundFingerprinting">
223 |       <Version>7.3.3</Version>
224 |     </PackageReference>
225 |     <PackageReference Include="SoundFingerprinting.Audio.Bass">
226 |       <Version>7.0.0</Version>
227 |     </PackageReference>
228 |     <PackageReference Include="WPFToolkit">
229 |       <Version>3.5.50211.1</Version>
230 |     </PackageReference>
231 |   </ItemGroup>
232 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
233 |   <PropertyGroup>
234 |     <PreBuildEvent>
235 |     </PreBuildEvent>
236 |   </PropertyGroup>
237 |   <Import Project="$(SolutionDir)\.nuget\nuget.targets" />
238 |   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
239 | 		 Other similar extension points exist, see Microsoft.Common.targets.
240 | 	<Target Name="BeforeBuild">
241 | 	</Target>
242 | 	<Target Name="AfterBuild">
243 | 	</Target>
244 | 	-->
245 | </Project>


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/DuplicatesDetectorFacade.cs:
--------------------------------------------------------------------------------
  1 | namespace SoundFingerprinting.DuplicatesDetector
  2 | {
  3 |     using System;
  4 |     using System.Collections.Concurrent;
  5 |     using System.Collections.Generic;
  6 |     using System.Threading;
  7 |     using System.Threading.Tasks;
  8 | 
  9 |     using SoundFingerprinting.Audio;
 10 |     using SoundFingerprinting.DAO.Data;
 11 |     using SoundFingerprinting.Data;
 12 |     using SoundFingerprinting.DuplicatesDetector.Infrastructure;
 13 |     using SoundFingerprinting.DuplicatesDetector.Model;
 14 |     using SoundFingerprinting.DuplicatesDetector.ViewModel;
 15 | 
 16 |     /// <summary>
 17 |     ///   Facade which prepares the data for analysis of the tracks (does all the "dirty job")
 18 |     /// </summary>
 19 |     internal class DuplicatesDetectorFacade : IDisposable
 20 |     {
 21 |         /// <summary>
 22 |         ///   Maximum track length (track's bigger than this value will be discarded)
 23 |         /// </summary>
 24 |         private const int MaxTrackLength = 60 * 10; /*10 min - maximal track length*/
 25 | 
 26 |         /// <summary>
 27 |         ///   Number of seconds to process from each song
 28 |         /// </summary>
 29 |         private const int SecondsToProcess = 20;
 30 | 
 31 |         /// <summary>
 32 |         ///   Starting processing point
 33 |         /// </summary>
 34 |         private const int StartProcessingAtSecond = 20;
 35 | 
 36 |         /// <summary>
 37 |         ///   Buffer size of the application reading songs
 38 |         /// </summary>
 39 |         /// <remarks>
 40 |         ///   Represented in MB.
 41 |         ///   Max 100MB will be reserved for the samples read from songs
 42 |         /// </remarks>
 43 |         private const int BufferSize = 100;
 44 | 
 45 |         /// <summary>
 46 |         ///   Minimum track length (track's less than this value will be discarded)
 47 |         /// </summary>
 48 |         private const int MinTrackLength = SecondsToProcess + StartProcessingAtSecond + 1;
 49 |        
 50 |         /// <summary>
 51 |         ///   Down sampling rate
 52 |         /// </summary>
 53 |         /// <remarks>
 54 |         ///   If you want to change this, contact ciumac.sergiu@gmail.com
 55 |         /// </remarks>
 56 |         private const int SampleRate = 5512;
 57 |        
 58 |         private readonly DuplicatesDetectorService duplicatesDetectorService;
 59 | 
 60 |         private readonly TrackHelper trackHelper;
 61 | 
 62 |         private CancellationTokenSource cts;
 63 | 
 64 |         public DuplicatesDetectorFacade(DuplicatesDetectorService duplicatesDetectorService, TrackHelper trackHelper)
 65 |         {
 66 |             cts = new CancellationTokenSource();
 67 |             this.duplicatesDetectorService = duplicatesDetectorService;
 68 |             this.trackHelper = trackHelper;
 69 |         }
 70 | 
 71 |         ~DuplicatesDetectorFacade()
 72 |         {
 73 |             Dispose(false);
 74 |         }
 75 | 
 76 |         /// <summary>
 77 |         ///   Process the tracks asynchronously (get their path location, fingerprint content, hash fingerprint into storage)
 78 |         /// </summary>
 79 |         /// <param name = "paths">Paths to be processed</param>
 80 |         /// <param name = "fileFilters">File filters used</param>
 81 |         /// <param name = "callback">Callback invoked once processing ends</param>
 82 |         /// <param name = "trackProcessed">Callback invoked once 1 track is processed</param>
 83 |         public void ProcessTracksAsync(
 84 |             IEnumerable<Item> paths,
 85 |             string[] fileFilters,
 86 |             Action<List<TrackInfo>, Exception> callback,
 87 |             Action<TrackInfo> trackProcessed)
 88 |         {
 89 |             var files = new List<string>();
 90 |             foreach (var path in paths)
 91 |             {
 92 |                 if (path.IsFolder)
 93 |                 {
 94 |                     files.AddRange(Helper.GetMusicFiles(path.Path, fileFilters)); // get music file names
 95 |                 }
 96 |                 else
 97 |                 {
 98 |                     files.Add(path.Path);
 99 |                 }
100 |             }
101 | 
102 |             Task.Factory.StartNew(
103 |                 () =>
104 |                     {
105 |                         try
106 |                         {
107 |                             var tracks = ProcessFiles(files, trackProcessed);
108 |                             callback.Invoke(tracks, null);
109 |                         }
110 |                         catch (AggregateException) /*here we are sure all consumers are done processing*/
111 |                         {
112 |                             callback.Invoke(null, null);
113 |                             duplicatesDetectorService.ClearStorage(); /*its safe to clear the storage, no more thread is executing*/
114 |                         }
115 |                         catch (Exception ex)
116 |                         {
117 |                             callback.Invoke(null, ex);
118 |                         }
119 |                     },
120 |                 cts.Token);
121 |         }
122 | 
123 |         /// <summary>
124 |         ///   Find all duplicate files from the storage
125 |         /// </summary>
126 |         /// <param name = "callback">Callback invoked at each processed track</param>
127 |         /// <returns>Set of tracks that are duplicate</returns>
128 |         public HashSet<TrackData>[] FindAllDuplicates(Action<TrackData, int, int> callback)
129 |         {
130 |             return duplicatesDetectorService.FindDuplicates(callback);
131 |         }
132 | 
133 |         /// <summary>
134 |         ///   Abort processing the files (at any stage)
135 |         /// </summary>
136 |         public void AbortProcessing()
137 |         {
138 |             cts.Cancel();
139 |             cts = new CancellationTokenSource();
140 |         }
141 | 
142 |         public void Dispose()
143 |         {
144 |             Dispose(true);
145 |             GC.SuppressFinalize(this);
146 |         }
147 | 
148 |         protected virtual void Dispose(bool isDisposing)
149 |         {
150 |             if (isDisposing)
151 |             {
152 |                 cts.Dispose();
153 |             }
154 |         }
155 | 
156 |         /// <summary>
157 |         ///   Process files (get fingerprint signatures, hash them into storage)
158 |         /// </summary>
159 |         /// <param name = "files">List of files to be hashed</param>
160 |         /// <param name = "processed">Callback invoked once 1 track is processed</param>
161 |         /// <returns>List of processed tracks</returns>
162 |         private List<TrackInfo> ProcessFiles(IEnumerable<string> files, Action<TrackInfo> processed)
163 |         {
164 |             /*preprocessing stage ended, now make sure to do the actual job*/
165 | 
166 |             int numProcs = Environment.ProcessorCount;
167 | 
168 |             // 1024 (Kb) * BufferSize / SampleRate * SecondsRead * 4 (1 float = 4 bytes) / 1024 (Kb)
169 |             const int Buffersize =
170 |                 (int)((1024.0 * BufferSize) / ((double)SampleRate * SecondsToProcess / 1000 * 4 / 1024));
171 | 
172 |             // ~317 songs are allowed for 15 seconds snippet at 5512 Hz sample rate
173 |             var buffer = new BlockingCollection<Tuple<TrackInfo, AudioSamples>>(Buffersize);
174 |             var processedtracks = new List<TrackInfo>();
175 |             var consumers = new List<Task>();
176 |             var producers = new List<Task>();
177 |             CancellationToken token = cts.Token;
178 |             var bag = new ConcurrentBag<string>(files);
179 | 
180 |             for (var i = 0; i < numProcs; i++)
181 |             {
182 |                 /*producers*/
183 |                 producers.Add(Task.Factory.StartNew(
184 |                     () =>
185 |                     {
186 |                         while (!bag.IsEmpty)
187 |                             {
188 |                                 if (token.IsCancellationRequested)
189 |                                 {
190 |                                     return;
191 |                                 }
192 | 
193 |                                 string file;
194 |                                 if (!bag.TryTake(out file))
195 |                                 {
196 |                                     return;
197 |                                 }
198 | 
199 |                                 TrackInfo track;
200 |                                 AudioSamples samples;
201 |                                 try
202 |                                 {
203 |                                     track = trackHelper.GetTrack(MinTrackLength, MaxTrackLength, file);
204 |                                     samples = trackHelper.GetTrackSamples(track, SampleRate, SecondsToProcess, StartProcessingAtSecond);
205 |                                 }
206 |                                 catch
207 |                                 {
208 |                                     continue;
209 |                                     /*Continue processing even if getting samples failed*/
210 |                                     /*the failing might be caused by a bunch of File I/O factors, that cannot be considered critical*/
211 |                                 }
212 | 
213 |                                 try
214 |                                 {
215 |                                     buffer.TryAdd(new Tuple<TrackInfo, AudioSamples>(track, samples), 1, token); /*producer*/
216 |                                 }
217 |                                 catch (OperationCanceledException)
218 |                                 {
219 |                                     /*it is safe to break here, operation was canceled*/
220 |                                     break;
221 |                                 }
222 |                             }
223 |                     },
224 |                     token));
225 |             }
226 | 
227 |             /*When all producers ended with their operations, call the CompleteAdding() to tell Consumers no more items are available*/
228 |             Task.Factory.ContinueWhenAll(producers.ToArray(), p => buffer.CompleteAdding());
229 | 
230 |             for (int i = 0; i < numProcs * 4; i++) 
231 |             {
232 |                 /*consumer*/
233 |                 consumers.Add(Task.Factory.StartNew(() =>
234 |                     {
235 |                         foreach (Tuple<TrackInfo, AudioSamples> tuple in buffer.GetConsumingEnumerable()) /*If OCE is thrown it will be caught in the caller's AggregateException*/
236 |                         {
237 |                             if (tuple != null)
238 |                             {
239 |                                 /*Long running procedure*/
240 |                                 duplicatesDetectorService.CreateInsertFingerprints(tuple.Item2, tuple.Item1);
241 | 
242 |                                 processedtracks.Add(tuple.Item1);
243 |                                 if (processed != null)
244 |                                 {
245 |                                     processed.Invoke(tuple.Item1);
246 |                                 }
247 |                             }
248 |                         }
249 |                     },
250 |                     token));
251 |             }
252 | 
253 |             Task.WaitAll(consumers.ToArray()); /*wait for all consumers to end*/
254 |             return processedtracks;
255 |         }
256 |     }
257 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/ViewModel/ReportViewModel.cs:
--------------------------------------------------------------------------------
  1 | namespace SoundFingerprinting.DuplicatesDetector.ViewModel
  2 | {
  3 |     using System.Collections.Generic;
  4 |     using System.Collections.ObjectModel;
  5 |     using System.Diagnostics;
  6 |     using System.IO;
  7 |     using System.Linq;
  8 |     using System.Threading.Tasks;
  9 |     using System.Windows.Forms;
 10 |     using System.Windows.Input;
 11 | 
 12 |     using Ninject;
 13 | 
 14 |     using SoundFingerprinting.Audio;
 15 |     using SoundFingerprinting.DAO.Data;
 16 |     using SoundFingerprinting.DuplicatesDetector.Infrastructure;
 17 |     using SoundFingerprinting.DuplicatesDetector.Model;
 18 |     using SoundFingerprinting.DuplicatesDetector.Services;
 19 | 
 20 |     /// <summary>
 21 |     ///   Report view-model, provides the report result to the view
 22 |     /// </summary>
 23 |     public class ReportViewModel : ViewModelBase
 24 |     {
 25 |         private const string StatusPlay = "Play";
 26 |         private const string StatusStop = "Stop";
 27 | 
 28 |         /// <summary>
 29 |         ///   Proxy used in playing files
 30 |         /// </summary>
 31 |         private readonly IPlayAudioFileService audioService = ServiceContainer.Kernel.Get<IPlayAudioFileService>();
 32 | 
 33 |         /// <summary>
 34 |         ///   Flag - if the player is playing something
 35 |         /// </summary>
 36 |         private bool isPlaying;
 37 | 
 38 |         /// <summary>
 39 |         ///  Flag - if the application is moving items from one folder to another
 40 |         /// </summary>
 41 |         private bool isMoving;
 42 | 
 43 |         /// <summary>
 44 |         ///   Opens the location folder where the result item is located
 45 |         /// </summary>
 46 |         private RelayCommand openFolderCommand;
 47 | 
 48 |         /// <summary>
 49 |         ///   Play the selected file
 50 |         /// </summary>
 51 |         private RelayCommand playCommand;
 52 | 
 53 |         /// <summary>
 54 |         ///   Save the results into a file
 55 |         /// </summary>
 56 |         private RelayCommand saveCommand;
 57 | 
 58 |         /// <summary>
 59 |         ///  Move items into a separate folder
 60 |         /// </summary>
 61 |         private RelayCommand moveItemsCommand;
 62 | 
 63 |         /// <summary>
 64 |         ///   Playing status (Stop/Play)
 65 |         /// </summary>
 66 |         private string playingStatus = StatusPlay;
 67 | 
 68 |         /// <summary>
 69 |         ///   Raw results
 70 |         /// </summary>
 71 |         private HashSet<TrackData>[] rawResult;
 72 | 
 73 |         /// <summary>
 74 |         ///   Results displayed
 75 |         /// </summary>
 76 |         private ObservableCollection<ResultItem> results;
 77 | 
 78 |         /// <summary>
 79 |         ///   Status of the player (Show which file is currently playing)
 80 |         /// </summary>
 81 |         private string currentlyPlayingFilename;
 82 | 
 83 |         /// <summary>
 84 |         /// Pointer to currently playing stream
 85 |         /// </summary>
 86 |         private object currentlyPlayingStream;
 87 | 
 88 |         public ReportViewModel()
 89 |         {
 90 |             isPlaying = false;
 91 |             isMoving = false;
 92 |         }
 93 | 
 94 |         public ObservableCollection<ResultItem> Results
 95 |         {
 96 |             get
 97 |             {
 98 |                 return results;
 99 |             }
100 | 
101 |             set
102 |             {
103 |                 if (results != value)
104 |                 {
105 |                     results = value;
106 |                     OnPropertyChanged("Results");
107 |                 }
108 |             }
109 |         }
110 | 
111 |         public ResultItem SelectedItem { get; set; }
112 | 
113 |         public HashSet<TrackData>[] Sets
114 |         {
115 |             get
116 |             {
117 |                 return rawResult;
118 |             }
119 | 
120 |             set
121 |             {
122 |                 rawResult = value;
123 |                 results = new ObservableCollection<ResultItem>(ProcessRawData(rawResult));
124 |             }
125 |         }
126 | 
127 |         public string Status
128 |         {
129 |             get
130 |             {
131 |                 return currentlyPlayingFilename;
132 |             }
133 | 
134 |             set
135 |             {
136 |                 if (currentlyPlayingFilename != value)
137 |                 {
138 |                     currentlyPlayingFilename = value;
139 |                     OnPropertyChanged("Status");
140 |                 }
141 |             }
142 |         }
143 | 
144 |         public string PlayingStatus
145 |         {
146 |             get
147 |             {
148 |                 return playingStatus;
149 |             }
150 | 
151 |             set
152 |             {
153 |                 if (playingStatus != value)
154 |                 {
155 |                     playingStatus = value;
156 |                     OnPropertyChanged("PlayingStatus");
157 |                 }
158 |             }
159 |         }
160 | 
161 |         public RelayCommand OpenFolderCommand
162 |         {
163 |             get
164 |             {
165 |                 return openFolderCommand ?? (openFolderCommand = new RelayCommand(OpenFolder, CanOpenFolder));
166 |             }
167 |         }
168 | 
169 |         public RelayCommand SaveCommand
170 |         {
171 |             get
172 |             {
173 |                 return saveCommand ?? (saveCommand = new RelayCommand(SaveResults, CanSaveResults));
174 |             }
175 |         }
176 | 
177 |         public RelayCommand MoveItemsCommand
178 |         {
179 |             get
180 |             {
181 |                 return moveItemsCommand ?? (moveItemsCommand = new RelayCommand(MoveItems, CanMoveItems));
182 |             }
183 |         }
184 | 
185 |         public RelayCommand PlayCommand
186 |         {
187 |             get
188 |             {
189 |                 return playCommand ?? (playCommand = new RelayCommand(PlayStopAudioFile, CanPlayStopAudioFile));
190 |             }
191 |         }
192 | 
193 |         public void StopPlaying()
194 |         {
195 |             if (isPlaying)
196 |             {
197 |                 audioService.StopPlayingFile(currentlyPlayingStream); // stop previous play
198 |                 isPlaying = !isPlaying;
199 |             }
200 |         }
201 | 
202 |         public void MoveItems(object param)
203 |         {
204 |             // select folder
205 |             IFolderBrowserDialogService fbd = GetService<IFolderBrowserDialogService>();
206 |             if (fbd != null)
207 |             {
208 |                 var result = fbd.Show();
209 |                 if (result == DialogResult.OK || result == DialogResult.Yes)
210 |                 {
211 |                     string selectedPath = fbd.SelectedPath;
212 |                     if (Directory.Exists(selectedPath))
213 |                     {
214 |                         isMoving = true;
215 |                         Task.Factory.StartNew(
216 |                             () =>
217 |                             {
218 |                                 MoveDuplicatesToFolder(selectedPath);
219 |                                 isMoving = false;
220 |                                 Process.Start("explorer.exe", selectedPath);
221 |                             }).ContinueWith(task => CommandManager.InvalidateRequerySuggested(), TaskScheduler.FromCurrentSynchronizationContext());
222 |                     }
223 |                 }
224 |             }
225 |         }
226 | 
227 |         public bool CanMoveItems(object param)
228 |         {
229 |             return Sets.Length > 0 && !isPlaying && !isMoving;
230 |         }
231 | 
232 |         private void OpenFolder(object param)
233 |         {
234 |             if (SelectedItem != null)
235 |             {
236 |                 string path = SelectedItem.Path;
237 |                 Process.Start("explorer.exe", Path.GetDirectoryName(path));
238 |             }
239 |         }
240 | 
241 |         // Is there any item selected, if yes, allow opening the folder and listening to the music
242 |         private bool CanOpenFolder(object param)
243 |         {
244 |             return SelectedItem != null;
245 |         }
246 | 
247 |         /// <summary>
248 |         ///   Save results into a file
249 |         /// </summary>
250 |         /// <param name = "param">Parameter</param>
251 |         private void SaveResults(object param)
252 |         {
253 |             if (Sets.Length > 0)
254 |             {
255 |                 int totalItems = Sets.Sum(set => set.Count) + 1;
256 |                 object[][] array = new object[totalItems][];
257 |                 int i = 0;
258 |                 int setId = 0;
259 |                 array[i] = new object[2];
260 |                 array[i][0] = "Set ID";
261 |                 array[i][1] = "Path";
262 |                 i++;
263 |                 foreach (HashSet<TrackData> set in Sets)
264 |                 {
265 |                     foreach (TrackData track in set)
266 |                     {
267 |                         array[i] = new object[2];
268 |                         array[i][0] = setId;
269 |                         array[i][1] = track.MetaFields["FilePath"];
270 |                         i++;
271 |                     }
272 | 
273 |                     setId++;
274 |                 }
275 | 
276 |                 ISaveFileDialogService sfd = GetService<ISaveFileDialogService>();
277 |                 if (sfd != null)
278 |                 {
279 |                     if (sfd.SaveFile("Save result", "results.csv", "(*.csv)|*.csv") == DialogResult.OK)
280 |                     {
281 |                         string path = sfd.Filename;
282 |                         if (!string.IsNullOrEmpty(path))
283 |                         {
284 |                             CSVWriter writer = new CSVWriter(path);
285 |                             writer.Write(array);
286 |                         }
287 |                     }
288 |                 }
289 |             }
290 |         }
291 | 
292 |         /// <summary>
293 |         ///   Check if the results can be exported
294 |         /// </summary>
295 |         /// <param name = "param">Parameter</param>
296 |         /// <returns>True/False</returns>
297 |         private bool CanSaveResults(object param)
298 |         {
299 |             return Sets.Length > 0;
300 |         }
301 | 
302 |         /// <summary>
303 |         ///   Play/Stop audio file
304 |         /// </summary>
305 |         /// <param name = "param">Parameter</param>
306 |         private void PlayStopAudioFile(object param)
307 |         {
308 |             if (!isPlaying)
309 |             {
310 |                 if (SelectedItem != null)
311 |                 {
312 |                     string filename = SelectedItem.Path;
313 |                     if (File.Exists(SelectedItem.Path))
314 |                     {
315 |                         string path = Path.GetFileName(filename);
316 |                         Status = "Playing: " + path;
317 |                         audioService.StopPlayingFile(currentlyPlayingStream); // stop previous play, if such
318 |                         currentlyPlayingStream = audioService.PlayFile(filename); // play file
319 |                         PlayingStatus = StatusStop; // change playing status 
320 |                         isPlaying = true;
321 |                     }
322 |                 }
323 |                 else
324 |                 {
325 |                     audioService.StopPlayingFile(currentlyPlayingStream); // stop previous play, if such
326 |                 }
327 |             }
328 |             else
329 |             {
330 |                 Status = string.Empty;
331 |                 audioService.StopPlayingFile(currentlyPlayingStream); // stop previous play
332 |                 isPlaying = !isPlaying;
333 |                 PlayingStatus = StatusPlay; // change status
334 |             }
335 |         }
336 | 
337 |         /// <summary>
338 |         ///   Can play/stop audio file
339 |         /// </summary>
340 |         /// <param name = "param">Parameter</param>
341 |         /// <returns>True/False</returns>
342 |         private bool CanPlayStopAudioFile(object param)
343 |         {
344 |             return SelectedItem != null || isPlaying;
345 |         }
346 | 
347 |         /// <summary>
348 |         ///   Process raw results for suitable appearance
349 |         /// </summary>
350 |         /// <param name = "rawData">Raw data</param>
351 |         /// <returns>List of items for view</returns>
352 |         private List<ResultItem> ProcessRawData(IEnumerable<HashSet<TrackData>> rawData)
353 |         {
354 |             List<ResultItem> showResults = new List<ResultItem>();
355 |             int counter = 0;
356 |             foreach (HashSet<TrackData> item in rawData)
357 |             {
358 |                 showResults.AddRange(item.Select(track => new ResultItem(counter, track)));
359 |                 counter++;
360 |             }
361 | 
362 |             return showResults;
363 |         }
364 | 
365 |         private void MoveDuplicatesToFolder(string selectedPath)
366 |         {
367 |             foreach (var set in Sets)
368 |             {
369 |                 bool hasUniqueFiles = CheckIfUniqueNames(set);
370 |                 int count = 1;
371 |                 foreach (var duplicate in set)
372 |                 {
373 |                     string fileName = Path.GetFileName(duplicate.MetaFields["FilePath"]); // Path is stored in album
374 |                     if (!hasUniqueFiles)
375 |                     {
376 |                         fileName = string.Format("{0}_{1}", count, fileName);
377 |                     }
378 | 
379 |                     string srcPath = duplicate.MetaFields["FilePath"];
380 |                     if (fileName != null)
381 |                     {
382 |                         string dstPath = Path.Combine(selectedPath, fileName);
383 |                         if (!File.Exists(dstPath))
384 |                         {
385 |                             try
386 |                             {
387 |                                 File.Move(srcPath, dstPath);
388 |                                 duplicate.MetaFields["FilePath"] = dstPath;
389 |                             }
390 |                             catch
391 |                             {
392 |                                 continue;
393 |                             }
394 |                         }
395 |                     }
396 | 
397 |                     count++;
398 |                 }
399 |             }
400 |         }
401 | 
402 |         private bool CheckIfUniqueNames(IEnumerable<TrackData> source)
403 |         {
404 |             Dictionary<string, bool> distinct = new Dictionary<string, bool>();
405 |             foreach (var track in source)
406 |             {
407 |                 string fileName = Path.GetFileName(track.MetaFields["FilePath"]);
408 |                 if (fileName != null)
409 |                 {
410 |                     if (distinct.ContainsKey(fileName))
411 |                     {
412 |                         return false;
413 |                     }
414 | 
415 |                     distinct[fileName] = true;
416 |                 }
417 |             }
418 | 
419 |             return true;
420 |         }
421 |     }
422 | }


--------------------------------------------------------------------------------
/src/SoundFingerprinting.DuplicatesDetector/ViewModel/PathListViewModel.cs:
--------------------------------------------------------------------------------
  1 | namespace SoundFingerprinting.DuplicatesDetector.ViewModel
  2 | {
  3 |     using System;
  4 |     using System.Collections.Generic;
  5 |     using System.Collections.ObjectModel;
  6 |     using System.Collections.Specialized;
  7 |     using System.IO;
  8 |     using System.Linq;
  9 |     using System.Threading;
 10 |     using System.Threading.Tasks;
 11 |     using System.Windows;
 12 |     using System.Windows.Forms;
 13 |     using System.Windows.Input;
 14 | 
 15 |     using SoundFingerprinting.DAO.Data;
 16 |     using SoundFingerprinting.DuplicatesDetector.Model;
 17 |     using SoundFingerprinting.DuplicatesDetector.Services;
 18 | 
 19 |     /// <summary>
 20 |     ///   Path List VM
 21 |     /// </summary>
 22 |     public class PathListViewModel : ViewModelBase
 23 |     {
 24 |         #region Constants
 25 | 
 26 |         private const string StepSelectRootFolder = "Step 1/3 - Select root folders";
 27 |         private const string StepHashingMusicFiles = "Step 2/3 - Fingerprinting music files";
 28 |         private const string StepFindDuplicates = "Step 3/3 - Finding duplicates";
 29 |         private const string SetpGeneratingReport = "Generating report...";
 30 |         private const string StepAborting = "Aborting, please wait...";
 31 | 
 32 |         private static readonly object LockObject = new object();
 33 | 
 34 |         /// <summary>
 35 |         ///   Music file filters
 36 |         /// </summary>
 37 |         private readonly string[] musicFileFilters = new[] { "*.mp3", "*.ogg", "*.flac", "*.wav" };
 38 | 
 39 |         #endregion
 40 |         
 41 |         /// <summary>
 42 |         ///   Repository gateway
 43 |         /// </summary>
 44 |         private readonly DuplicatesDetectorFacade duplicatesDetectorFacade;
 45 | 
 46 |         /// <summary>
 47 |         ///   Add single music file command
 48 |         /// </summary>
 49 |         private RelayCommand addFileCommand;
 50 | 
 51 |         /// <summary>
 52 |         ///   Add more folders command
 53 |         /// </summary>
 54 |         private RelayCommand addMoreCommand;
 55 | 
 56 |         private int currentProgress;
 57 | 
 58 |         /// <summary>
 59 |         ///   Paths to folders to be processed
 60 |         /// </summary>
 61 |         private ObservableCollection<Item> paths;
 62 | 
 63 |         /// <summary>
 64 |         ///   Processed music files
 65 |         /// </summary>
 66 |         private int processedMusicItems;
 67 | 
 68 |         private HashSet<Item> processedPaths;
 69 | 
 70 |         /// <summary>
 71 |         ///   Flag for processing is possible
 72 |         /// </summary>
 73 |         private bool processing;
 74 | 
 75 |         /// <summary>
 76 |         ///   Processing step
 77 |         /// </summary>
 78 |         private string processingStep;
 79 | 
 80 |         /// <summary>
 81 |         ///   Start processing command
 82 |         /// </summary>
 83 |         private RelayCommand startCommand;
 84 | 
 85 |         /// <summary>
 86 |         ///   Stop processing command
 87 |         /// </summary>
 88 |         private RelayCommand stopCommand;
 89 | 
 90 |         /// <summary>
 91 |         ///   Total music items to process
 92 |         /// </summary>
 93 |         private int totalMusicItems;
 94 | 
 95 |         public PathListViewModel()
 96 |         {
 97 |             paths = new ObservableCollection<Item>();
 98 |             paths.CollectionChanged += CollectionChanged; /*Subscribe to the event when the collection gets changed*/
 99 |             processingStep = StepSelectRootFolder;
100 |             TaskScheduler = TaskScheduler.FromCurrentSynchronizationContext();
101 |             try
102 |             {
103 |                 duplicatesDetectorFacade = GetService<DuplicatesDetectorFacade>();
104 |             }
105 |             catch (Exception ex)
106 |             {
107 |                 IMessageBoxService msb = GetService<IMessageBoxService>(); // Show dialog if an exception occurred during processing
108 |                 if (msb != null)
109 |                 {
110 |                     msb.Show(ex.Message, "Exception occurred during processing!", MessageBoxButton.OK, MessageBoxImage.Error);
111 |                 }
112 |             }
113 |         }
114 | 
115 |         public ObservableCollection<Item> Paths
116 |         {
117 |             get
118 |             {
119 |                 return paths ?? (paths = new ObservableCollection<Item>());
120 |             }
121 |         }
122 | 
123 |         public string ProcessingStep
124 |         {
125 |             get
126 |             {
127 |                 return processingStep;
128 |             }
129 | 
130 |             set
131 |             {
132 |                 if (processingStep != value)
133 |                 {
134 |                     processingStep = value;
135 |                     OnPropertyChanged("ProcessingStep");
136 |                 }
137 |             }
138 |         }
139 | 
140 |         public bool IsProcessing
141 |         {
142 |             get
143 |             {
144 |                 return processing;
145 |             }
146 | 
147 |             set
148 |             {
149 |                 if (processing != value)
150 |                 {
151 |                     processing = value;
152 |                     OnPropertyChanged("IsProcessing");
153 |                 }
154 |             }
155 |         }
156 | 
157 |         public int CurrentProgress
158 |         {
159 |             get
160 |             {
161 |                 return currentProgress;
162 |             }
163 | 
164 |             private set
165 |             {
166 |                 if (currentProgress != value)
167 |                 {
168 |                     currentProgress = value;
169 |                     OnPropertyChanged("CurrentProgress");
170 |                 }
171 |             }
172 |         }
173 |         
174 |         public TaskScheduler TaskScheduler { get; private set; }
175 | 
176 |         public ICommand AddMoreCommand
177 |         {
178 |             get
179 |             {
180 |                 return addMoreCommand ?? (addMoreCommand = new RelayCommand(AddMoreFolders, CanAddMoreFolders));
181 |             }
182 |         }
183 | 
184 |         public ICommand StartCommand
185 |         {
186 |             get
187 |             {
188 |                 return startCommand ?? (startCommand = new RelayCommand(StartProcessing, CanStartProcessing));
189 |             }
190 |         }
191 | 
192 |         public ICommand StopCommand
193 |         {
194 |             get
195 |             {
196 |                 return stopCommand ?? (stopCommand = new RelayCommand(StopProcessing, CanStopProcessing));
197 |             }
198 |         }
199 | 
200 |         public ICommand AddFileCommand
201 |         {
202 |             get
203 |             {
204 |                 return addFileCommand ?? (addFileCommand = new RelayCommand(AddFile, CanAddFile));
205 |             }
206 |         }
207 | 
208 |         public void AddMoreFolders(object param)
209 |         {
210 |             IFolderBrowserDialogService fbg = GetService<IFolderBrowserDialogService>();
211 |             if (fbg != null)
212 |             {
213 |                 if (DialogResult.OK == fbg.Show())
214 |                 {
215 |                     string selectedPath = fbg.SelectedPath;
216 |                     
217 |                     // Check if such directory exists, and check if such directory wasn't already introduced
218 |                     if (!string.IsNullOrEmpty(selectedPath) && Paths.All(folder => selectedPath != folder.Path))
219 |                     {
220 |                         if (Directory.Exists(selectedPath))
221 |                         {
222 |                             Paths.Add(new Item { Path = selectedPath, Count = -1, IsFolder = true });
223 |                         }
224 |                         else if (File.Exists(selectedPath))
225 |                         {
226 |                             Paths.Add(new Item { Path = selectedPath, Count = 1, IsFolder = false });
227 |                             return;
228 |                         }
229 |                         else
230 |                         {
231 |                             return;
232 |                         }
233 | 
234 |                         // count the number of available music files asynchronously
235 |                         Task.Factory.StartNew(
236 |                             () =>
237 |                             {
238 |                                 int count = Helper.CountNumberOfMusicFiles(selectedPath, musicFileFilters);
239 | 
240 |                                 lock (LockObject)
241 |                                 {
242 |                                     int index = -1;
243 |                                     foreach (Item path in Paths)
244 |                                     {
245 |                                         index++;
246 |                                         if (path.Path == selectedPath)
247 |                                         {
248 |                                             break;
249 |                                         }
250 |                                     }
251 | 
252 |                                     if (Paths != null && Paths.Count >= index && index >= 0)
253 |                                     {
254 |                                         totalMusicItems += count;
255 |                                         Paths[index].Count = count;
256 |                                     }
257 |                                 }
258 |                             }).ContinueWith(
259 |                                 task => CommandManager.InvalidateRequerySuggested(), TaskScheduler);
260 |                     }
261 |                 }
262 |             }
263 |         }
264 | 
265 |         /// <summary>
266 |         ///   Check if adding folders is allowed
267 |         /// </summary>
268 |         /// <param name = "param">Any parameter</param>
269 |         /// <returns>True if allowed, otherwise false</returns>
270 |         /// <remarks>
271 |         ///   Can execute is called before Execute() method, thus if the method returns false, the button will be disabled
272 |         /// </remarks>
273 |         public bool CanAddMoreFolders(object param)
274 |         {
275 |             return !IsProcessing;
276 |         }
277 | 
278 |         /// <summary>
279 |         ///   Actual method which start processing
280 |         /// </summary>
281 |         /// <param name = "param">Parameter</param>
282 |         public void StartProcessing(object param)
283 |         {
284 |             ProcessingStep = StepHashingMusicFiles;
285 |             IsProcessing = true;
286 |             int alreadyProcessedFiles = processedMusicItems;
287 |             HashSet<Item> pathsToBeProcessed;
288 | 
289 |             if (processedPaths == null)
290 |             {
291 |                 pathsToBeProcessed = new HashSet<Item>(Paths);
292 |                 processedPaths = new HashSet<Item>(Paths);
293 |             }
294 |             else
295 |             {
296 |                 // if there are already paths that have been processed, use only new ones
297 |                 var except = Paths.Except(processedPaths).ToList();
298 |                 pathsToBeProcessed = new HashSet<Item>(except);
299 |                 if (pathsToBeProcessed.Count == 0)
300 |                 {
301 |                     FindDuplicates();
302 |                     return;
303 |                 }
304 | 
305 |                 foreach (Item item in except)
306 |                 {
307 |                     processedPaths.Add(item);
308 |                 }
309 |             }
310 | 
311 |             duplicatesDetectorFacade.ProcessTracksAsync(
312 |                 pathsToBeProcessed,
313 |                 musicFileFilters,
314 |                 (tracks, exception) => /*processing ends*/
315 |                 {
316 |                     if (exception != null) /*Exception occurred during processing*/
317 |                     {
318 |                         IMessageBoxService msg = GetService<IMessageBoxService>();
319 |                         msg.Show("Error occurred during processing!\n" + exception.Message, "Error!", MessageBoxButton.OK, MessageBoxImage.Error);
320 |                         if (IsProcessing)
321 |                         {
322 |                             IsProcessing = false;
323 |                         }
324 | 
325 |                         return;
326 |                     }
327 | 
328 |                     if (tracks == null || tracks.Count == 0) /*Processing aborted*/
329 |                     {
330 |                         IsProcessing = false; /*successfully aborted continue*/
331 |                         CurrentProgress = 0;
332 |                         ProcessingStep = StepSelectRootFolder;
333 |                         Task.Factory.StartNew(CommandManager.InvalidateRequerySuggested, CancellationToken.None, TaskCreationOptions.None, TaskScheduler);
334 |                         return;
335 |                     }
336 | 
337 |                     /*Processing ended*/
338 |                     ProcessingStep = StepFindDuplicates;
339 |                     CurrentProgress = 0;
340 |                     FindDuplicates();
341 |                 },
342 |                 track => /*one file is processed*/
343 |                 {
344 |                     // ReSharper disable AccessToModifiedClosure
345 |                     Interlocked.Increment(ref alreadyProcessedFiles);
346 |                     // ReSharper restore AccessToModifiedClosure
347 |                     CurrentProgress = (int)Math.Ceiling((float)alreadyProcessedFiles / totalMusicItems * 100);
348 |                     if (alreadyProcessedFiles >= totalMusicItems)
349 |                     {
350 |                         processedMusicItems = alreadyProcessedFiles; /*set processed unit items*/
351 |                         alreadyProcessedFiles = 0;
352 |                         CurrentProgress = 0;
353 |                     }
354 |                 });
355 |         }
356 | 
357 |         /// <summary>
358 |         ///   Check if the system can start processing
359 |         /// </summary>
360 |         /// <param name = "param">Parameter</param>
361 |         /// <returns>True/False</returns>
362 |         public bool CanStartProcessing(object param)
363 |         {
364 |             return !IsProcessing && totalMusicItems > 1 && (totalMusicItems - processedMusicItems > 0); /*Processing can start if you have at least 2 files to play with*/
365 |         }
366 | 
367 |         /// <summary>
368 |         ///   Stop processing the songs
369 |         /// </summary>
370 |         /// <param name = "param">Parameter</param>
371 |         public void StopProcessing(object param)
372 |         {
373 |             ProcessingStep = StepAborting;
374 |             processedMusicItems = 0;
375 |             processedPaths = null;
376 |             duplicatesDetectorFacade.AbortProcessing();
377 |         }
378 | 
379 |         /// <summary>
380 |         ///   Check if the system can stop processing the songs
381 |         /// </summary>
382 |         /// <param name = "param">Parameter</param>
383 |         /// <returns>True/False</returns>
384 |         public bool CanStopProcessing(object param)
385 |         {
386 |             return IsProcessing;
387 |         }
388 | 
389 |         public void AddFile(object param)
390 |         {
391 |             IOpenFileDialogService fbg = GetService<IOpenFileDialogService>();
392 |             if (fbg != null)
393 |             {
394 |                 if (DialogResult.OK == fbg.Show("Please choose your awesome track", "Amazing Track", Helper.GetMultipleFilter("Supported Formats", musicFileFilters), true))
395 |                 {
396 |                     string[] selectedPaths = fbg.SelectedPaths;
397 |                     foreach (string selectedPath in selectedPaths)
398 |                     {
399 |                         // Check if such directory exists, and check if such directory wasn't already introduced
400 |                         if (!string.IsNullOrEmpty(selectedPath) && Paths.All(folder => selectedPath != folder.Path))
401 |                         {
402 |                             if (Directory.Exists(selectedPath))
403 |                             {
404 |                                 Paths.Add(new Item { Path = selectedPath, Count = -1, IsFolder = true });
405 |                             }
406 |                             else if (File.Exists(selectedPath))
407 |                             {
408 |                                 Paths.Add(new Item { Path = selectedPath, Count = 1, IsFolder = false });
409 |                             }
410 |                         }
411 |                     }
412 |                 }
413 |             }
414 | 
415 |             if (param != null)
416 |             {
417 |                 if (File.Exists(param as string))
418 |                 {
419 |                     string extension = Path.GetExtension(param as string);
420 |                     if (musicFileFilters.Where(filter => extension != null).Any(filter => filter.Contains(extension)))
421 |                     {
422 |                         Paths.Add(new Item { Path = param as string, Count = 1, IsFolder = false });
423 |                     }
424 |                 }
425 |             }
426 |         }
427 | 
428 |         private void CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
429 |         {
430 |             if (e.Action == NotifyCollectionChangedAction.Add)
431 |             {
432 |                 foreach (object item in e.NewItems)
433 |                 {
434 |                     int c = ((Item)item).Count;
435 |                     if (c > 0)
436 |                     {
437 |                         totalMusicItems += c;
438 |                     }
439 |                 }
440 |             }
441 |             else if (e.Action == NotifyCollectionChangedAction.Remove)
442 |             {
443 |                 foreach (object item in e.OldItems)
444 |                 {
445 |                     int c = ((Item)item).Count;
446 |                     if (c > 0)
447 |                     {
448 |                         totalMusicItems -= c;
449 |                     }
450 |                 }
451 |             }
452 | 
453 |             OnPropertyChanged("Paths"); /*Signalize that the collection got changed*/
454 |         }
455 | 
456 |         /// <summary>
457 |         ///   Search the storage for duplicate files
458 |         /// </summary>
459 |         private void FindDuplicates()
460 |         {
461 |             HashSet<TrackData>[] duplicates = null;
462 |             Task.Factory.StartNew(
463 |                 () =>
464 |                 {
465 |                     duplicates = duplicatesDetectorFacade.FindAllDuplicates(
466 |                         (track, total, current) =>
467 |                             {
468 |                                 CurrentProgress = (int)Math.Ceiling((float)current / total * 100);
469 |                                 if (current >= total)
470 |                                 {
471 |                                 processedMusicItems = current; /*set processed unit items*/
472 |                                 CurrentProgress = 0;
473 |                             }
474 |                         });
475 |                 }).ContinueWith( /*Update the UI*/
476 |                 task =>
477 |                 {
478 |                     ProcessingStep = SetpGeneratingReport;
479 |                     ReportViewModel report = new ReportViewModel { Sets = duplicates };
480 |                     GenericViewModel viewModel = new GenericViewModel();
481 |                     viewModel.Workspaces.Add(report);
482 |                     IGenericViewWindow view = GetService<IGenericViewWindow>();
483 |                     IWindowService windowMediator = GetService<IWindowService>();
484 |                     windowMediator.ShowDialog(view, viewModel, (o, args) => report.StopPlaying());
485 |                     ProcessingStep = StepSelectRootFolder;
486 |                     IsProcessing = false;
487 |                 },
488 |                     TaskScheduler);
489 |         }
490 | 
491 |         /// <summary>
492 |         ///   See if adding files is allowed
493 |         /// </summary>
494 |         /// <param name = "param">Parameter</param>
495 |         /// <returns>True/False</returns>
496 |         private bool CanAddFile(object param)
497 |         {
498 |             return !IsProcessing;
499 |         }
500 |     }
501 | }


--------------------------------------------------------------------------------