com.adrenak.univoice 4.5.1 → 4.7.0

package/README.md

@@ -4,7 +4,16 @@ UniVoice is a voice chat/VoIP solution for Unity.
 Some features of UniVoice:
 - 👥 Group voice chat. Multiple peers can join a chatroom and exchange audio.  
 
-- ⚙ Peer specific settings. Don't want to listen to a peer? Mute them. Don't want someone listening to you? Deafen them.  
+- ⚙ Fine control over audio data flow. 
+    * Don't want to listen to a peer? Mute them. Don't want someone listening to you? Deafen them.  
+    * Group players using tags and control audio flow between them. For example:
+        - "red", "blue" and "spectator" tags for two teams playing against each other.
+            - Red and Blue teams can only hear each other
+            - Spectators can hear everyone
+        - clients with "contestant", "judge" and "audience" tags for a virtual talent show. 
+            - Contestant can be heard by everyone, but don't hear anyone else (for focus) 
+            - Judges can talk to and hear each other for discussions. They can hear the contestant. But not the audience (for less noise)
+            - Audience can hear and talk to each other. They can hear the performer. But they cannot hear the judges.
  
 - 🎨 Customize your audio input, output and networking layers. 
   * 🌐 __Configurable Network__: 

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/FakeNetwork.cs

@@ -0,0 +1,6 @@
+namespace Adrenak.UniVoice.Networks {
+    // Just an empty client to make sure that there's always
+    // an Adrenak.UniVoice.Networks namespace even if there's
+    // no network implementation in the project
+    public class FakeNetwork { }
+}

