Add a class for fading

(we don't have to implement this multiple times)

Vocaluxe/Lib/Sound/CGstreamerSharpAudio.cs

@@ -20,8 +20,8 @@ using System.Collections.Generic;
 using Gst;
 using GLib;
 using System.Runtime.InteropServices;
-using System.Diagnostics;
 using Vocaluxe.Base;
+using VocaluxeLib;
 using Thread = System.Threading.Thread;
 
 namespace Vocaluxe.Lib.Sound
@@ -213,18 +213,21 @@ namespace Vocaluxe.Lib.Sound
 
         private class CGstreamerSharpAudioStream
         {
+            private enum EStreamAction
+            {
+                Nothing,
+                Pause,
+                Stop,
+                Close
+            }
+
             private Element _Element;
             private bool _Loop;
             public volatile bool Closed = true;
             public volatile bool Finished;
 
-            private bool _Fading;
+            private CFading _Fading;
-            private bool _CloseStreamAfterFade;
+            private EStreamAction _AfterFadeAction;
-            private bool _PauseStreamAfterFade;
-            private bool _StopStreamAfterFade;
-            private readonly Stopwatch _FadeTimer = new Stopwatch();
-            private float _FadeTime;
-            private float _FadeVolume;
             private float _Volume = 1f;
 
             private float _MaxVolume = 1f;
@@ -358,28 +361,26 @@ namespace Vocaluxe.Lib.Sound
 
             public void Fade(float targetVolume, float seconds)
             {
-                _Fading = true;
+                _Fading = new CFading(_Volume, targetVolume, seconds);
-                _FadeTimer.Restart();
+                _AfterFadeAction = EStreamAction.Nothing;
-                _FadeTime = seconds;
-                _FadeVolume = targetVolume;
             }
 
             public void FadeAndPause(float targetVolume, float seconds)
             {
                 Fade(targetVolume, seconds);
-                _PauseStreamAfterFade = true;
+                _AfterFadeAction = EStreamAction.Pause;
             }
 
             public void FadeAndClose(float targetVolume, float seconds)
             {
                 Fade(targetVolume, seconds);
-                _CloseStreamAfterFade = true;
+                _AfterFadeAction = EStreamAction.Close;
             }
 
             public void FadeAndStop(float targetVolume, float seconds)
             {
                 Fade(targetVolume, seconds);
-                _StopStreamAfterFade = true;
+                _AfterFadeAction = EStreamAction.Stop;
             }
 
             public float Volume
@@ -460,25 +461,25 @@ namespace Vocaluxe.Lib.Sound
                 while (_Element != null && _Element.Bus != null && _Element.Bus.HavePending())
                     _OnMessage(_Element.Bus.Pop());
 
-                if (_Fading)
+                if (_Fading != null)
                 {
-                    if (_FadeTimer.ElapsedMilliseconds < (_FadeTime * 1000f))
+                    bool finished;
-                        Volume = ((_FadeTimer.ElapsedMilliseconds) / (_FadeTime * 1000f)) * _FadeVolume;
+                    Volume = _Fading.GetValue(out finished);
-                    else
+                    if (finished)
                     {
-                        Volume = _FadeVolume;
+                        switch (_AfterFadeAction)
-                        if (_CloseStreamAfterFade)
+                        {
-                            Close();
+                            case EStreamAction.Pause:
-                        if (_PauseStreamAfterFade)
+                                Paused = true;
-                            Paused = true;
+                                break;
-                        if (_StopStreamAfterFade)
+                            case EStreamAction.Stop:
-                            Stop();
+                                Stop();
-
+                                break;
-                        _CloseStreamAfterFade = false;
+                            case EStreamAction.Close:
-                        _PauseStreamAfterFade = false;
+                                Close();
-                        _StopStreamAfterFade = false;
+                                break;
-                        _Fading = false;
+                        }
-                        _FadeTimer.Reset();
+                        _Fading = null;
                     }
                 }
             }

VocaluxeLib/CFading.cs

@@ -0,0 +1,64 @@
+#region license
+// This file is part of Vocaluxe.
+// 
+// Vocaluxe is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// Vocaluxe is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with Vocaluxe. If not, see <http://www.gnu.org/licenses/>.
+#endregion
+
+using System.Diagnostics;
+
+namespace VocaluxeLib
+{
+    public class CFading
+    {
+        private readonly float _FromValue;
+        private readonly float _ToValue;
+        private readonly float _Duration; //in ms
+        private readonly Stopwatch _Timer = new Stopwatch();
+
+        /// <summary>
+        ///     Starts a fading process adjusting between 2 values over a given amount of time
+        /// </summary>
+        /// <param name="fromValue">Start value</param>
+        /// <param name="toValue">Target value</param>
+        /// <param name="duration">Duration of the fading in seconds</param>
+        public CFading(float fromValue, float toValue, float duration)
+        {
+            _FromValue = fromValue;
+            _ToValue = toValue;
+            _Duration = duration * 1000f;
+            _Timer.Start();
+        }
+
+        /// <summary>
+        /// Gets the current value and sets finished
+        /// </summary>
+        /// <param name="finished">Set to whether fading has finished</param>
+        /// <returns>Current value (between from and to values)</returns>
+        public float GetValue(out bool finished)
+        {
+            float result;
+            if (_Timer.ElapsedMilliseconds < _Duration)
+            {
+                result = (_Timer.ElapsedMilliseconds / _Duration) * (_ToValue - _FromValue) + _FromValue;
+                finished = false;
+            }
+            else
+            {
+                result = _ToValue;
+                finished = true;
+            }
+            return result;
+        }
+    }
+}

VocaluxeLib/VocaluxeLib.csproj

@@ -130,6 +130,7 @@
     <Reference Include="System.XML" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="CFading.cs" />
     <Compile Include="Extensions.cs" />
     <Compile Include="GlobalSuppressions.cs" />
     <Compile Include="IBasic.cs" />