bananahemic / mumble-unity Goto Github PK

It looks like there is a quarter to half second latency increase when comparing receiving the plugin audio to standalone mumble. Is this something that can be reduced or played with on my end? Or is this just the overhead from talking through Unity?
Worth noting that I am in a LAN setting so the latency shouldn't be network related, and a mumble client receives audio quickly.

Hi All

I am new to Mumble. I have downloaded the Mumble Unity assets. and i have run on Unity 2018.
When i try to build in ios Platform. the xcode project is not created.. I cant run in Xcode.
So What i have to Do to create Xcode project.

Did Mumble Unity Projects in Github Supports Unity 2018 Version?

I'm aware it is marked as todo. Is there any estimate on when this would be implemented? Or could you give me any directions on how to implement it myself?

I didn't work with mumble so far. I need a VoIP solution for unity with spatial audio and this mumble client implementation looks promising. (the only promising solution I found to be honest..)

Everything works well in Editor, but if I launch the game standalone it doesn't connect to the server.

It would be nice if there was a package manager support.

I tried connecting to a local murmur server and to an online one. In both cases the connection hangs at _ssl.AuthenticateAsClient(_hostname); in MumbleTCPConnection

Hi, I 'm having a error with this project. I downloaded it in an empty Unity project, loaded the Example Scene and modified the Mumble Host Name. When I hit play, the library connects to the server, but fails when trying to decode the sound of participants in the room. I can see small points on Editor Graph but i can't hear anything.

The first error in UnityConsole is:

Parameter name: outputChannelCount
Mumble.OpusDecoder..ctor (Int32 outputSampleRate, Int32 outputChannelCount) (at Assets/Mumble-Unity/Scripts/Opus/OpusDecoder.cs:59)

This is the Error each time the asset try to decode audio:

UnityEngine.Debug:LogError(Object)
Mumble.MumbleUdpConnection:UnpackOpusVoicePacket(Byte[]) (at Assets/Mumble-Unity/Scripts/MumbleUDPConnection.cs:150)
Mumble.MumbleTcpConnection:ProcessTcpData() (at Assets/Mumble-Unity/Scripts/MumbleTCPConnection.cs:254) 

Am I doing something wrong? Is this behaviour normal? Any ideas to fix this?

Unity Editor successfully connects to my Mumble server, but the Build doesn't. I'm using your Example scene.

Here's the murmur server log, I've bolded the lines that came when connecting with the Build:

2020-09-06 18:01:56.657 1 => <5:(-1)> New connection: 192.168.1.40:58802
2020-09-06 18:01:56.658 Connection: Failed to add flow to QOS
2020-09-06 18:02:17.524 1 => <6:(-1)> New connection: 192.168.1.40:58805
2020-09-06 18:02:17.525 Connection: Failed to add flow to QOS
2020-09-06 18:02:17.679 1 => <6:(-1)> Client version 1.2.8 (Microsoft Windows NT 10.0.18363.0: MumbleUnity)
2020-09-06 18:02:17.702 1 => Starting voice thread
2020-09-06 18:02:17.716 1 => <6:testOliver1233(-1)> Authenticated
2020-09-06 18:02:17.748 1 => <5:(-1)> Requesting crypt-nonce resync
2020-09-06 18:02:33.200 1 => <5:(-1)> Timeout
2020-09-06 18:02:33.211 1 => <5:(-1)> Connection closed: [-1]

