com.adrenak.univoice 3.0.0 → 4.1.0

package/README.md

@@ -1,5 +1,3 @@
-Note: Inbuilt implementations and samples have been removed from this repository. They'll be added to separate repositories soon.
-
 # UniVoice
 UniVoice is a voice chat/VoIP solution for Unity.
   
@@ -9,76 +7,60 @@ Some features of UniVoice:
 - ⚙ Peer specific settings. Don't want to listen to a peer? Mute them. Don't want someone listening to you? Mute yourself against them.
  
 - 🎨 Customize your audio input, output and networking layer. 
-  * 🎤 __Configurable Audio Input__: Decide what the input of your outgoing audio is. Let it be from [Unity's Microphone](https://docs.unity3d.com/ScriptReference/Microphone.html) class, or a live streaming audio, or an MP4 file on the disk.
+  * 🎤 __Configurable Audio Input__: UniVoice is audio input agnostic. It supports mic audio input out of the box and you can change the source of outgoing audio by implementing the `IAudioInput` interrace.  
     
-  * 🔊 __Configurable Audio Output__:  Decide where the incoming peer audio goes. Let the output of incoming audio be [Unity AudioSource](https://docs.unity3d.com/ScriptReference/AudioSource.html) to play the audio in-game, or write it into an MP4 on the disk, or stream it to an online service.
+  * 🔊 __Configurable Audio Output__:  UniVoice is audio output agnostic. Out of the box is supports playing peer audio using Unity AudioSource. You can divert incoming audio to anywhere you want by implementing the `IAudioOutput` interface.  
 
-  * 🌐 __Configurable Network__: Want to use UniVoice in a WLAN project using [Telepathy?](https://github.com/vis2k/Telepathy) Just adapt its API for UniVoice with a simple the `IChatroomNetwork` interface. Using your own backend for multiplayer? Create and expose your audio API and write a UniVoice implementation, again with the same interface.
-  
-# Docs
-Manuals and sample projects are not available yet. For the API reference, please visit http://www.vatsalambastha.com/univoice
-  
-# Usage
-## Creating a chatroom agent
-- To be able to host and join voice chatrooms, you need a `ChatroomAgent` instance.
+  * 🌐 __Configurable Network__: UniVoice is network agnostic and supports Mirror out of the box. You can implement the `IAudioClient` and `IAudioServer` interfaces using the networking plugin of your choice to make it compatible with it.
+
+  * ✏️ __Audio Filters__: Modify outgoing and incoming audio by implementing the `IAudioFilter` interface. Gaussian blurring for denoising and Opus (Concentus) encoding & decoding for lower bandwidth consumption are provided out of the box.
   
+## Installation
+⚠️ [OpenUPM](https://openupm.com/packages/com.adrenak.univoice/?subPage=versions) may not have up to date releases. Install using NPM registry instead 👇
+
+Ensure you have the NPM registry in the `manifest.json` file of your Unity project with the following scopes:
 ```
-var agent = new ChatroomAgent(IChatroomNetwork network, IAudioInput audioInput, IAudioOutput audioOutput);
+"scopedRegistries": [
+    {
+        "name": "npmjs",
+        "url": "https://registry.npmjs.org",
+        "scopes": [
+            "com.npmjs",
+            "com.adrenak.univoice",
+            "com.adrenak.brw",
+            "com.adrenak.unimic",
+            "com.adrenak.concentus-unity"
+        ]
+    }
+}
 ```
+Then add `com.adrenak.univoice:x.y.z` to the `dependencies` in your `manifest.json` file (where x.y.z is the version you wish to install). The list of versions is available on [the UniVoice NPM page](https://www.npmjs.com/package/com.adrenak.univoice?activeTab=versions).
 
-## Hosting and joining chatrooms
+## Docs
+Am API reference is available: http://www.vatsalambastha.com/univoice
 
-Every peer in the chatroom is assigned an ID by the host. And every peer has a peer list, representing the other peers in the chatroom.
-
-- To get your ID  
-`agent.Network.OwnID;`
+## Samples
+This repository contains a sample scene for the Mirror network, which is the best place to see how UniVoice can be integrated into your project.  
   
-- To get a list of the other peers in the chatroom, use this:  
-`agent.Network.PeersIDs`
-
-`agent.Network` also provides methods to host or join a chatroom. Here is how you use them:
+To try the sample, import Mirror and add the `UNIVOICE_MIRROR_NETWORK` compilation symbol to your project.
   
-```
-// Host a chatroom using a name
-agent.Network.HostChatroom(optional_data);
-
-// Join an existing chatroom using a name
-agent.Network.JoinChatroom(optional_data);
+## Dependencies
+[com.adrenak.brw](https://www.github.com/adrenak/brw) for reading and writing messages for communication. See `MirrorServer.cs` and `MirrorClient.cs` where they're used.  
 
-// Leave the chatroom, if connected to one
-agent.Network.LeaveChatroom(optional_data);
+[com.adrenak.unimic](https://www.github.com/adrenak/unimic) for easily capturing audio from any connected mic devices. See `UniMicInput.cs` for usage. Also used for streaming audio playback. See `StreamedAudioSourceOutput.cs` for usage.
 
-// Closes a chatroom, if is hosting one
-agent.Network.CloseChatroom(optional_data);
+[com.adrenak.concentus-unity](https://www.github.com/adrenak/concentus-unity) for Opus encoding and decoding. See `ConcentusEncodeFilter.cs` and `ConcentusDecodeFilter.cs` for usage
 
-```
-## Muting Audio
-To mute everyone in the chatroom, use `agent.MuteOthers = true;` or set it to `false` to unmute them all.  
-  
-To mute yourself use `agent.MuteSelf = true;` or set it to `false` to unmute yourself. This will stop sending your audio to all the peers in the chatroom.
-
-For muting a specific peer, first get the peers settings object using this:  
-```
-agent.PeerSettings[id].muteThem = true; // where id belongs to the peer in question
-```
-  
-If you want to mute yourself towards a specific peer, use this:
-`agent.PeerSettings[id].muteSelf = true; // where id belongs to the peer in question`
-  
-## Events
-`agent.Network` provides several network related events. Refer to the [API reference](http://www.vatsalambastha.com/univoice/api/Adrenak.UniVoice.ChatroomAgent.html) for them.
-
-# License and Support
+## License and Support
 This project is under the [MIT license](https://github.com/adrenak/univoice/blob/master/LICENSE).
 
-Updates and maintenance are not guaranteed and the project is maintained by the original developer in his free time. Community contributions are welcome.
-  
-__Commercial consultation and development can be arranged__ but is subject to schedule and availability.  
+Community contributions are welcome.
   
-# Contact
+## Contact
 The developer can be reached at the following links:
   
 [Website](http://www.vatsalambastha.com)  
 [LinkedIn](https://www.linkedin.com/in/vatsalAmbastha)  
 [GitHub](https://www.github.com/adrenak)  
 [Twitter](https://www.twitter.com/vatsalAmbastha)  
+Discord: `adrenak#1934`

package/Runtime/Adrenak.UniVoice.Runtime.asmdef

@@ -1,3 +1,20 @@
-{
-	"name": "Adrenak.UniVoice.Runtime"
-}
+{
+    "name": "Adrenak.UniVoice.Runtime",
+    "rootNamespace": "",
+    "references": [
+        "GUID:f87ecb857e752164ab814a3de8eb0262",
+        "GUID:1f776cd02c03a7b4280b6b649d7758e2",
+        "GUID:30817c1a0e6d646d99c048fc403f5979",
+        "GUID:725ee7191c021de4dbf9269590ded755",
+        "GUID:b118fd5a40c85ad4e9b38e8c4a42bbb1"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Runtime/ClientSession.cs

@@ -0,0 +1,138 @@
+using System;
+using System.Collections.Generic;
+
+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.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class ClientSession<T> : IDisposable {
+        /// <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>
+        /// The input <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.
+        /// </summary>
+        public List<IAudioFilter> OutputFilters { get; set; } = new List<IAudioFilter>();
+
+        public ClientSession(IAudioClient<T> client, IAudioInput input, IAudioOutputFactory outputFactory) {
+            Client = client;
+            Input = input;
+            OutputFactory = outputFactory;
+        }
+
+        /// <summary>
+        /// The <see cref="IAudioClient{T}"/> that's used for networking
+        /// </summary>
+        IAudioClient<T> client;
+        public IAudioClient<T> Client {
+            get => client;
+            set {
+                if(client != null)
+                    client.Dispose();
+                client = value;
+
+                Client.OnLeft += () => {
+                    foreach (var output in PeerOutputs)
+                        output.Value.Dispose();
+                    PeerOutputs.Clear();
+                };
+
+                Client.OnPeerJoined += id => {
+                    try {
+                        var output = outputFactory.Create();
+                        PeerOutputs.Add(id, output);
+                    }
+                    catch (Exception e) {
+                        Debug.LogException(e);
+                    }
+                };
+
+                Client.OnPeerLeft += id => {
+                    if (!PeerOutputs.ContainsKey(id)) 
+                        return;
+
+                    PeerOutputs[id].Dispose();
+                    PeerOutputs.Remove(id);
+                };
+
+                client.OnReceivedPeerAudioFrame += (id, audioFrame) => {
+                    if (!PeerOutputs.ContainsKey(id))
+                        return;
+
+                    if (OutputFilters != null) {
+                        foreach (var filter in OutputFilters)
+                            audioFrame = filter.Run(audioFrame);
+                    }
+                    if(audioFrame.samples.Length > 0)
+                        PeerOutputs[id].Feed(audioFrame);
+                };
+            }
+        }
+
+        IAudioInput input;
+        /// <summary>
+        /// The <see cref="IAudioInput"/> that's used for sourcing outgoing audio
+        /// </summary>
+        public IAudioInput Input {
+            get => input;
+            set {
+                if(input != null)
+                    input.Dispose();
+                input = value;
+                input.OnFrameReady += frame => {
+                    if (InputFilters != null) {
+                        foreach (var filter in InputFilters)
+                            frame = filter.Run(frame);
+                    }
+
+                    if(frame.samples.Length > 0)
+                        Client.SendAudioFrame(frame);
+                };
+            }
+        }
+
+        IAudioOutputFactory outputFactory;
+        /// <summary>
+        /// The <see cref="IAudioOutputFactory"/> that creates the <see cref="IAudioOutput"/> of peers
+        /// </summary>
+        public IAudioOutputFactory OutputFactory {
+            get => outputFactory;
+            set {
+                outputFactory = value;
+
+                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);
+                    }
+                }
+            }
+        }
+
+        public void Dispose() {
+            Client.Dispose();
+            Input.Dispose();
+        }
+    }
+}

package/Runtime/{Interfaces/IChatroomNetwork.cs.meta → ClientSession.cs.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 11ba8951ad10dc84a963ca3c32cda48a
+guid: 923d8509d2c05f2479d6af7331dabe58
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

package/Runtime/Common/Utils.cs

@@ -0,0 +1,55 @@
+using System.IO;
+using System.IO.Compression;
+using System.Net.Sockets;
+using System.Net;
+using System.Runtime.Serialization.Formatters.Binary;
+using System;
+using UnityEngine;
+
+namespace Adrenak.UniVoice {
+    public class Utils {
+        public class Bytes {
+            public static byte[] FloatsToBytes(float[] floats) {
+                int byteCount = sizeof(float) * floats.Length;
+                byte[] byteArray = new byte[byteCount];
+
+                Buffer.BlockCopy(floats, 0, byteArray, 0, byteCount);
+
+                return byteArray;
+            }
+
+            public static float[] BytesToFloats(byte[] bytes) {
+                int floatCount = bytes.Length / sizeof(float);
+                float[] floatArray = new float[floatCount];
+
+                Buffer.BlockCopy(bytes, 0, floatArray, 0, bytes.Length);
+
+                return floatArray;
+            }
+        }
+
+        public static class Audio {
+            static float[] audioF;
+            static float sumOfSquares;
+            public static float CalculateRMS(byte[] audio) {
+                audioF = Bytes.BytesToFloats(audio);
+
+                foreach(var x in audioF)
+                    sumOfSquares += x * x;
+                return Mathf.Sqrt(sumOfSquares / audioF.Length);
+            }
+        }
+
+        public static class Network {
+            public static string LocalIPv4Address {
+                get {
+                    using (Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, 0)) {
+                        socket.Connect("8.8.8.8", 65530);
+                        IPEndPoint endPoint = socket.LocalEndPoint as IPEndPoint;
+                        return endPoint.Address.ToString();
+                    }
+                }
+            }
+        }
+    }
+}

package/Runtime/{Types/ChatroomAgentMode.cs.meta → Common/Utils.cs.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 95ab24cb9f03b8c4c8f22f567259def4
+guid: a3530a416ca433448ab4c50826faefb4
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

package/Runtime/Common.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7e8f97d020fcd2740b34e8d69e4f882d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Impl/Filters/Concentus Opus Filters/ConcentusDecodeFilter.cs

@@ -0,0 +1,80 @@
+using Concentus;
+using System;
+
+/*
+ * Opus encoding and decoding are VERY important for any real world use of UniVoice as without
+ * encoding the size of audio data is much (over 10x) larger.
+ * For more info see https://www.github.com/adrenak/concentus-unity
+ */
+namespace Adrenak.UniVoice.Filters {
+    /// <summary>
+    /// Decodes Opus encoded audio. Use this as a filter for incoming client audio.
+    /// </summary>
+    public class ConcentusDecodeFilter : IAudioFilter {
+        IOpusDecoder decoder;
+        float[] decodeBuffer;
+        int inputChannelCount;
+        int inputFrequency;
+        byte[] floatsToBytes;
+
+        /// <summary>
+        /// Creates a Concentus decode filter.
+        /// </summary>
+        /// <param name="decodeBufferLength">
+        /// The length of the decode buffer. Default is 11520 to fit a large sample
+        /// with frequency 48000, duration 120ms and 2 channels. This should be enough
+        /// for almost all scenarios. Increase if you need more.
+        /// </param>
+        public ConcentusDecodeFilter(int decodeBufferLength = 11520) {
+            decodeBuffer = new float[decodeBufferLength];
+        }
+
+        public AudioFrame Run(AudioFrame input) {
+            inputChannelCount = input.channelCount;
+            inputFrequency = input.frequency;
+
+            CreateNewDecoderIfNeeded();
+
+            var decodeResult = Decode(input.samples, out Span<float> decoded);
+            if (decodeResult > 0) {
+                floatsToBytes = Utils.Bytes.FloatsToBytes(decoded.ToArray());
+                return new AudioFrame {
+                    timestamp = input.timestamp,
+                    samples = floatsToBytes,
+                    channelCount = inputChannelCount,
+                    frequency = inputFrequency
+                };
+            }
+            else {
+                return new AudioFrame {
+                    timestamp = input.timestamp,
+                    samples = new byte[0],
+                    channelCount = inputChannelCount,
+                    frequency = inputFrequency
+                };
+            }
+        }
+
+        int Decode(Span<byte> toDecode, out Span<float> decoded) {
+            // Decode the Opus packet into preallocated buffer
+            int samplesPerChannel = decoder.Decode(toDecode, decodeBuffer, decodeBuffer.Length);
+
+            if (samplesPerChannel > 0) {
+                int totalSamples = samplesPerChannel * inputChannelCount; // Total samples across all channels
+                decoded = decodeBuffer.AsSpan(0, totalSamples); // Trim to valid samples
+            }
+            else {
+                decoded = Span<float>.Empty;
+            }
+
+            return samplesPerChannel; // Return number of samples per channel or 0 on failure
+        }
+
+        void CreateNewDecoderIfNeeded() {
+            if (decoder == null || decoder.SampleRate != inputFrequency || decoder.NumChannels != inputChannelCount) {
+                decoder?.Dispose();
+                decoder = OpusCodecFactory.CreateDecoder(inputFrequency, inputChannelCount);
+            }
+        }
+    }
+}

package/Runtime/{ChatroomAgent.cs.meta → Impl/Filters/Concentus Opus Filters/ConcentusDecodeFilter.cs.meta }

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 76706adfc97ef7d44823aa51d618267d
+guid: 31124d8beda4bc045b5ee5696140f0d8
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

package/Runtime/Impl/Filters/Concentus Opus Filters/ConcentusEncodeFilter.cs

@@ -0,0 +1,156 @@
+using Concentus;
+using Concentus.Enums;
+using System;
+
+/*
+ * Opus encoding and decoding are VERY important for any real world use of UniVoice as without
+ * encoding the size of audio data is much (over 10x) larger.
+ * For more info see https://www.github.com/adrenak/concentus-unity
+ */
+namespace Adrenak.UniVoice.Filters {
+    /// <summary>
+    /// A filter that encodes audio using Opus. Use this as an output filter
+    /// to reduce the size of outgoing client audio
+    /// </summary>
+    public class ConcentusEncodeFilter : IAudioFilter {
+        public ConcentusFrequencies SamplingFrequency { get; private set; }
+        IOpusEncoder encoder;
+        IResampler resampler;
+        byte[] encodeBuffer;
+        float[] resampleBuffer;
+        int inputDuration;
+        int inputChannels;
+        int inputFrequency;
+        int resamplerChannelCount;
+        float[] bytesToFloats;
+        byte[] floatsToBytes;
+        int resamplerQuality;
+        int encoderComplexity;
+        int encoderBitrate;
+
+        /// <summary>
+        /// Creates a Concentus encode filter
+        /// </summary>
+        /// <param name="encodeFrequency">
+        /// The frequency the encoder runs at.
+        /// If the input audio frequency is different from this value, it will be resampled before encode.
+        /// </param>
+        /// <param name="resamplerQuality">Resampler quality [1, 10]</param>
+        /// <param name="encoderComplexity">Encoder complexity [1, 10]</param>
+        /// <param name="encoderBitrate">Encoder bitrate [16000, 256000]. Set to -1 to enable variable bitrate.</param>
+        /// <param name="encodeBufferLength">
+        /// The length of the encode buffer. Default is 46080 to fit a large sample
+        /// with frequency 48000, duration 120ms and 2 channels. This should be enough
+        /// for almost all scenarios. Increase if you need more.
+        /// </param>
+        public ConcentusEncodeFilter(
+            ConcentusFrequencies encodeFrequency = ConcentusFrequencies.Frequency_16000,
+            int resamplerQuality = 2,
+            int encoderComplexity = 3,
+            int encoderBitrate = 64000,
+            int encodeBufferLength = 46080
+        ) {
+            SamplingFrequency = encodeFrequency;
+            this.resamplerQuality = Math.Clamp(resamplerQuality, 1, 10);
+            this.encoderComplexity = Math.Clamp(encoderComplexity, 1, 10);
+            this.encoderBitrate = Math.Clamp(encoderBitrate, 16000, 256000);
+            encodeBuffer = new byte[encodeBufferLength];
+        }
+
+        public AudioFrame Run(AudioFrame input) {
+            inputChannels = input.channelCount;
+            inputFrequency = input.frequency;
+            inputDuration = ((input.samples.Length / 4) * 1000) / (input.frequency * input.channelCount);
+
+            CreateNewResamplerAndEncoderIfNeeded();
+
+            Span<float> toEncode;
+            bytesToFloats = Utils.Bytes.BytesToFloats(input.samples);
+            toEncode = bytesToFloats;
+
+            if (inputFrequency != (int)SamplingFrequency) 
+                toEncode = Resample(bytesToFloats);
+
+            var encodeResult = Encode(toEncode, out Span<byte> encoded);
+            if (encodeResult > 0) {
+                floatsToBytes = encoded.ToArray();
+                return new AudioFrame {
+                    timestamp = input.timestamp,
+                    channelCount = inputChannels,
+                    samples = floatsToBytes,
+                    frequency = (int)SamplingFrequency
+                };
+            }
+            else {
+                return new AudioFrame {
+                    timestamp = input.timestamp,
+                    channelCount = inputChannels,
+                    samples = new byte[0],
+                    frequency = (int)SamplingFrequency
+                };
+            }
+        }
+
+        void CreateNewResamplerAndEncoderIfNeeded() {
+            if (resampleBuffer == null || resampleBuffer.Length != (int)SamplingFrequency * inputDuration * inputChannels / 1000)
+                resampleBuffer = new float[(int)SamplingFrequency * inputDuration * inputChannels / 1000];
+
+            if (resampler == null) {
+                resamplerChannelCount = inputChannels;
+                resampler = ResamplerFactory.CreateResampler(inputChannels, inputFrequency, (int)SamplingFrequency, resamplerQuality);
+            }
+            else {
+                resampler.GetRates(out int in_rate, out int out_rate);
+                if (in_rate != inputFrequency || out_rate != (int)SamplingFrequency || resamplerChannelCount != inputChannels) {
+                    resampler.Dispose();
+                    resamplerChannelCount = inputChannels;
+                    resampler = ResamplerFactory.CreateResampler(inputChannels, inputFrequency, (int)SamplingFrequency, resamplerQuality);
+                }
+            }
+
+            if (encoder == null || encoder.SampleRate != (int)SamplingFrequency || encoder.NumChannels != inputChannels) {
+                encoder?.Dispose();
+                encoder = OpusCodecFactory.CreateEncoder((int)SamplingFrequency, inputChannels, OpusApplication.OPUS_APPLICATION_VOIP);
+                encoder.Complexity = encoderComplexity;
+                if(encoderBitrate == -1) 
+                    encoder.UseVBR = true;
+                else {
+                    encoder.UseVBR = false;
+                    encoder.Bitrate = encoderBitrate;
+                }
+            }
+        }
+
+        Span<float> Resample(Span<float> samples) {
+            // Calculate input and output lengths
+            int in_len = samples.Length / inputChannels; // Input samples per channel
+            int out_len = (int)SamplingFrequency * inputDuration / 1000; // Output samples per channel
+
+            // Perform resampling into preallocated buffer
+            resampler.ProcessInterleaved(samples, ref in_len, resampleBuffer, ref out_len);
+
+            // Return only the valid portion of resampled data
+            return resampleBuffer.AsSpan(0, out_len * inputChannels); // Trim to valid samples
+        }
+
+        int Encode(Span<float> toEncode, out Span<byte> encoded) {
+            int frameSize = (int)SamplingFrequency * inputDuration / 1000; // Samples per channel
+            int totalSamples = frameSize * inputChannels; // Total interleaved samples
+
+            if (toEncode.Length < totalSamples) {
+                encoded = Span<byte>.Empty;
+                return 0;
+            }
+
+            // Use preallocated encodeBuffer
+            int result = encoder.Encode(toEncode.Slice(0, totalSamples), frameSize, encodeBuffer, encodeBuffer.Length);
+
+            if (result > 0) 
+                encoded = encodeBuffer.AsSpan(0, result); // Trim to actual encoded size
+            else 
+                encoded = Span<byte>.Empty;
+
+            return result; // Return number of bytes written or 0 on failure
+        }
+    }
+}

package/Runtime/Impl/Filters/Concentus Opus Filters/ConcentusEncodeFilter.cs.meta

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

package/Runtime/Impl/Filters/Concentus Opus Filters/ConcentusFrequencies.cs

@@ -0,0 +1,31 @@
+namespace Adrenak.UniVoice.Filters {
+    /// <summary>
+    /// Defines supported sampling frequencies for the Opus codec via Concentus.
+    /// </summary>
+    public enum ConcentusFrequencies : int {
+        /// <summary>
+        /// 8 kHz sampling frequency, typically used for narrowband audio.
+        /// </summary>
+        Frequency_8000 = 8000,
+
+        /// <summary>
+        /// 12 kHz sampling frequency, suitable for medium-band audio.
+        /// </summary>
+        Frequency_12000 = 12000,
+
+        /// <summary>
+        /// 16 kHz sampling frequency, commonly used for wideband speech.
+        /// </summary>
+        Frequency_16000 = 16000,
+
+        /// <summary>
+        /// 24 kHz sampling frequency, providing good quality for music and audio.
+        /// </summary>
+        Frequency_24000 = 24000,
+
+        /// <summary>
+        /// 48 kHz sampling frequency, offering the highest audio quality.
+        /// </summary>
+        Frequency_48000 = 48000,
+    }
+}

package/Runtime/Impl/Filters/Concentus Opus Filters/ConcentusFrequencies.cs.meta

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