diff --git a/modules/mumble/callback.cpp b/modules/mumble/callback.cpp
index e9c7fa8bf3f1..e0ded848a0fe 100644
--- a/modules/mumble/callback.cpp
+++ b/modules/mumble/callback.cpp
@@ -2,66 +2,47 @@
 #include "utils.h"
 #include "variant.h"
 #include "print_string.h"
+#include "math/vector3.h"
 #include "scene/resources/audio_stream_sample.h"
 
-SimpleCallback::SimpleCallback() : _callback(*this) { }
-SimpleCallback::~SimpleCallback() { }
-mumlib::Callback *SimpleCallback::get_callback(){
-    return &_callback;
-}
-void SimpleCallback::MyCallBack::audio( int target,
-                       int sessionId,
-                       int sequenceNumber,
-                       int16_t *pcm_data,
-                       uint32_t pcm_data_size){
-   if(!_cb._audio_handler.is_null()){
-        Variant sid(sessionId);
-        Variant snum(sequenceNumber);
-        Ref<AudioStreamSample> sam = Ref<AudioStreamSample>(utils::pcm2Sample(pcm_data, pcm_data_size));    
-        Variant pcm(sam);
 
-        Variant::CallError err;
-        const Variant *args[3] = { &sid, &snum, &pcm};
-        Variant result =  _cb._audio_handler->call_func( args, 3, err);
-   }
+
+void MyCallBack::audio( int target,
+	int sessionId, int sequenceNumber, int16_t *pcm_data,
+	uint32_t pcm_data_size, float position[3]){
+	Variant sid(sessionId);
+	Variant snum(sequenceNumber);
+	Ref<AudioStreamSample> sam = Ref<AudioStreamSample>(utils::pcm2Sample(pcm_data, pcm_data_size));    
+	Variant pcm(sam);
+	Variant tar(target);
+	Vector3 pos(position[0],position[1],position[2]);
+//	Variant::CallError err;
+	Variant result = _mumble_ref.emit_signal( "audio_message", pcm, pos, tar, sid );
 }
 
 
-void SimpleCallback::MyCallBack::textMessage(
-            uint32_t actor,
-            std::vector<uint32_t> session,
-            std::vector<uint32_t> channel_id,
-            std::vector<uint32_t> tree_id,
-	    std::string message) {
-   if(!_cb._text_handler.is_null()){
-        Variant s = utils::cpp_uint32vec2Variant(session);
-        Variant c = utils::cpp_uint32vec2Variant(channel_id);
-        Variant t = utils::cpp_uint32vec2Variant(tree_id);
-        Variant a(actor);
-        Variant m(String(message.c_str()));
-        Variant::CallError err;
-        const Variant *args[5] = {&a, &s, &c, &t, &m};
-        Variant result =  _cb._text_handler->call_func( args, 5, err );
-   }
+void MyCallBack::textMessage(
+			uint32_t actor,
+			std::vector<uint32_t> session,
+			std::vector<uint32_t> channel_id,
+			std::vector<uint32_t> tree_id,
+			std::string message) {
+	Variant s = utils::cpp_uint32vec2Variant(session);
+	Variant c = utils::cpp_uint32vec2Variant(channel_id);
+	Variant t = utils::cpp_uint32vec2Variant(tree_id);
+	Variant a(actor);
+	Variant m(String(message.c_str()));
+//		Variant::CallError err;
+//		const Variant *args[5] = {&a, &s, &c, &t, &m};
+	Variant result =  _mumble_ref.emit_signal( "text_message", m, a );
 
 }
-void SimpleCallback::MyCallBack::version(
-                uint16_t major,
-                uint8_t minor,
-                uint8_t patch,
-                std::string release,
-                std::string os,
-                std::string os_version){ }
-                
-void SimpleCallback::_bind_methods(){
-   ClassDB::bind_method(D_METHOD("setAudioHandler", "handler"), &SimpleCallback::setAudioHandler);
-   ClassDB::bind_method(D_METHOD("setTextHandler", "handler"), &SimpleCallback::setTextHandler);
+void MyCallBack::version(
+				uint16_t major,
+				uint8_t minor,
+				uint8_t patch,
+				std::string release,
+				std::string os,
+				std::string os_version){ }
 
-}
 
-void SimpleCallback::setAudioHandler(  Ref<FuncRef> handler){
-   this->_audio_handler = handler;
-}
-void SimpleCallback::setTextHandler( Ref<FuncRef> handler){
-   this->_text_handler = handler;
-}
diff --git a/modules/mumble/callback.h b/modules/mumble/callback.h
index b4e76ff24bc0..3ebe3fbd252d 100644
--- a/modules/mumble/callback.h
+++ b/modules/mumble/callback.h
@@ -3,67 +3,38 @@
 #define SimpleCALLBACK_H
 
 #include "reference.h"
-#include "ustring.h"
-#include "func_ref.h"
 #include <string.h>
 #include <mumlib/Callback.hpp>
 #include <vector>
-#include "scene/resources/audio_stream_sample.h"
 
-class SimpleCallback : public Reference {
-    GDCLASS(SimpleCallback,Reference);
+class MyCallBack : public mumlib::Callback{
 
-
-protected:
-//    bool _set(const StringName &p_name, const Variant &p_value);
-//    bool _get(const StringName &p_name, Variant &r_ret) const;
-//    void _get_property_list(List<PropertyInfo> *p_list) const;
-    static void _bind_methods();
-   
-private:
-    Ref<FuncRef>  _audio_handler;
-    Ref<FuncRef>  _text_handler;
-    
-    class MyCallBack : public mumlib::Callback{
-    protected:
-        static void _bind_methods();
-
-    public:
-        MyCallBack( SimpleCallback &o ): _cb(o){
-        };
-        virtual void audio(int target,
-                        int sessionId,
-                        int sequenceNumber,
-                        int16_t *pcm_data,
-                uint32_t pcm_data_size)  ;
-
-        virtual void textMessage(
-                uint32_t actor,
-                std::vector<uint32_t> session,
-                std::vector<uint32_t> channel_id,
-                std::vector<uint32_t> tree_id,
-                std::string message);
-
-        virtual void version(
-                    uint16_t major,
-                    uint8_t minor,
-                    uint8_t patch,
-                    std::string release,
-                    std::string os,
-            std::string os_version);
-    private:
-        SimpleCallback &_cb;
-    };
-    MyCallBack _callback;
 public:
-     SimpleCallback();
-    ~SimpleCallback();
-     mumlib::Callback * get_callback();
-   
-    void setAudioHandler(Ref<FuncRef> handler);
-    void setTextHandler(Ref<FuncRef> handler);
-
-
+	MyCallBack( Object &o ): _mumble_ref(o){
+	};
+	virtual void audio(int target,
+			int sessionId,
+			int sequenceNumber,
+			int16_t *pcm_data,
+			uint32_t pcm_data_size,
+			float position [3]);
+	virtual void textMessage(
+		uint32_t actor,
+		std::vector<uint32_t> session,
+		std::vector<uint32_t> channel_id,
+		std::vector<uint32_t> tree_id,
+		std::string message);
+
+	virtual void version(
+		uint16_t major,
+		uint8_t minor,
+		uint8_t patch,
+		std::string release,
+		std::string os,
+		std::string os_version);
+private:
+	Object &_mumble_ref;
 };
 
+
 #endif
diff --git a/modules/mumble/mumble.cpp b/modules/mumble/mumble.cpp
index 109e6444645c..ac093a663239 100644
--- a/modules/mumble/mumble.cpp
+++ b/modules/mumble/mumble.cpp
@@ -9,101 +9,89 @@
 #include <string>
 #include "scene/main/timer.h"
 
+Mumble::Mumble() : _cb(*this) {
+	_pMumble = Ref<_PrivateMumble>(memnew(_PrivateMumble(_cb)));
+}
+
 Mumble::_PrivateMumble::_PrivateMumble( mumlib::Callback & c) : _mum(c) {
 }
 void Mumble::_PrivateMumble::engage(String host, int port, String user, String password){
-   std::string h = utils::gstr2cpp_str(host);
-   std::string u = utils::gstr2cpp_str(user);
-   std::string p = utils::gstr2cpp_str(password);
-   while(true){
-        try{
-            this->_mum.connect(h, port,  u, p);
-            print_line( "Mumble: connecting to " + host );
-            this->_mum.run();
-        }catch (mumlib::TransportException &exp) {
-            print_line( "Mumble: error " + utils::cpp_str2gstr(exp.what()));
-            print_line( "Mumble: attempting to reconnect in 5s. ");
-            Timer * sleep = memnew(Timer);
-            sleep -> set_wait_time(5.0);
-            sleep -> start();
-            memdelete(sleep);
-            
-        }
-   }
+	std::string h = utils::gstr2cpp_str(host);
+	std::string u = utils::gstr2cpp_str(user);
+	std::string p = utils::gstr2cpp_str(password);
+	this->_mum.connect(h, port,  u, p);
+	this -> start();
+}
+void Mumble::_PrivateMumble::start(){
+	while(true){
+		try{
+			this->_mum.run();
+		}catch (mumlib::TransportException &exp) {
+			print_line( "Mumble: error " + utils::cpp_str2gstr(exp.what()));
+			print_line( "Mumble: attempting to reconnect in 5s. ");
+			Timer * sleep = memnew(Timer);
+			sleep -> set_wait_time(5.0);
+			sleep -> start();
+			memdelete(sleep);
+		}
+	}
 }
 
+
+
 void Mumble::_PrivateMumble::sendText(const String text){
-   _mum.sendTextMessage( utils::gstr2cpp_str(text) );
+	_mum.sendTextMessage( utils::gstr2cpp_str(text) );
 }
 
 void Mumble::_PrivateMumble::send16bAudio(const PoolByteArray & sample){
-    uint32_t pcm_len = sample.size()/2;
-    int16_t pcm[50000];
-    for(int i = 0; i < pcm_len; i++){
-        uint16_t low = (uint16_t) sample[2*i];
-        uint16_t hi = (uint16_t) sample[2*i+1];
-        pcm[i] = ( low | ( hi << 8));
-     }
-     _mum.sendAudioData(pcm, pcm_len);
+	uint32_t pcm_len = sample.size()/2;
+	int16_t pcm[50000];
+	for(int i = 0; i < pcm_len; i++){
+		uint16_t low = (uint16_t) sample[2*i];
+		uint16_t hi = (uint16_t) sample[2*i+1];
+		pcm[i] = ( low | ( hi << 8));
+	}
+	_mum.sendAudioData(pcm, pcm_len);
 }
 
 void Mumble::_bind_methods() {
-    ClassDB::bind_method(D_METHOD("add", "value"), &Mumble::add);
-    ClassDB::bind_method(D_METHOD("reset"), &Mumble::reset);
-    ClassDB::bind_method(D_METHOD("get_total"), &Mumble::get_total);
+	ClassDB::bind_method(D_METHOD("engage", "host", "port", "user", "password"), &Mumble::engage);
+	ClassDB::bind_method(D_METHOD("disengage"), &Mumble::disengage);
+//	ClassDB::bind_method(D_METHOD("start"), &Mumble::start);
 
-    ClassDB::bind_method(D_METHOD("engage", "host", "port", "user", "password"), &Mumble::engage);
-    ClassDB::bind_method(D_METHOD("setCallback", "callback"), &Mumble::setCallback);
-    ClassDB::bind_method(D_METHOD("sendText", "text"), &Mumble::sendText);
-    ClassDB::bind_method(D_METHOD("sendAudio", "sample"), &Mumble::sendAudio);
+	ClassDB::bind_method(D_METHOD("sendText", "text"), &Mumble::sendText);
+	ClassDB::bind_method(D_METHOD("sendAudio", "sample"), &Mumble::sendAudio);
+	ADD_SIGNAL(MethodInfo("audio_message", PropertyInfo(Variant::OBJECT, "audio_sample"), PropertyInfo(Variant::VECTOR3, "position"), PropertyInfo(Variant::INT, "target"), PropertyInfo(Variant::INT, "session_id")));
+	ADD_SIGNAL(MethodInfo("text_message", PropertyInfo(Variant::STRING, "message"), PropertyInfo(Variant::INT, "actor")));
 
 }
 void Mumble::engage(String host, int port, String user, String password) {
-   _pMumble -> engage( host,  port,  user,  password);
+	_pMumble -> engage( host,  port,  user,  password);
 }
 
-void Mumble::setCallback( Ref<SimpleCallback> cb){
-
-   _pMumble = Ref<_PrivateMumble>(memnew(_PrivateMumble(*(cb->get_callback()))));
+void Mumble::disengage(){
+	_pMumble->disengage();
+}
+void Mumble::start(){
+	_pMumble->start();
 }
 void Mumble::sendText(const String text){
-   _pMumble -> sendText( text );
+	_pMumble -> sendText( text );
 }
 
 void Mumble::sendAudio(Ref<AudioStreamSample> sample){
 
-    const PoolByteArray data = sample->get_data();
+	const PoolByteArray data = sample->get_data();
 
 
-    if(data.size() > 0){
-        switch(sample->get_format()){
-            case AudioStreamSample::FORMAT_16_BITS:         
-                _pMumble->send16bAudio(data);
-            default:
-                return;
-        }
-    }
+	if(data.size() > 0){
+		switch(sample->get_format()){
+			case AudioStreamSample::FORMAT_16_BITS:         
+				_pMumble->send16bAudio(data);
+			default:
+				return;
+		}
+	}
     
 }
 
-
-
-Mumble::Mumble() {
-    count=0;
-}
-
-void Mumble::add(int value) {
-
-    count+=value;
-}
-
-void Mumble::reset() {
-
-    count=0;
-}
-
-
-int Mumble::get_total() const {
-
-    return count;
-}
diff --git a/modules/mumble/mumble.h b/modules/mumble/mumble.h
index 1527072d9a23..601890b2e9ce 100644
--- a/modules/mumble/mumble.h
+++ b/modules/mumble/mumble.h
@@ -9,37 +9,36 @@
 #include "callback.h"
 
 class Mumble :  public Reference {
-    GDCLASS(Mumble,Reference);
-    int count;
+	GDCLASS(Mumble,Reference);
 private:
-    
-    
-    class _PrivateMumble: public Reference {
-        GDCLASS(_PrivateMumble,Reference);
-    private:
-        mumlib::Mumlib _mum;
-    public:
-        _PrivateMumble(mumlib::Callback & c);
-        void engage(String host, int port, String user, String password);
-        void sendText(const String text);
-        void send16bAudio(const PoolByteArray & arr);
-    };
-    Ref<_PrivateMumble> _pMumble;
+	class _PrivateMumble: public Reference {
+		GDCLASS(_PrivateMumble,Reference);
+	private:
+		mumlib::Mumlib _mum;
+	public:
+		_PrivateMumble(mumlib::Callback & c);
+		void engage(String host, int port, String user, String password);
+		void sendText(const String text);
+		void send16bAudio(const PoolByteArray & arr);
+		void disengage() { _mum.disconnect(); }
+		void start();
+	};
+	Ref<_PrivateMumble> _pMumble;
 
 protected:
-    static void _bind_methods();
+	static void _bind_methods();
 
 public:
-    void add(int value);
-    void reset();
-    int get_total() const;
-    void engage(String host, int port, String user, String password);
-    void setCallback( Ref<SimpleCallback> c );
-    void sendText(const String message);
-    void sendAudio(Ref<AudioStreamSample> sample);
-//    void sendAudio(PoolByteArray sample);
-    Mumble();
+
+	void engage(String host, int port, String user, String password);
+	void disengage();
+	void start();
+	void sendText(const String message);
+	void sendAudio(Ref<AudioStreamSample> sample);
+	Mumble();
 //    ~Mumble();
+private:
+	MyCallBack _cb;
 };
 
 #endif
diff --git a/modules/mumble/register_types.cpp b/modules/mumble/register_types.cpp
index 0df991f8f9fd..d67ac9ee0fe2 100644
--- a/modules/mumble/register_types.cpp
+++ b/modules/mumble/register_types.cpp
@@ -7,8 +7,7 @@
 
 void register_mumble_types() {
 
-        ClassDB::register_class<Mumble>();
-        ClassDB::register_class<SimpleCallback>();
+	ClassDB::register_class<Mumble>();
 }
 
 void unregister_mumble_types() {
diff --git a/modules/mumble/utils.cpp b/modules/mumble/utils.cpp
index 05b055e15001..6c8162904d98 100644
--- a/modules/mumble/utils.cpp
+++ b/modules/mumble/utils.cpp
@@ -5,36 +5,35 @@
 
 
 std::string utils::gstr2cpp_str(String s){
-           std::wstring ws(s.c_str());
-           std::string str(ws.begin(), ws.end());
-           return str;
+	std::wstring ws(s.c_str());
+	std::string str(ws.begin(), ws.end());
+	return str;
 };
 String utils::cpp_str2gstr(std::string s){
-       return String(s.c_str());
+	return String(s.c_str());
 }
 Variant utils::cpp_uint32vec2Variant(  const std::vector<uint32_t> &v ){
-        Vector<Variant> ret;
-        ret.resize(v.size());
-        for( int i = 0; i < v.size(); i++){
-            ret[i] = (Variant( (uint64_t)v[i]));
-        }
-        return ret;
+	Vector<Variant> ret;
+	ret.resize(v.size());
+	for( int i = 0; i < v.size(); i++){
+		ret[i] = (Variant( (uint64_t)v[i]));
+	}
+	return ret;
 }
 
 
 AudioStreamSample *utils::pcm2Sample( const int16_t * pcm_data, uint32_t size){
-    PoolByteArray d;
-    d.resize(size * 2);
-    AudioStreamSample *sam = memnew(AudioStreamSample);
-    sam->set_format(AudioStreamSample::FORMAT_16_BITS);
-    sam->set_loop_mode(AudioStreamSample::LOOP_DISABLED);
-    for( int i=0; i < size; i++){
-         uint16_t sh = (uint16_t) pcm_data[i];
-         d.set( i*2 ,  (uint8_t) (sh & 0xFF) );
-         d.set( i*2+1 , (uint8_t) (sh >> 8));
-    }
+	PoolByteArray d;
+	d.resize(size * 2);
+	AudioStreamSample *sam = memnew(AudioStreamSample);
+	sam->set_format(AudioStreamSample::FORMAT_16_BITS);
+	sam->set_loop_mode(AudioStreamSample::LOOP_DISABLED);
+	for( int i=0; i < size; i++){
+		uint16_t sh = (uint16_t) pcm_data[i];
+		d.set( i*2 ,  (uint8_t) (sh & 0xFF) );
+		d.set( i*2+1, (uint8_t) (sh >> 8));
+	}
 
-
-    sam->set_data(d);
-    return sam;
+	sam->set_data(d);
+	return sam;
 }
diff --git a/modules/mumble/utils.h b/modules/mumble/utils.h
index 6626a4337c2c..78ad0e0b039b 100644
--- a/modules/mumble/utils.h
+++ b/modules/mumble/utils.h
@@ -6,8 +6,8 @@
 #include "variant.h"
 
 namespace utils{
-    std::string gstr2cpp_str(String s);
-    String cpp_str2gstr(std::string s);
-    Variant cpp_uint32vec2Variant(  const std::vector<uint32_t> &v );
-    AudioStreamSample *pcm2Sample( const int16_t * pcm_data, uint32_t size);
+	std::string gstr2cpp_str(String s);
+	String cpp_str2gstr(std::string s);
+	Variant cpp_uint32vec2Variant(  const std::vector<uint32_t> &v );
+	AudioStreamSample *pcm2Sample( const int16_t * pcm_data, uint32_t size);
 }
diff --git a/thirdparty/mumlib/include/mumlib.hpp b/thirdparty/mumlib/include/mumlib.hpp
index 95afe0229e4b..9e58b6c265e2 100644
--- a/thirdparty/mumlib/include/mumlib.hpp
+++ b/thirdparty/mumlib/include/mumlib.hpp
@@ -49,6 +49,8 @@ namespace mumlib {
         ConnectionState getConnectionState();
 
         void sendAudioData(int16_t *pcmData, int pcmLength);
+        
+        void sendAudioData(int16_t *pcmData, int pcmLength, float position[3]);
 
         void sendTextMessage(std::string message);
 
diff --git a/thirdparty/mumlib/include/mumlib/Audio.hpp b/thirdparty/mumlib/include/mumlib/Audio.hpp
index d98f41a1551f..43b69f7f56e4 100644
--- a/thirdparty/mumlib/include/mumlib/Audio.hpp
+++ b/thirdparty/mumlib/include/mumlib/Audio.hpp
@@ -24,6 +24,8 @@ namespace mumlib {
         int64_t sequenceNumber;
         uint8_t *audioPayload;
         int audioPayloadLength;
+        float position[3];
+
     };
 
     class Audio : boost::noncopyable {
@@ -62,4 +64,4 @@ namespace mumlib {
 
         std::chrono::time_point<std::chrono::system_clock> lastEncodedAudioPacketTimestamp;
     };
-}
\ No newline at end of file
+}
diff --git a/thirdparty/mumlib/include/mumlib/Callback.hpp b/thirdparty/mumlib/include/mumlib/Callback.hpp
index a11b7b4a89d1..8106168cee28 100644
--- a/thirdparty/mumlib/include/mumlib/Callback.hpp
+++ b/thirdparty/mumlib/include/mumlib/Callback.hpp
@@ -24,6 +24,14 @@ namespace mumlib {
                 int sequenceNumber,
                 int16_t *pcm_data,
                 uint32_t pcm_data_size) { };
+                
+        virtual void audio(
+                int target,
+                int sessionId,
+                int sequenceNumber,
+                int16_t *pcm_data,
+                uint32_t pcm_data_size,
+                float position[3]) { };
 
         virtual void unsupportedAudio(
                 int target,
@@ -69,6 +77,7 @@ namespace mumlib {
                 int32_t self_mute,
                 int32_t self_deaf,
                 string comment,
+                string plugin_context,
                 int32_t priority_speaker,
                 int32_t recording) { };
 
@@ -167,6 +176,14 @@ namespace mumlib {
                 int sequenceNumber,
                 int16_t *pcm_data,
                 uint32_t pcm_data_size) override;
+                
+        virtual void audio(
+                int target,
+                int sessionId,
+                int sequenceNumber,
+                int16_t *pcm_data,
+                uint32_t pcm_data_size,
+                float position[3]) override;
 
         virtual void unsupportedAudio(
                 int target,
@@ -212,6 +229,7 @@ namespace mumlib {
                 int32_t self_mute,
                 int32_t self_deaf,
                 string comment,
+                string plugin_context,
                 int32_t priority_speaker,
                 int32_t recording) override;
 
@@ -289,4 +307,4 @@ namespace mumlib {
     private:
         _BasicCallback_Private *impl;
     };
-}
\ No newline at end of file
+}
diff --git a/thirdparty/mumlib/src/Audio.cpp b/thirdparty/mumlib/src/Audio.cpp
index 3ce75944b03e..e4ec1fe2baee 100644
--- a/thirdparty/mumlib/src/Audio.cpp
+++ b/thirdparty/mumlib/src/Audio.cpp
@@ -173,15 +173,23 @@ mumlib::IncomingAudioPacket mumlib::Audio::decodeIncomingAudioPacket(uint8_t *in
         throw AudioException((boost::format("invalid incoming audio packet (%d B): header %d B") % inputBufferLength %
                               dataPointer).str());
     }
-
+    //https://commandcenter.blogspot.de/2012/04/byte-order-fallacy.html
+    uint32_t * pos = (uint32_t *) incomingAudioPacket.position;
+    pos[2] = (inputBuffer[inputBufferLength-4] << 0) | (inputBuffer[inputBufferLength-3] << 8) |(inputBuffer[inputBufferLength-2] << 16 ) | (inputBuffer[inputBufferLength-1] << 24); //set z
+    pos[1] = (inputBuffer[inputBufferLength-8] << 0) | (inputBuffer[inputBufferLength-7] << 8) |(inputBuffer[inputBufferLength-6] << 16 ) | (inputBuffer[inputBufferLength-5] << 24); //set y
+    pos[0] = (inputBuffer[inputBufferLength-12] << 0) | (inputBuffer[inputBufferLength-11] << 8) |(inputBuffer[inputBufferLength-10] << 16 ) | (inputBuffer[inputBufferLength-9] << 24); //set x
+    incomingAudioPacket.audioPayloadLength -= 12; //remove 12 bytes of position data
     logger.debug(
-            "Received %d B of audio packet, %d B header, %d B payload (target: %d, sessionID: %ld, seq num: %ld).",
+            "Received %d B of audio packet, %d B header, %d B payload (target: %d, sessionID: %ld, seq num: %ld). %f,%f,%f, position",
             inputBufferLength,
             dataPointer,
             incomingAudioPacket.audioPayloadLength,
             incomingAudioPacket.target,
             incomingAudioPacket.sessionId,
-            incomingAudioPacket.sequenceNumber);
+            incomingAudioPacket.sequenceNumber,
+            incomingAudioPacket.position[0],
+            incomingAudioPacket.position[1],
+            incomingAudioPacket.position[2]);
 
     return incomingAudioPacket;
 }
diff --git a/thirdparty/mumlib/src/Callback.cpp b/thirdparty/mumlib/src/Callback.cpp
index ea8fb804ddff..060724d8c8f2 100644
--- a/thirdparty/mumlib/src/Callback.cpp
+++ b/thirdparty/mumlib/src/Callback.cpp
@@ -41,8 +41,18 @@ void mumlib::BasicCallback::audio(
         int sequenceNumber,
         int16_t *pcmData,
         uint32_t pcm_data_size) {
-    impl->logger.debug("audio: %d bytes of raw PCM data, target: %d, session: %d, seq: %d.",
-                       pcm_data_size, target, sessionId, sequenceNumber);
+}
+
+void mumlib::BasicCallback::audio(
+        int target,
+        int sessionId,
+        int sequenceNumber,
+        int16_t *pcmData,
+        uint32_t pcm_data_size,
+        float position[3]) {
+    impl->logger.debug("audio: %d bytes of raw PCM data, target: %d, session: %d, seq: %d. pos: %f,%f,%f",
+                       pcm_data_size, target, sessionId, sequenceNumber, position[0], position[1], position[2]);
+    this -> audio(target, sessionId, sequenceNumber, pcmData, pcm_data_size);
 }
 
 void BasicCallback::unsupportedAudio(
@@ -68,18 +78,17 @@ void BasicCallback::channelRemove(uint32_t channel_id) {
 void BasicCallback::channelState(string name, int32_t channel_id, int32_t parent, string description,
                                  vector<uint32_t> links, vector<uint32_t> inks_add, vector<uint32_t> links_remove,
                                  bool temporary, int32_t position) {
-    impl->logger.debug("channelState: %d: %s, %s", channel_id, name.c_str(), description.c_str());
+    impl->logger.debug("channelState: %d: %s, %s, %d", channel_id, name.c_str(), description.c_str());
 }
 
 void BasicCallback::userRemove(uint32_t session, int32_t actor, string reason, bool ban) {
     impl->logger.debug("userRemove: session: %d, actor: %d, reason: %s, ban: %d.", session, actor, reason.c_str(), ban);
 }
 
-void BasicCallback::userState(int32_t session, int32_t actor, string name, int32_t user_id, int32_t channel_id,
-                              int32_t mute, int32_t deaf, int32_t suppress, int32_t self_mute, int32_t self_deaf,
-                              string comment, int32_t priority_speaker, int32_t recording) {
-    impl->logger.debug("userState: %s: mute: %d, deaf: %d, suppress: %d, self mute: %d, self deaf: %d",
-                       name.c_str(), mute, deaf, suppress, self_mute, self_deaf);
+void mumlib::BasicCallback::userState(int session, int actor, std::__cxx11::string name, int user_id, int channel_id, int mute, int deaf, int suppress, int self_mute, int self_deaf, std::__cxx11::string comment, std::__cxx11::string plugin_context, int priority_speaker, int recording)
+{
+    impl->logger.debug("userState: %s: mute: %d, deaf: %d, suppress: %d, self mute: %d, self deaf: %d, plugin context: %s",
+                       name.c_str(), mute, deaf, suppress, self_mute, self_deaf, plugin_context.c_str());
 }
 
 void BasicCallback::banList(const uint8_t *ip_data, uint32_t ip_data_size, uint32_t mask, string name, string hash,
diff --git a/thirdparty/mumlib/src/mumlib.cpp b/thirdparty/mumlib/src/mumlib.cpp
index 08197d1a39d4..5ec2b2f70423 100644
--- a/thirdparty/mumlib/src/mumlib.cpp
+++ b/thirdparty/mumlib/src/mumlib.cpp
@@ -70,7 +70,8 @@ namespace mumlib {
                                    incomingAudioPacket.sessionId,
                                    incomingAudioPacket.sequenceNumber,
                                    pcmData,
-                                   status.first);
+                                   status.first,
+                                   incomingAudioPacket.position);
                 } else {
                     logger.warn("Incoming audio packet doesn't contain Opus data, calling unsupportedAudio callback.");
                     callback.unsupportedAudio(incomingAudioPacket.target,
@@ -197,6 +198,7 @@ namespace mumlib {
                     int32_t suppress = userState.has_suppress() ? userState.suppress() : -1;
                     int32_t self_mute = userState.has_self_mute() ? userState.self_mute() : -1;
                     int32_t self_deaf = userState.has_self_deaf() ? userState.self_deaf() : -1;
+                    std::string plugin_context = userState.has_plugin_context() ? userState.plugin_context() : "";
                     int32_t priority_speaker = userState.has_priority_speaker() ? userState.priority_speaker() : -1;
                     int32_t recording = userState.has_recording() ? userState.recording() : -1;
 
@@ -211,6 +213,7 @@ namespace mumlib {
                                        self_mute,
                                        self_deaf,
                                        userState.comment(),
+                                       plugin_context,
                                        priority_speaker,
                                        recording);
                 }
@@ -389,6 +392,22 @@ namespace mumlib {
         int length = impl->audio.encodeAudioPacket(0, pcmData, pcmLength, encodedData, 5000);
         impl->transport.sendEncodedAudioPacket(encodedData, length);
     }
+    
+    void Mumlib::sendAudioData(int16_t *pcmData, int pcmLength, float position[3]) {
+        uint8_t encodedData[5000];
+        int length = impl->audio.encodeAudioPacket(0, pcmData, pcmLength, encodedData, 4988);
+        uint32_t * pos = (uint32_t *) position;
+        encodedData[length] = (pos[0] >> 24) & 0xFF; encodedData[length + 1] = (pos[0] >> 16) & 0xFF;
+        encodedData[length + 2] = (pos[0] >> 8) & 0xFF; encodedData[length + 3] = (pos[0] >> 0) & 0xFF;
+        
+        encodedData[length + 4] = (pos[1] >> 24) & 0xFF; encodedData[length + 5] = (pos[1] >> 16) & 0xFF;
+        encodedData[length + 6] = (pos[1] >> 8) & 0xFF; encodedData[length + 7] = (pos[1] >> 0) & 0xFF;
+        
+        encodedData[length + 8] = (pos[2] >> 24) & 0xFF; encodedData[length + 9] = (pos[2] >> 16) & 0xFF;
+        encodedData[length + 10] = (pos[2] >> 8) & 0xFF; encodedData[length + 11] = (pos[2] >> 0) & 0xFF;
+        
+        impl->transport.sendEncodedAudioPacket(encodedData, length + 12);
+    }
 
     void Mumlib::sendTextMessage(string message) {
         MumbleProto::TextMessage textMessage;