com.adrenak.univoice 4.5.0 → 4.6.0

package/Runtime/ClientSession.cs

@@ -1,21 +1,92 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 using UnityEngine;
 
 namespace Adrenak.UniVoice {
     /// <summary>
     /// Handles a client session. 
-    /// Requires an implementation of <see cref="IAudioClient{T}"/>, <see cref="IAudioInput"/> and <see cref="IAudioOutputFactory"/> each.
-    /// Allows adding input and output filters and handles their execution.
+    /// Requires implementations of <see cref="IAudioClient{T}"/>, <see cref="IAudioInput"/> and <see cref="IAudioOutput"/>.
+    /// Handles input, output along with filters over the entire client lifecycle.
+    /// Adjusts to changes in configuration at runtime.
     /// </summary>
     /// <typeparam name="T"></typeparam>
     public class ClientSession<T> : IDisposable {
+        /// <summary>
+        /// Represents a filter registered in the session.
+        /// Currently used only for output filters.
+        /// </summary>
+        class FilterFactoryEntry {
+            public Type FilterType { get; }
+            public Func<IAudioFilter> Factory { get; }
+
+            public FilterFactoryEntry(Type filterType, Func<IAudioFilter> factory) {
+                FilterType = filterType;
+                Factory = factory;
+            }
+        }
+
+        #region AUDIO OUTPUT 
+
+        List<FilterFactoryEntry> outputFilterFactories = new List<FilterFactoryEntry>();
+        Dictionary<T, List<IAudioFilter>> peerOutputFilters = new Dictionary<T, List<IAudioFilter>>();
+
+        /// <summary>
+        /// Whether any incoming audio from peers would be processed. If set to false, all incoming peer audio is ignored, and would
+        /// neither be processed by the <see cref="OutputFilters"/> nor output to the <see cref="IAudioOutput"/> of any peer.
+        /// This can be used to easily mute all the peers on the network.
+        /// Note that this doesn't stop the audio data from arriving and would consume bandwidth. To stop reception completely
+        /// by telling the server to not send audio, use <see cref="IAudioClient{T}.YourVoiceSettings"/>
+        /// </summary>
+        public bool OutputsEnabled { get; set; } = true;
+
         /// <summary>
         /// The <see cref="IAudioOutput"/> instances of each peer in the session
         /// </summary>
         public Dictionary<T, IAudioOutput> PeerOutputs { get; private set; } = new Dictionary<T, IAudioOutput>();
 
+        /// <summary>
+        /// Adds an filter to the output audio. Note: it is possible to register the same
+        /// filter type more than once, this can be used to create some effects but can also cause
+        /// errors.
+        /// </summary>
+        /// <typeparam name="TFilter">The type of the filter to be added</typeparam>
+        /// <param name="filterFactory">A lambda method that returns an instance of the filter type</param>
+        public void AddOutputFilter<TFilter>(Func<IAudioFilter> filterFactory)
+        where TFilter : IAudioFilter {
+            outputFilterFactories.Add(new FilterFactoryEntry(typeof(TFilter), filterFactory));
+
+            foreach (var peerFilters in peerOutputFilters.Values)
+                peerFilters.Add(filterFactory());
+        }
+
+        /// <summary>
+        /// Checks if an output audio filter of a specific type has been registered.
+        /// </summary>
+        /// <typeparam name="TFilter">The type of the filter to check</typeparam>
+        /// <returns>True if the filter is registered, false otherwise</returns>
+        public bool HasOutputFilter<TFilter>()
+            where TFilter : IAudioFilter {
+            return outputFilterFactories.Any(entry => entry.FilterType == typeof(TFilter));
+        }
+
+        /// <summary>
+        /// Removes a previously registered output audio filter
+        /// </summary>
+        /// <typeparam name="TFilter">The type of the filter to be removed</typeparam>
+        public void RemoveOutputFilter<TFilter>()
+        where TFilter : IAudioFilter {
+            outputFilterFactories.RemoveAll(entry => entry.FilterType == typeof(TFilter));
+
+            foreach (var peerFilters in peerOutputFilters.Values)
+                peerFilters.RemoveAll(f => f.GetType() == typeof(TFilter));
+        }
+
+        #endregion
+
+        #region AUDIO INPUT
+
         /// <summary>
         /// Whether input audio will be processed. If set to false, any input audio captured by 
         /// <see cref="Input"/> would be ignored and would neither be processed by the <see cref="InputFilters"/> nor send via the <see cref="Client"/>
@@ -24,25 +95,28 @@ namespace Adrenak.UniVoice {
         public bool InputEnabled { get; set; } = true;
 
         /// <summary>
-        /// Whether any incoming audio from peers would be processed. If set to false, all incoming peer audio is ignored, and would
-        /// neither be processed by the <see cref="OutputFilters"/> nor outputted to the <see cref="IAudioOutput"/> of any peer.
-        /// This can be used to easily mute all the peers on the network.
-        /// Note that this doesn't stop the audio data from arriving and would consume bandwidth. Do stop reception completely
-        /// use <see cref="IAudioClient{T}.YourVoiceSettings"/>
-        /// </summary>
-        public bool OutputsEnabled { get; set; } = true;
-
-        /// <summary>
-        /// The input <see cref="IAudioFilter"/> that will be applied to the outgoing audio for all the peers.
+        /// The <see cref="IAudioFilter"/> that will be applied to the outgoing audio for all the peers.
         /// Note that filters are executed in the order they are present in this list
         /// </summary>
         public List<IAudioFilter> InputFilters { get; set; } = new List<IAudioFilter>();
 
         /// <summary>
-        /// The output <see cref="IAudioFilter"/> that will be applied to the incoming audio for all the peers.
-        /// Note that filters are executed in the order they are present in this list.
+        /// Checks if an input audio filter of a specific type has been registered.
         /// </summary>
-        public List<IAudioFilter> OutputFilters { get; set; } = new List<IAudioFilter>();
+        /// <typeparam name="TFilter">The type of the filter to check</typeparam>
+        /// <returns>True if the filter is registered, false otherwise</returns>
+        public bool HasInputFilter<TFilter>()
+            where TFilter : IAudioFilter {
+            return InputFilters.Any(filter => filter.GetType() == typeof(TFilter));
+        }
+
+        #endregion
+
+        public ClientSession(IAudioClient<T> client, IAudioInput input, Func<IAudioOutput> outputProvider) {
+            Client = client;
+            Input = input;
+            OutputProvider = outputProvider;
+        }
 
         public ClientSession(IAudioClient<T> client, IAudioInput input, IAudioOutputFactory outputFactory) {
             Client = client;
@@ -57,7 +131,7 @@ namespace Adrenak.UniVoice {
         public IAudioClient<T> Client {
             get => client;
             set {
-                if(client != null)
+                if (client != null)
                     client.Dispose();
                 client = value;
 
@@ -65,12 +139,24 @@ namespace Adrenak.UniVoice {
                     foreach (var output in PeerOutputs)
                         output.Value.Dispose();
                     PeerOutputs.Clear();
+                    peerOutputFilters.Clear();
                 };
 
                 Client.OnPeerJoined += id => {
                     try {
-                        var output = outputFactory.Create();
-                        PeerOutputs.Add(id, output);
+                        if (OutputProvider != null) {
+                            var output = OutputProvider();
+                            PeerOutputs.Add(id, output);
+                        }
+                        else if (OutputFactory != null) {
+                            var output = OutputFactory.Create();
+                            PeerOutputs.Add(id, output);
+                        }
+
+                        var filters = outputFilterFactories
+                            .Select(entry => entry.Factory())
+                            .ToList();
+                        peerOutputFilters.Add(id, filters);
                     }
                     catch (Exception e) {
                         Debug.LogException(e);
@@ -78,26 +164,27 @@ namespace Adrenak.UniVoice {
                 };
 
                 Client.OnPeerLeft += id => {
-                    if (!PeerOutputs.ContainsKey(id)) 
-                        return;
+                    if (PeerOutputs.ContainsKey(id)) {
+                        PeerOutputs[id].Dispose();
+                        PeerOutputs.Remove(id);
+                    }
 
-                    PeerOutputs[id].Dispose();
-                    PeerOutputs.Remove(id);
+                    if (peerOutputFilters.ContainsKey(id)) {
+                        peerOutputFilters.Remove(id);
+                    }
                 };
 
                 Client.OnReceivedPeerAudioFrame += (id, audioFrame) => {
-                    if (!OutputsEnabled)
+                    if (!OutputsEnabled || !PeerOutputs.ContainsKey(id))
                         return;
 
-                    if (!PeerOutputs.ContainsKey(id))
-                        return;
-
-                    if (OutputFilters != null) {
-                        foreach (var filter in OutputFilters)
+                    if (peerOutputFilters.TryGetValue(id, out var filters)) {
+                        foreach (var filter in filters)
                             audioFrame = filter.Run(audioFrame);
                     }
-                    if(audioFrame.samples.Length > 0)
-                        PeerOutputs[id].Feed(audioFrame);
+
+                    if (audioFrame.samples.Length > 0)
+                        PeerOutputs[id]?.Feed(audioFrame);
                 };
             }
         }
@@ -109,11 +196,11 @@ namespace Adrenak.UniVoice {
         public IAudioInput Input {
             get => input;
             set {
-                if(input != null)
+                if (input != null)
                     input.Dispose();
                 input = value;
                 input.OnFrameReady += frame => {
-                    if (!InputEnabled) 
+                    if (!InputEnabled)
                         return;
 
                     if (InputFilters != null) {
@@ -121,12 +208,44 @@ namespace Adrenak.UniVoice {
                             frame = filter.Run(frame);
                     }
 
-                    if(frame.samples.Length > 0)
+                    if (frame.samples.Length > 0)
                         Client.SendAudioFrame(frame);
                 };
             }
         }
 
+        Func<IAudioOutput> outputProvider;
+        /// <summary>
+        /// The provider of IAudioOutput objects for peers.
+        /// If this value is being set while peers already exist,
+        /// the old outputs would be cleared and new onces will 
+        /// be created.
+        /// </summary>
+        public Func<IAudioOutput> OutputProvider {
+            get => outputProvider;
+            set {
+                outputProvider = value;
+                outputFactory = null;
+
+                foreach (var output in PeerOutputs)
+                    output.Value.Dispose();
+                PeerOutputs.Clear();
+
+                if(outputProvider != null) {
+                    foreach (var id in Client.PeerIDs) {
+                        try {
+                            var output = outputProvider();
+                            PeerOutputs.Add(id, output);
+                        }
+                        catch (Exception e) {
+                            Debug.LogException(e);
+                        }
+                    }
+                }
+            }
+        }
+
+
         IAudioOutputFactory outputFactory;
         /// <summary>
         /// The <see cref="IAudioOutputFactory"/> that creates the <see cref="IAudioOutput"/> of peers
@@ -135,18 +254,21 @@ namespace Adrenak.UniVoice {
             get => outputFactory;
             set {
                 outputFactory = value;
+                outputProvider = null;
 
                 foreach (var output in PeerOutputs)
                     output.Value.Dispose();
                 PeerOutputs.Clear();
 
-                foreach (var id in Client.PeerIDs) {
-                    try {
-                        var output = outputFactory.Create();
-                        PeerOutputs.Add(id, output);
-                    }
-                    catch (Exception e) {
-                        Debug.LogException(e);
+                if (outputFactory != null) {
+                    foreach (var id in Client.PeerIDs) {
+                        try {
+                            var output = outputFactory.Create();
+                            PeerOutputs.Add(id, output);
+                        }
+                        catch (Exception e) {
+                            Debug.LogException(e);
+                        }
                     }
                 }
             }
@@ -156,5 +278,16 @@ namespace Adrenak.UniVoice {
             Client.Dispose();
             Input.Dispose();
         }
+
+        #region OBSOLETE
+
+        /// <summary>
+        /// The output <see cref="IAudioFilter"/> that will be applied to the incoming audio for all the peers.
+        /// Note that filters are executed in the order they are present in this list.
+        /// </summary>
+        [Obsolete("OutputFilters has been removed. Use AddOutputFilter and RemoveOutputFilter instead.", true)]
+        public List<IAudioFilter> OutputFilters { get; set; } = new List<IAudioFilter>();
+
+        #endregion
     }
 }

package/Runtime/Impl/Networks/Mirror/MirrorModeObserver.cs

@@ -40,7 +40,7 @@ namespace Adrenak.UniVoice.Networks {
                     ModeChanged?.Invoke(lastMode, newMode);
                 }
                 catch (Exception e) {
-                    Debug.Log(LogType.Error, TAG, "Exception while handling Mirror Mode change: " + e);
+                    Debug.unityLogger.Log(LogType.Error, TAG, "Exception while handling Mirror Mode change: " + e);
                 }
                 lastMode = newMode;
             }

package/Runtime/Impl/Outputs/StreamedAudioSourceOutput.cs

@@ -33,7 +33,7 @@ namespace Adrenak.UniVoice.Outputs {
         /// </summary>
         /// <param name="frame"></param>
         public void Feed(AudioFrame frame) {
-            Stream.Feed(frame.frequency, frame.channelCount, Utils.Bytes.BytesToFloats(frame.samples), true);
+            Stream.Feed(frame.frequency, frame.channelCount, Utils.Bytes.BytesToFloats(frame.samples));
         }
 
         /// <summary>

package/Samples~/Basic Setup Scripts/UniVoiceMirrorSetupSample.cs

@@ -185,7 +185,7 @@ namespace Adrenak.UniVoice.Samples {
                 Debug.unityLogger.Log(LogType.Log, TAG, "Registered ConcentusEncodeFilter as an input filter");
 
                 // For incoming audio register the ConcentusDecodeFilter to decode the encoded audio received from other clients 
-                ClientSession.OutputFilters.Add(new ConcentusDecodeFilter());
+                ClientSession.AddOutputFilter<ConcentusDecodeFilter>(() => new ConcentusDecodeFilter());
                 Debug.unityLogger.Log(LogType.Log, TAG, "Registered ConcentusDecodeFilter as an output filter");
             }
 

package/Samples~/Group Chat Sample/Scripts/GroupVoiceCallMirrorSample.cs

@@ -89,7 +89,7 @@ namespace Adrenak.UniVoice.Samples {
 
             // Next, for incoming audio we register the Concentus decode filter as the audio we'd
             // receive from other clients would be encoded and not readily playable
-            session.OutputFilters.Add(new ConcentusDecodeFilter());
+            session.AddOutputFilter<ConcentusDecodeFilter>(() => new ConcentusDecodeFilter());
 
             // Subscribe to some server events 
             server.OnServerStart += () => {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "com.adrenak.univoice",
-    "version": "4.5.0",
+    "version": "4.6.0",
     "displayName": "Adrenak.UniVoice",
     "description": "Voice chat/VoIP framework for Unity.",
     "unity": "2021.2",
@@ -33,7 +33,7 @@
 	],
     "dependencies": {
         "com.adrenak.brw": "1.0.1",
-        "com.adrenak.unimic": "3.2.4",
+        "com.adrenak.unimic": "3.3.0",
         "com.adrenak.concentus-unity": "1.0.1"
     }
 }