Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Mumble code cleanup #11

Merged
merged 7 commits into from
Oct 20, 2017
Merged

Mumble code cleanup #11

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
82c6ffd
added crude incoming position data
hungrymonkey Oct 18, 2017
4232023
added positional data send
hungrymonkey Oct 18, 2017
b53248c
Merge commit '423202357e89af45f54181fe1dc467d2a4fbee53' into mumble_a…
hungrymonkey Oct 18, 2017
8cacf8c
change spaces to tabs like the rest of the godot
hungrymonkey Oct 18, 2017
cb73a44
well, it compiles. i have to test it
hungrymonkey Oct 18, 2017
de5e9fd
i cannot seem to figure out how to use godot to play sound
hungrymonkey Oct 18, 2017
dc29a9a
added a position vector to the signal
hungrymonkey Oct 19, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
87 changes: 34 additions & 53 deletions modules/mumble/callback.cpp
View file
Open in desktop
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
Open in desktop
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
Open in desktop
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