package/Runtime/Impl/Networks/FakeNetwork.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: af0bac6bd02832141b9897cc6b24529b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -171,6 +171,10 @@ namespace Adrenak.UniVoice.Networks {
             writer.WriteIntArray(YourVoiceSettings.mutedPeers.ToArray());
             writer.WriteInt(YourVoiceSettings.deafenAll ? 1 : 0);
             writer.WriteIntArray(YourVoiceSettings.deafenedPeers.ToArray());
+            writer.WriteString(string.Join(",", YourVoiceSettings.myTags));
+            writer.WriteString(string.Join(",", YourVoiceSettings.mutedTags));
+            writer.WriteString(string.Join(",", YourVoiceSettings.deafenedTags));
+
             var message = new MirrorMessage {
                 data = writer.Bytes
             };

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

@@ -1,4 +1,4 @@
-// Notes:
+// Notes:
 // In Mirror 89.11.0, the OnServerConnectedWithAddress event was added
 // https://github.com/MirrorNetworking/Mirror/releases/tag/v89.11.0
 // OnServerConnected no longer seems to work?
@@ -106,37 +106,61 @@ namespace Adrenak.UniVoice.Networks {
             var reader = new BytesReader(message.data);
             var tag = reader.ReadString();
 
+            // Server forwards the received audio from a client to other clients based on voice settings.
+            // Client can mute or deafen each other using IDs as well as tags
             if (tag.Equals(MirrorMessageTags.AUDIO_FRAME)) {
                 // We start with all the peers except the one that's
                 // sent the audio 
                 var peersToForwardAudioTo = ClientIDs
                     .Where(x => x != clientId);
 
-                // Consider the voice settings of the sender to see who
-                // the sender doesn't want to send audio to
+                // Check the voice settings of the sender and eliminate any peers the sender
+                // may have deafened
                 if (ClientVoiceSettings.TryGetValue(clientId, out var senderSettings)) {
-                    // If the client sending the audio has deafened everyone
-                    // to their audio, we simply return
+                    // If the client sending the audio has deafened everyone,
+                    // we simply return. Sender's audio should not be forwarded to anyone.
                     if (senderSettings.deafenAll)
                         return;
 
-                    // Else, we remove all the peers that the sender has
-                    // deafened themselves to
+                    // Filter the recipient list by removing all peers that the sender has
+                    // deafened using ID
                     peersToForwardAudioTo = peersToForwardAudioTo
                         .Where(x => !senderSettings.deafenedPeers.Contains(x));
+
+                    // Further filter the recipient list by removing peers that the sender has
+                    // deafened using tags
+                    peersToForwardAudioTo = peersToForwardAudioTo.Where(peer => {
+                        // Get the voice settings of the peer
+                        if (ClientVoiceSettings.TryGetValue(peer, out VoiceSettings peerVoiceSettings)) {
+                            // Check if sender has not deafened peer using tag
+                            var hasDeafenedPeer = senderSettings.deafenedTags.Intersect(peerVoiceSettings.myTags).Count() > 0;
+                            return !hasDeafenedPeer;
+                        }
+                        // If peer doesn't have voice settings, we can keep the peer in the list
+                        else {
+                            return true;
+                        }
+                    });
                 }
 
-                // We iterate through each recipient peer that the sender wants to send
-                // audio to, checking if they have muted the sender in which case
-                // we skip that recipient
-                foreach (var receiver in peersToForwardAudioTo) {
-                    if (ClientVoiceSettings.TryGetValue(receiver, out var receiverSettings)) {
-                        if (receiverSettings.muteAll)
+                // We iterate through each recipient peer that the sender wants to send audio to, checking if
+                // they have muted the sender, before forwarding the audio to them.
+                foreach (var recipient in peersToForwardAudioTo) {
+                    // Get the settings of a potential recipient
+                    if (ClientVoiceSettings.TryGetValue(recipient, out var recipientSettings)) {
+                        // If a peer has muted everyone, don't send audio
+                        if (recipientSettings.muteAll)
                             continue;
-                        if (receiverSettings.mutedPeers.Contains(clientId))
+
+                        // If the peers has muted the sender using ID, skip sending audio
+                        if (recipientSettings.mutedPeers.Contains(clientId))
+                            continue;
+
+                        // If the peer has muted the sender using tag, skip sending audio
+                        if (recipientSettings.mutedTags.Intersect(senderSettings.myTags).Count() > 0)
                             continue;
                     }
-                    SendToClient(receiver, message.data, Channels.Unreliable);
+                    SendToClient(recipient, message.data, Channels.Unreliable);
                 }
             }
             else if (tag.Equals(MirrorMessageTags.VOICE_SETTINGS)) {
@@ -147,11 +171,18 @@ namespace Adrenak.UniVoice.Networks {
                 var mutedPeers = reader.ReadIntArray().ToList();
                 var deafenAll = reader.ReadInt() == 1 ? true : false;
                 var deafenedPeers = reader.ReadIntArray().ToList();
+                var myTags = reader.ReadString().Split(",").ToList();
+                var mutedTags = reader.ReadString().Split(",").ToList();
+                var deafenedTags = reader.ReadString().Split(",").ToList();
+
                 var voiceSettings = new VoiceSettings {
                     muteAll = muteAll,
                     mutedPeers = mutedPeers,
                     deafenAll = deafenAll,
-                    deafenedPeers = deafenedPeers
+                    deafenedPeers = deafenedPeers,
+                    myTags = myTags,
+                    mutedTags = mutedTags,
+                    deafenedTags = deafenedTags
                 };
                 if (ClientVoiceSettings.ContainsKey(clientId))
                     ClientVoiceSettings[clientId] = voiceSettings;

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/Runtime/Types/VoiceSettings.cs

@@ -22,6 +22,26 @@ namespace Adrenak.UniVoice {
         /// </summary>
         public List<int> deafenedPeers = new List<int>();
 
+        /// <summary>
+        /// The tags associated with this client.
+        /// DO NOT USE COMMAS (,)
+        /// </summary>
+        public List<string> myTags = new List<string>();
+
+        /// <summary>
+        /// The tags, which if associated with a peer, would cause
+        /// those the audio of that peer to not be send to this peer
+        /// DO NOT USE COMMAS (,)
+        /// </summary>
+        public List<string> mutedTags = new List<string>();
+
+        /// <summary>
+        /// The tags, which if associated with a peer, would cause
+        /// those peers to not receive audio from this client
+        /// DO NOT USE COMMAS (,)
+        /// </summary>
+        public List<string> deafenedTags = new List<string>();
+
         /// <summary>
         /// Sets the deaf status of a peer
         /// </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.1",
+    "version": "4.7.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"
     }
 }