For some reason it leaves the connection hanging (and doesn't apply a username to the build).

This assett is working really well, thanks for your efforts in creating it.

Im using it in a 2D enviroment. is there any way to send the audio to the left or right ear only?
I would like to have the audio from a certain user coming out of a set channel?

Many thanks
Spriggsy

Hello,
I would like to add/remove channels on the server form this client.
I manage to do it to remove a channel by adding a new method and using "_tcpConnection.SendMessage<MumbleProto.ChannelRemove>(MessageType.ChannelRemove, channeltoremove);"
(I am connected as SuperUser in order to have the rights.)
But I can't manage to add a new channel. I have tried with a "MessageType.ChannelState" but I'am not sure if it is possible this way?
Any advices if it should be possible or not?
Thanks,
Gildas

@BananaHemic Would you accept a PR that makes the necessary conversion to this format? Folder hierarchy, package.json file, etc. ...

Have upgraded an existing project from 2017 to 2019. Mumble was working perfectly now it can't find the Opus.dll even though it is there. Do you think with Unity 2019 forced .net 4.0 this could be the problem??

In README you say:

Different audio positions for each Mumble speaker is not yet supported, but is possible

How can integrate this feature in little Social Demo?

My project is Open Source and based on Unity 5.6.1f1.

Thanks for your work and help!

Hello! Do you currently support a way to connect with a certificate so that I can register users? I want to do some fancy stuff with ACL and groups and to my knowledge you can only add users to groups if they are registered.

Hello I was looking for an up-to-date opus binding for unity and stumbled upon this project.

Maybe someone could point me to the source of the opus-1_3.bundle ?

I ran the example scene and everything worked as expected.
The sound quality feels good!

But after a while when receiving there is a warning on the screen and the sequence number increase:
...
Max recv buffer size reached, dropping for user Plumble_User seq: 1708
Max recv buffer size reached, dropping for user Plumble_User seq: 1710
Max recv buffer size reached, dropping for user Plumble_User seq: 1740
Max recv buffer size reached, dropping for user Plumble_User seq: 1742
...

This happens in the AudioDecodingBuffer but the sound still work and the sound is clear.
There is a red line in the editor graph that is correlated with the warning message, close to be continuous after the first warning.

The audio is transmitted from a plumble (android client) continuously. Whenever the transmission is stopped, the counter reset.

Should the data dropped affect the output audio?
Is that warning important?

I am currently in unity 2018.2 and using
mumur 1.2.19
Client version 1.2.5 (Android: Plumble Free 3.2.0)

When Unity conection to mamble server, server go to reboot. How i can connect from unity3d? And from unity 2019.2? Ver. server of mumble 1.3

Hi,

Is there any way to get the amplitude of the Mumble audio player pefab.
When you are connected to the server you can see the amplitude in the editor moving but I cannot seem to find the source of this.

Question about the PCMArray in ManageAudioSendBuffer. I noticed that "GetAvailablePCMArray()" gets called every frame, and basically never has available arrays because the "ReleasePCMArray()" is not called anywhere. Do you have an idea where I should be calling this, as the iteration through a list that gets longer every frame is very expensive.

I can't seem to open it in unity, and am unsure as to how to otherwise use the files from the readme

I have been testing this client and I have noticed that it uses a lot of CPU. It uses 15% of i7 7700k.

It looks like the TargettedSpeech struct does support a SpeechTarget to shout/whipser to channel. I have a few questions regarding it.

1. I assume if you set the SpeechTarget = 1 (WhisperToChannel), then the TargetId is the channel ID you want to whisper to. Is that correct?

2. How/what do I set so that a whisper to channel does not get propagated to linked channels? There is a way to do this in mumble when you assign a shortcut and I was wondering how I would do that with the TargettedSpeech struct.

3. I'll keep digging to find the answer to this but just in case you answer this before I find it: Does your library support listing the channels so I can build a channel name to ID map?

Thanks!

I will try Script Backend il2cpp Not working on Android and Ios.
When try on Android:
It's not send debug to editor. I connect with breakpoint it's give Culture error on Debug.log side
When try Ios:
On load give error like
Exception: Encoder error - BadArgument
at Mumble.OpusEncoder.set_EnableForwardErrorCorrection (Boolean value) [0x00000] in :0
at Mumble.OpusCodec.InitializeEncoderWithSampleRate (Int32 newSampleRate) [0x00000] in :0
at MumbleTester.Start () [0x00000] in :0

I thing can't load static lib Unity on il2cpp.
It's working on mono Script Backend but Ios only selected il2cpp.

Any idea?

@BananaHemic why isn't MumbleSharp used as a dependency? https://www.nuget.org/packages/MumbleSharp

I see that at the very least we can share the Mumble.cs class which is the one with the protobuff-net data model (3k lines of code).

I see that the loading of the native dlls is done differently and the use of it in Unity is somewhat different as far as OPUS is concerned. Part of this problem could be solved by making a PR in MumbleSharp to expose a custom callback for loading native assemblies.

But for everything else couldn't we make use of MumbleSharp and only implement what is strictly necessary? That way it would be easier to maintain the code and only focus on what is unique to Unity.

EDIT: apart warnings like:

[WARNING]: This server has the ChannelListener feature enabled but your client version does not support it. This means that users might be listening to what you are saying in your channel without you noticing! You can solve this issue by upgrading to Mumble 1.4.0 or newer.

This is because the Unity code was implemented when the server was around 1.2.x. And as I say, not using MumbleSharp makes it difficult to stay on the latest version of the client.

Greetings,
I have a localhost murmur server and I simply launched the Example scene, changed the host name and clicked play. I get the error in the title when the following function is called in MumbleTCPConnection.cs :
_tcpClient.BeginConnect(_host.Address, _host.Port, new AsyncCallback(OnTcpConnected), null);

Here is the complete error :

NotSupportedException: This protocol version is not supported.
System.Net.Sockets.Socket.BeginConnect (System.Net.IPAddress address, System.Int32 port, System.AsyncCallback requestCallback, System.Object state) (at <3845a180c26b4889bc2d47593a665814>:0)
System.Net.Sockets.TcpClient.BeginConnect (System.Net.IPAddress address, System.Int32 port, System.AsyncCallback requestCallback, System.Object state) (at <3845a180c26b4889bc2d47593a665814>:0)
Mumble.MumbleTcpConnection.StartClient (System.String username, System.String password) (at Assets/Scripts/MumbleTCPConnection.cs:55)
Mumble.MumbleClient.Connect (System.String username, System.String password) (at Assets/Scripts/MumbleClient.cs:445)
MumbleTester+d__15.MoveNext () (at Assets/MumbleTester.cs:103)
UnityEngine.SetupCoroutine.InvokeMoveNext (System.Collections.IEnumerator enumerator, System.IntPtr returnValueAddress) (at C:/buildslave/unity/build/Runtime/Export/Coroutines.cs:17)

I'm trying to look on the Microsoft documentation but can't find a way to make it work. Does anyone have an idea on the matter ?

Thank you.

Thank you for your great job!

Im using Mumble-Unity on iOS, Android.
Android works great but iOS I had to build opus codec .
After that I got this error, I think it has problem with Protobuf.(on google, people say it's related with protobuf code generation)
I'm new at protobuf so any help would be grateful
I attached my error log

NotSupportedException: System.Reflection.Emit.DynamicMethod::.ctor
  at System.Reflection.Emit.DynamicMethod..ctor (System.String name, System.Type returnType, System.Type[] parameterTypes, System.Type owner, System.Boolean skipVisibility) [0x00000] in <00000000000000000000000000000000>:0 
  at ProtoBuf.Compiler.CompilerContext..ctor (System.Type associatedType, System.Boolean isWriter, System.Boolean isStatic, ProtoBuf.Meta.TypeModel model, System.Type inputType) [0x00000] in <00000000000000000000000000000000>:0 
  at ProtoBuf.Compiler.CompilerContext.BuildSerializer (ProtoBuf.Serializers.IProtoSerializer head, ProtoBuf.Meta.TypeModel model) [0x00000] in <00000000000000000000000000000000>:0 
  at ProtoBuf.Serializers.CompiledSerializer..ctor (ProtoBuf.Serializers.IProtoTypeSerializer head, ProtoBuf.Meta.TypeModel model) [0x00000] in <00000000000000000000000000000000>:0 
  at ProtoBuf.Serializers.CompiledSerializer.Wrap (ProtoBuf.Serializers.IProtoTypeSerializer head, ProtoBuf.Meta.TypeModel model) [0x00000] in <00000000000000000000000000000000>:0 
  at ProtoBuf.Meta.MetaType.CompileInPlace () [0x00000] in <00000000000000000000000000000000>:0 
  at ProtoBuf.Meta.MetaType.get_Serializer () [0x00000] in <00000000000000000000000000000000>:0 
  at ProtoBuf.Meta.RuntimeTypeModel.Serialize (System.Int32 key, System.Object value, ProtoBuf.ProtoWriter dest) [0x00000] in <00000000000000000000000000000000>:0 
  at ProtoBuf.Meta.TypeModel.SerializeCore (ProtoBuf.ProtoWriter writer, System.Object value) [0x00000] in <00000000000000000000000000000000>:0 
  at ProtoBuf.Meta.TypeModel.Serialize (System.IO.Stream dest, System.Object value, ProtoBuf.SerializationContext context) [0x00000] in <00000000000000000000000000000000>:0 
  at ProtoBuf.Meta.TypeModel.Serialize (System.IO.Stream dest, System.Object value) [0x00000] in <00000000000000000000000000000000>:0 
  at ProtoBuf.Serializer+NonGeneric.Serialize (System.IO.Stream dest, System.Object instance) [0x00000] in <00000000000000000000000000000000>:0 
  at Mumble.MumbleTcpConnection.SendMessage[T] (Mumble.MessageType mt, T message) [0x00000] in <00000000000000000000000000000000>:0 
  at Mumble.MumbleTcpConnection.SendVersion () [0x00000] in <00000000000000000000000000000000>:0 
  at Mumble.MumbleTcpConnection.OnTcpConnected (System.IAsyncResult connectionResult) [0x00000] in <00000000000000000000000000000000>:0 
  at System.AsyncCallback.Invoke (System.IAsyncResult ar) [0x00000] in <00000000000000000000000000000000>:0 
  at System.Net.Sockets.SocketAsyncResult+<>c.<Complete>b__27_0 (System.Object state) [0x00000] in <00000000000000000000000000000000>:0 
  at System.Threading.WaitCallback.Invoke (System.Object state) [0x00000] in <00000000000000000000000000000000>:0 
  at System.Threading.QueueUserWorkItemCallback.System.Threading.IThreadPoolWorkItem.ExecuteWorkItem () [0x00000] in <00000000000000000000000000000000>:0 
  at System.Threading.ThreadPoolWorkQueue.Dispatch () [0x00000] in <00000000000000000000000000000000>:0 
  at System.Threading._ThreadPoolWaitCallback.PerformWaitCallback () [0x00000] in <00000000000000000000000000000000>:0 
Rethrow as InvalidOperationException: It was not possible to prepare a serializer for: MumbleProto.Version
  at ProtoBuf.Compiler.CompilerContext.BuildSerializer (ProtoBuf.Serializers.IProtoSerializer head, ProtoBuf.Meta.TypeModel model) [0x00000] in <00000000000000000000000000000000>:0 
  at ProtoBuf.Serializers.CompiledSerializer..ctor (ProtoBuf.Serializers.IProtoTypeSerializer head, ProtoBuf.Meta.TypeModel model) [0x00000] in <00000000000000000000000000000000>:0 
  at ProtoBuf.Serializers.CompiledSerializer.Wrap (ProtoBuf.Serializers.IProtoTypeSerializer head, ProtoBuf.Meta.TypeModel model) [0x00000] in <00000000000000000000000000000000>:0 
  at ProtoBuf.Meta.MetaType.CompileInPlace () [0x00000] in <00000000000000000000000000000000>:0 
  at ProtoBuf.Meta.MetaType.get_Serializer () [0x00000] in <00000000000000000000000000000000>:0 
  at ProtoBuf.Meta.RuntimeTypeModel.Serialize (System.Int32 key, System.Object value, ProtoBuf.ProtoWriter dest) [0x00000] in <00000000000000000000000000000000>:0 
  at ProtoBuf.Meta.TypeModel.SerializeCore (ProtoBuf.ProtoWriter writer, System.Object value) [0x00000] in <00000000000000000000000000000000>:0 
  at ProtoBuf.Meta.TypeModel.Serialize (System.IO.Stream dest, System.Object value, ProtoBuf.SerializationContext context) [0x00000] in <00000000000000000000000000000000>:0 
  at ProtoBuf.Meta.TypeModel.Serialize (System.IO.Stream dest, System.Object value) [0x00000] in <00000000000000000000000000000000>:0 
  at ProtoBuf.Serializer+NonGeneric.Serialize (System.IO.Stream dest, System.Object instance) [0x00000] in <00000000000000000000000000000000>:0 
  at Mumble.MumbleTcpConnection.SendMessage[T] (Mumble.MessageType mt, T message) [0x00000] in <00000000000000000000000000000000>:0 
  at Mumble.MumbleTcpConnection.SendVersion () [0x00000] in <00000000000000000000000000000000>:0 
  at Mumble.MumbleTcpConnection.OnTcpConnected (System.IAsyncResult connectionResult) [0x00000] in <00000000000000000000000000000000>:0 
  at System.AsyncCallback.Invoke (System.IAsyncResult ar) [0x00000] in <00000000000000000000000000000000>:0 
  at System.Net.Sockets.SocketAsyncResult+<>c.<Complete>b__27_0 (System.Object state) [0x00000] in <00000000000000000000000000000000>:0 
  at System.Threading.WaitCallback.Invoke (System.Object state) [0x00000] in <00000000000000000000000000000000>:0 
  at System.Threading.QueueUserWorkItemCallback.System.Threading.IThreadPoolWorkItem.ExecuteWorkItem () [0x00000] in <00000000000000000000000000000000>:0 
  at System.Threading.ThreadPoolWorkQueue.Dispatch () [0x00000] in <00000000000000000000000000000000>:0 
  at System.Threading._ThreadPoolWaitCallback.PerformWaitCallback () [0x00000] in <00000000000000000000000000000000>:0 
UnityEngine.DebugLogHandler:Internal_LogException(Exception, Object)
UnityEngine.DebugLogHandler:LogException(Exception, Object)
UnityEngine.Logger:LogException(Exception, Object)
UnityEngine.Debug:LogException(Exception)
UnityEngine.UnhandledExceptionHandler:PrintException(String, Exception)
UnityEngine.UnhandledExceptionHandler:HandleUnhandledException(Object, UnhandledExceptionEventArgs)
System.UnhandledExceptionEventHandler:Invoke(Object, UnhandledExceptionEventArgs)

Thank you for your wonderfull work ... working really fine in standalone ... we are producing a webgl version of our appliaction ... i managed to get the webgl microphone, but i see that the opus lib that you delivered in your project dont fit for webGL... do you have a solution ? Thank you so much again

Ewen

I made a simple scene to test the 3d positional audio and it works great, but how can I turn this audio into stereo? So I can hear the voice depending on the camera (listener) orientation

Hi BananaHemic,
I have big problem with my voice chat App. When 2 people voice each other by mobile phone. The voice sound of the speaker is recorded back to the microphone, and causing echo. After many times the sound is echoed and resonant with each other, causing loud noises. I've been looking for solutions like AEC(Acoustic Echo Cancellation), Echo Suppression, but it's not work for Unity.
Have you ever had this problem or has any solutions, please let me know. Thanks so much!!!

I am getting ProtoBuf not found error.

Here is how I setup the project

1. Created a new empty project, configured for windows build.
2. followed "installing method 1" given in readme.
3. Getting the following 500+ error.
   [ERROR]: Library\PackageCache\[email protected]\Runtime\Scripts\MumbleTCPConnection.cs(2,7): error CS0246: The type or namespace name 'ProtoBuf' could not be found (are you missing a using directive or an assembly reference?)

Please help me how can I fix it.

This is a great plugin, very easy to setup and use. I had an issue where 3 clients were connected to mumble using the plugin. When two clients were talking at the same time, and the 3rd listening, the audio becomes super distorted. It sounds like the two are getting combined together somehow. Is there any setting I should be looking at for this or is this a known issue?

OpenUPM requires tags per version to work properly, can you create one? Thanks!

https://openupm.com/packages/com.bananahemic.mumble/

This was primarily occurring when trying to call the mumbleClient's Close() method without exiting the application. Also only happened once out of every 5 or 6 close operations. However generally speaking Thread.Abort() is not considered safe due to the fact there's no guarantee where/when in the thread the abort will happen. A better solution would be to use Thread.Interrupt(). I was able to fix the issue by modifying the following files to use a variable to signal the threads to shutdown and then by calling Thread.Interrupt vs. abort. Here's the source code of the files I modified

... unchanged using statements ...

namespace Mumble
{
    public class MumbleUdpConnection
    {
        ... unchanged var defs ...

        // Add this to signal thread to shutdown
        private bool _running;

        ... unchanged var defs ...

        ... unchanged class methods ...

        internal void Connect()
        {
            ... do what you were doing here ...

            _running = true; // set flag to true here
            _receiveThread = new Thread(ReceiveUDP)
            {
                IsBackground = true
            };
            _receiveThread.Start();
        }

       ... other class stuff ...

        private void ReceiveUDP()
        {
            ... keep doing what you were doing here ...

            // Instead of while(true) use our flag here
            while (_running)
            {
                 ... do thread stuff here ...
            }
            // This probably isn't needed but just a fail-safe. Set up thread for next run
            _running = true;
        }

        ... more unchanged class stuff ...

        internal void Close()
        {
            _running = false; // before closing, signal thread it's time to stop

             // The ?. in this case is the same as the null check you were doing before; no need to change
             // if you don't want to. However, do change Abort to Interrupt here which will wait for the thread
             // to resolve
            _receiveThread?.Interrupt();   
             
            ... unchanged ...
        }

        ... rest of the file is unchanged ...

... unchanged using statements ...

namespace Mumble
{
    public class MumbleTcpConnection
    {
        ... unchanged var defs ...

        // Add this to signal threads to shut down safely
        private bool _running;

        ... unchanged var defs ...

        ... unchanged class methods ...

        internal MumbleTcpConnection(IPEndPoint host, string hostname, UpdateOcbServerNonce updateOcbServerNonce,
            MumbleUdpConnection udpConnection, MumbleClient mumbleClient)
        {
            ... keep doing what you were doing here ...

             // Set flag to true here before starting thread
            _running = true;
            _processThread = new Thread(ProcessTcpData)
            {
                IsBackground = true
            };
        }

        .. unchanged class methods ...

        private void ProcessTcpData()
        {
            // This thread is aborted in Close()
           // Change while(true) to use _running here
            while (_running)
            {
                ... do thread stuff here (unchanged) ...
            }
            // This probably isn't needed, fail-safe to ensure we reset for next thread
            _running = true;
        }

       ... unchanged class methods ...

        internal void Close()
        {
            // Before interrupting thread, signal shutdown
            _running = false;
            
            ... unchanged ...
             // The ?. in this case is the same as the null check you were doing before; no need to change
             // if you don't want to. However, do change Abort to Interrupt here which will wait for the thread
             // to resolve 
            _processThread?.Interrupt();

            ... unchanged ...
        }

        ... rest of file is unchanged ...

Hello, I was wondering if whisper to user is supported and if not, how could it be implemented. I'm not sure if there is some kind of documentation about that or a general one for this Unity client. I've been looking around and I can't find anything. Thank you.

I'm just pointing that because it took me a while before I realized you were talking about a file in murmur settings and not in Unity, and the file name with the opusthreshold is in murmur.ini, not in mumble.ini like you wrote in your readme.

Cheers

This plugin does now seem to support UWP?

If I use the il2cpp scripting backend the project will build and run on Hololens (UWP) but will not connect to the mumble server.
If I switch to .Net I get a lot of errors - I assume due to UWP and normal windows .Net being different.

Assets\Scripts\MumbleTCPConnection.cs(6,36): error CS0234: The type or namespace name 'X509Certificates' does not exist in the namespace 'System.Security.Cryptography' (are you missing an assembly reference?)
Assets\Scripts\MumbleTCPConnection.cs(10,14): error CS0234: The type or namespace name 'Timers' does not exist in the namespace 'System' (are you missing an assembly reference?)
Assets\Scripts\MumbleUDPConnection.cs(4,14): error CS0234: The type or namespace name 'Timers' does not exist in the namespace 'System' (are you missing an assembly reference?)
Assets\Scripts\MumbleTCPConnection.cs(146,57): error CS0246: The type or namespace name 'X509Certificate' could not be found (are you missing a using directive or an assembly reference?
```)

etc etc etc

Unity version 2018.3.0f2

In the MumbleMicrophone component I am using VoiceSendingType = Amplitude, with a value of 0.03 to send voice. I noticed, when receiving a new voice, there is a crackle in the beginning. This is only happening in Unity, I didn't get a crackle when listening directly in a mumble client with another user.

I could reproduce it in your example scene while sending the synthetic audio source, with the amplitude setting. It is just the first bit of sound that crackles, if you keep talking after that it sounds fine.

Any idea what could be causing this? Thanks!

Hello, I was wondering if it's possible to admin the server using this client, for example changing ACL or muting/unmuting users in some way. I managed to do some of it sending my own codes to mute/unmute clients but not using Mumble protocol. Any tips? Thanks.

I've downloaded/cloned the latest and built an executable running for x64 out of Unity 2017.3. I can hear myself echo back, and can see a connection success to my local windows mumble server, but can't seem to communicate with anyone.

I've noticed a slew of debug prints with empty packets; is there something additional I need besides setting the threshold to 0 before getting the test to work out of box?

Hi,

Thanks so much for making this client! I have brought the latest code from this repo into a brand new Unity project (using version 2021.2.13f1) and have the following error when connecting to a local murmur server on same machine:

The config of my MumbleTester and MumbleMic scripts are as follows:

The client initially connects successfully to the server, but we're unable to send any audio (we use the official Mumble Desktop app to verify this).

The error above shows up almost immediately on startup and then not too long after we get disconnected from the server without the mumble client even noticing that we're disconnected. To be sure, I went back to an older Unity version where I'm confident this client worked back in 2021, but now it doesn't even work in that version.

What could be causing this?

Thanks so much for your help!

Cheers,
Danrae

Please help me. In the Script: UdpPacketReader.cs
Function:
public byte[] ReadBytes(int length)
{
byte[] buffer = new byte[length];
var read = _inner.Read(buffer, 0, length);
if (length != read)
return null;
return buffer;
}
Always return null. Because "read = _inner.Read(buffer, 0, length)" always return 101, with every value "length".
Thanks so much for your help.

If I want to use this project without unity, where can I start

I started developing my social VR using your awesome MumbleUnity component.
I cannot manage to distinguish each connected user from each other, which is necessary in order to associate every mumble object to its owner.
At every new connection , it is easy to istantiate the new user/player, and associating the new MumbleAudioPlayer.
However, starting from two players on, every new user receives its object , but cannot distinguish which of the two objects he finds (o1, o2) belongs to User A or User B.

How can I "label" every MumbleAudioPlayer with its owner?

How i can whisper to a client?
i find the function _manageSendBuffer.SendVoice(floatData, SpeechTarget.DirectWhisper1, 0), but i don't know where find the targetid to select the client i choose.

best regards,
Capitanio Fabio

For our case, we have multiple people in the same room talking to each other. The main problem we are facing is that the mics are picking up other people's audio and playing it back so they hear themselves echo. The main thing I was using to deal with this was the mic threshold value, trying to find the sweetspot to get rid of outside audio while still picking up the main person's mic. While this works, it obviously has some edge cases where someone can be yelling far away or the person who has the mic talks too quietly.

I was wondering, is there another setting you know of that can help with this issue, or is threshold the way to go? If not, you can go ahead and close this, was just checking to see if I wasn't missing anything.