Merge branch 'LiuYunPlayer:master' into master

Author: A-MAIN

TuneLab/App.axaml.cs

@@ -17,6 +17,10 @@
 using TuneLab.Utils;
 using TuneLab.I18N;
 using System.Linq;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+using System.Threading;
+using System.IO.Pipes;
 
 namespace TuneLab;
 
@@ -45,23 +49,56 @@ public override void OnFrameworkInitializationCompleted()
 
                 // init audio engine
                 AudioUtils.Init(new NAudioCodec());
-                AudioEngine.Init(new SDLPlaybackHandler());
+                AudioEngine.SampleRate.Value = Settings.SampleRate;
+                AudioEngine.BufferSize.Value = Settings.BufferSize;
+                if (!string.IsNullOrEmpty(Settings.AudioDriver)) AudioEngine.CurrentDriver.Value = Settings.AudioDriver;
+                if (!string.IsNullOrEmpty(Settings.AudioDevice)) AudioEngine.CurrentDevice.Value = Settings.AudioDevice;
+                AudioEngine.Init();
                 AudioEngine.LoadKeySamples(Settings.PianoKeySamplesPath);
                 AudioEngine.MasterGain = Settings.MasterGain;
                 Settings.PianoKeySamplesPath.Modified.Subscribe(() => AudioEngine.LoadKeySamples(Settings.PianoKeySamplesPath));
                 Settings.MasterGain.Modified.Subscribe(() => { AudioEngine.MasterGain = Settings.MasterGain; });
+                Settings.BufferSize.Modified.Subscribe(() => { AudioEngine.BufferSize.Value = Settings.BufferSize; });
+                Settings.SampleRate.Modified.Subscribe(() => { AudioEngine.SampleRate.Value = Settings.SampleRate; });
+                Settings.AudioDriver.Modified.Subscribe(() => { AudioEngine.CurrentDriver.Value = Settings.AudioDriver; });
+                Settings.AudioDevice.Modified.Subscribe(() => { AudioEngine.CurrentDevice.Value = Settings.AudioDevice; });
 
                 ExtensionManager.LoadExtensions();
-                var mainWindow = new MainWindow();
-                desktop.MainWindow = mainWindow;
+                mMainWindow = new MainWindow();
+                desktop.MainWindow = mMainWindow;
 
                 // 检测启动参数
                 var args = Environment.GetCommandLineArgs();
-                if (args.Length > 1)
+                Log.Info($"Command line args:");
+                for (int i = 1; i < args.Length; i++)
                 {
-                    var filePath = args[1];
-                    mainWindow.Editor.OpenProjectByPath(filePath);
+                    Log.Info(args[i]);
+                    HandleArg(args[i]);
                 }
+
+                // 获取主线程SynchronizationContext
+                var context = SynchronizationContext.Current ?? throw new InvalidOperationException("SynchronizationContext.Current is null");
+
+                // 监听其他实例的启动参数
+                Task.Run(() =>
+                {
+                    while (true)
+                    {
+                        var pipeServer = new NamedPipeServerStream("TuneLab", PipeDirection.In);
+                        pipeServer.WaitForConnection();
+
+                        using var reader = new StreamReader(pipeServer);
+                        while (pipeServer.IsConnected)
+                        {
+                            var arg = reader.ReadLine();
+                            if (arg == null)
+                                continue;
+
+                            Log.Info($"Received from another instance: {arg}");
+                            context.Post(_ => HandleArg(arg), null);
+                        }
+                    }
+                });
             }
             catch (Exception ex)
             {
@@ -92,4 +129,11 @@ public override void OnFrameworkInitializationCompleted()
 
         base.OnFrameworkInitializationCompleted();
     }
+
+    public void HandleArg(string arg)
+    {
+        mMainWindow?.Editor.OpenProjectByPath(arg);
+    }
+
+    MainWindow? mMainWindow = null;
 }

TuneLab/Audio/AudioEngine.cs

@@ -7,6 +7,8 @@
 using System.Threading;
 using System.Threading.Channels;
 using System.Threading.Tasks;
+using TuneLab.Audio.SDL2;
+using TuneLab.Base.Event;
 using TuneLab.Base.Science;
 using TuneLab.Base.Utils;
 using TuneLab.Utils;
