Skip to content

Commit

Permalink
Merge pull request #11 from hungrymonkey/mumble_add_positional
Browse files Browse the repository at this point in the history 
Mumble code cleanup
  • Loading branch information
@jcalifornia
jcalifornia authored Oct 20, 2017
2 parents ac1ffb7 + dc29a9a commit 4ffcfc5
Show file tree
Hide file tree
Showing 13 changed files with 240 additions and 245 deletions.
87 changes: 34 additions & 53 deletions modules/mumble/callback.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;
}
81 changes: 26 additions & 55 deletions modules/mumble/callback.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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
126 changes: 57 additions & 69 deletions modules/mumble/mumble.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;
}
Loading

0 comments on commit 4ffcfc5

Please sign in to comment.