@@ -17,53 +19,78 @@ internal static class AudioEngine
 {
     public static event Action? PlayStateChanged;
     public static event Action? ProgressChanged;
-    public static bool IsPlaying => mAudioProvider!.IsPlaying;
-    public static int SamplingRate => mAudioProvider!.SamplingRate;
-    public static double CurrentTime => mAudioProvider!.CurrentTime;
+    public static bool IsPlaying => mAudioSampleProvider.IsPlaying;
+    public static INotifiableProperty<int> SampleRate { get; } = new NotifiableProperty<int>(44100);
+    public static double CurrentTime => mAudioSampleProvider.CurrentTime;
     public static double MasterGain { get; set; } = 0;
     public static double EndTime => AudioGraph.EndTime;
+    public static INotifiableProperty<int> BufferSize { get; } = new NotifiableProperty<int>(1024);
+    public static INotifiableProperty<string> CurrentDriver { get; } = new NotifiableProperty<string>(string.Empty);
+    public static INotifiableProperty<string> CurrentDevice { get; } = new NotifiableProperty<string>(string.Empty);
+    public static IReadOnlyList<string> GetAllDrivers() => mAudioPlaybackHandler!.GetAllDrivers();
+    public static IReadOnlyList<string> GetAllDevices() => mAudioPlaybackHandler!.GetAllDevices();
 
-    public static void Init(IAudioPlaybackHandler playbackHandler)
+    public static void Init()
     {
-        mAudioProvider = new(44100);
-
-        mAudioPlaybackHandler = playbackHandler;
-        mAudioPlaybackHandler.Init(mAudioProvider);
+        mAudioSampleProvider.SampleRate = SampleRate.Value;
+        mAudioPlaybackHandler = new SDLPlaybackHandler() { SampleRate = SampleRate.Value, BufferSize = BufferSize.Value, ChannelCount = 2 };
+        mAudioPlaybackHandler.Init(mAudioSampleProvider);
+        SetDriverToPlaybackHandler();
+        SetDeviceToPlaybackHandler();
         mAudioPlaybackHandler.ProgressChanged += () => { if (IsPlaying) ProgressChanged?.Invoke(); };
+        mAudioPlaybackHandler.CurrentDeviceChanged += () => 
+        {
+            CurrentDevice.Value = mAudioPlaybackHandler.CurrentDevice;
+            mAudioPlaybackHandler.Start();
+        };
+        mAudioPlaybackHandler.DevicesChanged += () =>
+        {
+            SetDeviceToPlaybackHandler();
+        };
 
         ProgressChanged += OnProgressChanged;
+        SampleRate.Modified.Subscribe(OnSampleRateModified);
+        BufferSize.Modified.Subscribe(OnBufferSizeModified);
+        CurrentDriver.Modified.Subscribe(OnCurrentDriverModified);
+        CurrentDevice.Modified.Subscribe(OnCurrentDeviceModified);
 
         mAudioPlaybackHandler.Start();
     }
 
     public static void Destroy()
     {
         if (mAudioPlaybackHandler == null)
-            throw new Exception("Engine is not inited!");
+        {
+            Log.Error("Engine is not inited!");
+            return;
+        }
 
         mAudioPlaybackHandler.Stop();
 
         ProgressChanged -= OnProgressChanged;
+        SampleRate.Modified.Unsubscribe(OnSampleRateModified);
+        CurrentDriver.Modified.Unsubscribe(OnCurrentDriverModified);
+        CurrentDevice.Modified.Unsubscribe(OnCurrentDeviceModified);
 
         mAudioPlaybackHandler.Destroy();
         mAudioPlaybackHandler = null;
     }
 
     public static void Play()
     {
-        mAudioProvider!.IsPlaying = true;
+        mAudioSampleProvider.IsPlaying = true;
         PlayStateChanged?.Invoke();
     }
 
     public static void Pause()
     {
-        mAudioProvider!.IsPlaying = false;
+        mAudioSampleProvider.IsPlaying = false;
         PlayStateChanged?.Invoke();
     }
 
     public static void Seek(double time)
     {
-        mAudioProvider?.Seek(time);
+        mAudioSampleProvider.Seek(time);
         ProgressChanged?.Invoke();
     }
 
@@ -82,19 +109,19 @@ public static void ExportTrack(string filePath, IAudioTrack track, bool isStereo
         double endTime = track.EndTime;
         endTime = Math.Max(endTime, 0);
         endTime += 1;
-        int endPosition = (endTime * SamplingRate).Ceil();
+        int endPosition = (endTime * SampleRate.Value).Ceil();
         float[] buffer = new float[isStereo ? endPosition * 2 : endPosition];
         AudioGraph.AddData(track, 0, endPosition, isStereo, buffer, 0);
-        AudioUtils.EncodeToWav(filePath, buffer, SamplingRate, 16, isStereo ? 2 : 1);
+        AudioUtils.EncodeToWav(filePath, buffer, SampleRate.Value, 16, isStereo ? 2 : 1);
     }
 
     public static void ExportMaster(string filePath, bool isStereo)
     {
         var endTime = AudioGraph.EndTime;
-        int endPosition = (endTime * SamplingRate).Ceil();
+        int endPosition = (endTime * SampleRate.Value).Ceil();
         float[] buffer = new float[isStereo ? endPosition * 2 : endPosition];
         AudioGraph.MixData(0, endPosition, isStereo, buffer, 0);
-        AudioUtils.EncodeToWav(filePath, buffer, SamplingRate, 16, isStereo ? 2 : 1);
+        AudioUtils.EncodeToWav(filePath, buffer, SampleRate.Value, 16, isStereo ? 2 : 1);
     }
 
     public static void InvokeRealtimeAmplitude(IAudioTrack track,out Tuple<double,double>? amplitude)
@@ -121,7 +148,7 @@ double Amplitude2Db(double amplitude)
         {
             int sampleWindow = 64;
             float[] buffer = new float[sampleWindow * 2];
-            int position = (CurrentTime * SamplingRate).Ceil();
+            int position = (CurrentTime * SampleRate.Value).Ceil();
             AudioGraph.AddData(track, position, position + sampleWindow, true, buffer, 0);
             for (int i = 0; i < sampleWindow * 2; i += 2) { amp[0] = (float)Math.Max(amp[0], Sample2Amplitude(buffer[i])); amp[1] = (float)Math.Max(amp[1], Sample2Amplitude(buffer[i + 1])); };
         }
@@ -133,6 +160,7 @@ double Amplitude2Db(double amplitude)
 
     public static void LoadKeySamples(string path)
     {
+        mKeySamplesPath = path;
         try
         {
             mKeySamples.Fill(null);
@@ -149,8 +177,8 @@ public static void LoadKeySamples(string path)
                     {
                         try
                         {
-                            int samplingRate = SamplingRate;
-                            var data = AudioUtils.Decode(file, ref samplingRate);
+                            int sampleRate = SampleRate.Value;
+                            var data = AudioUtils.Decode(file, ref sampleRate);
                             switch (data.Length)
                             {
                                 case 1:
@@ -194,17 +222,67 @@ static void OnProgressChanged()
             Pause();
     }
 
-    class AudioProvider(int samplingRate) : IAudioProvider
+    static void OnSampleRateModified()
+    {
+        mAudioSampleProvider.SampleRate = SampleRate.Value;
+        if (mAudioPlaybackHandler != null)
+            mAudioPlaybackHandler.SampleRate = SampleRate.Value;
+        if (mKeySamplesPath != null)
+            LoadKeySamples(mKeySamplesPath);
+    }
+
+    static void OnBufferSizeModified()
+    {
+        if (mAudioPlaybackHandler != null)
+            mAudioPlaybackHandler.BufferSize = BufferSize.Value;
+    }
+
+    static void OnCurrentDriverModified()
+    {
+        SetDriverToPlaybackHandler(); 
+        SetDeviceToPlaybackHandler();
+        mAudioPlaybackHandler?.Start();
+    }
+
+    static void OnCurrentDeviceModified()
     {
-        public int SamplingRate => mAudioGraph.SamplingRate;
-        public int ChannelCount => 2;
-        public int SamplesPerChannel => int.MaxValue;
+        SetDeviceToPlaybackHandler();
+        mAudioPlaybackHandler?.Start();
+    }
+
+    static void SetDriverToPlaybackHandler()
+    {
+        var drivers = mAudioPlaybackHandler!.GetAllDrivers();
+        if (drivers.IsEmpty())
+            return;
 
+        var driver = drivers.Contains(CurrentDriver.Value) ? CurrentDriver.Value : drivers[0];
+        if (mAudioPlaybackHandler.CurrentDriver != driver)
+            mAudioPlaybackHandler.CurrentDriver = driver;
+
+        CurrentDriver.Value = mAudioPlaybackHandler.CurrentDriver;
+    }
+
+    static void SetDeviceToPlaybackHandler()
+    {
+        var devices = mAudioPlaybackHandler!.GetAllDevices();
+        if (devices.IsEmpty())
+            return;
+
+        var device = devices.Contains(CurrentDevice.Value) ? CurrentDevice.Value : devices[0];
+        if (mAudioPlaybackHandler.CurrentDevice != device)
+            mAudioPlaybackHandler.CurrentDevice = device;
+
+        CurrentDevice.Value = mAudioPlaybackHandler.CurrentDevice;
+    }
+
+    class AudioSampleProvider() : IAudioSampleProvider
+    {
         public AudioGraph AudioGraph => mAudioGraph;
         public AudioPlayer AudioPlayer => mAudioPlayer;
-
+        public int SampleRate { get => mAudioGraph.SampleRate; set => mAudioGraph.SampleRate = value; }
         public bool IsPlaying {  get; set; }
-        public double CurrentTime => (double)mGraphPosition / SamplingRate;
+        public double CurrentTime => (double)mGraphPosition / SampleRate;
 
         public void Read(float[] buffer, int offset, int count)
         {
@@ -239,20 +317,21 @@ public void Seek(double time)
         {
             lock (mSeekLockObject)
             {
-                mGraphPosition = (int)(time * SamplingRate);
+                mGraphPosition = (int)(time * SampleRate);
             }
         }
 
         readonly AudioPlayer mAudioPlayer = new();
-        readonly AudioGraph mAudioGraph = new(samplingRate);
+        readonly AudioGraph mAudioGraph = new();
         int mGraphPosition = 0;
         readonly object mSeekLockObject = new();
     }
 
     static IAudioPlaybackHandler? mAudioPlaybackHandler;
-    static AudioProvider? mAudioProvider;
-    static AudioGraph AudioGraph => mAudioProvider!.AudioGraph;
-    static AudioPlayer AudioPlayer => mAudioProvider!.AudioPlayer;
+    static AudioSampleProvider mAudioSampleProvider = new();
+    static AudioGraph AudioGraph => mAudioSampleProvider.AudioGraph;
+    static AudioPlayer AudioPlayer => mAudioSampleProvider.AudioPlayer;
 
     static readonly IAudioData?[] mKeySamples = new IAudioData?[MusicTheory.PITCH_COUNT];
+    static string? mKeySamplesPath = null;
 }

TuneLab/Audio/AudioGraph.cs

@@ -6,9 +6,26 @@
 
 namespace TuneLab.Audio;
 
-internal class AudioGraph(int samplingRate = 44100)
+internal class AudioGraph()
 {
-    public int SamplingRate => samplingRate;
+    public int SampleRate 
+    {
+        get => mSampleRate;
+        set
+        {
+            mSampleRate = value;
+            lock (mTrackLockObject)
+            {
+                foreach (var track in mTracks)
+                {
+                    foreach (var audioSource in track.AudioSources)
+                    {
+                        audioSource.OnSampleRateChanged();
+                    }
+                }
+            }
+        }
+    }
 
     public IReadOnlyCollection<IAudioTrack> Tracks => mTracks;
 
@@ -36,7 +53,7 @@ public void AddData(IAudioTrack track, int position, int endPosition, bool isSte
         float rightVolume = (float)(volume * (1 + pan));
         foreach (var audioSource in track.AudioSources)
         {
-            int audioSourceStart = (int)(audioSource.StartTime * SamplingRate);
+            int audioSourceStart = (int)(audioSource.StartTime * SampleRate);
             int audioSourceEnd = audioSourceStart + audioSource.SampleCount;
             if (audioSourceEnd < position)
                 continue;
@@ -106,7 +123,7 @@ public double EndTime
         }
     }
 
-
+    int mSampleRate = 44100;
     List<IAudioTrack> mTracks = [];
 
     readonly object mTrackLockObject = new();