/*******************************************************************************
* plugins/VOIP/services/p3VOIP.cc *
* *
* Copyright (C) 2015 by Retroshare Team <retroshare.project@gmail.com> *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Affero General Public License as *
* published by the Free Software Foundation, either version 3 of the *
* License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Affero General Public License for more details. *
* *
* You should have received a copy of the GNU Affero General Public License *
* along with this program. If not, see <https://www.gnu.org/licenses/>. *
* *
*******************************************************************************/
#include "util/rsdir.h"
#include "retroshare/rsiface.h"
#include "pqi/pqibin.h"
#include "pqi/pqistore.h"
#include "pqi/p3linkmgr.h"
#include <serialiser/rsserial.h>
#include <rsitems/rsconfigitems.h>
#include <sstream> // for std::istringstream
#include "services/p3VOIP.h"
#include "services/rsVOIPItems.h"
#include "gui/VOIPNotify.h"
#include <sys/time.h>
/****
* #define DEBUG_VOIP 1
****/
/* DEFINE INTERFACE POINTER! */
RsVOIP *rsVOIP = NULL;
#define MAX_PONG_RESULTS 150
#define VOIP_PING_PERIOD 10
#define VOIP_BANDWIDTH_PERIOD 5
/************ IMPLEMENTATION NOTES *********************************
*
* Voice over Retroshare ;)
*
* This will be a simple test VoIP system aimed at testing out the possibilities.
*
* Important things to test:
* 1) lag, and variability in data rate
* - To do this we time tag every packet..., the destination can use this info to calculate the results.
* - Like imixitup. Dt = clock_diff + lag.
* we expect clock_diff to be relatively constant, but lag to vary.
* lag cannot be negative, so minimal Dt is ~clock_diff, and delays on this are considered +lag.
*
* 2) we could directly measure lag. ping back and forth with Timestamps.
*
* 3) we also want to measure bandwidth...
* - not sure the best method?
* one way: send a ping, then a large amount of data (5 seconds worth), then another ping.
* the delta in timestamps should be a decent indication of bandwidth.
* say we have a 100kb/s connection... need 500kb.
* actually the amount of data should be based on a reasonable maximum that we require.
* what does decent video require?
* Audio we can test for 64kb/s - which seems like a decent rate: e.g. mono, 16bit 22k = 1 x 2 x 22k = 44 kilobytes/sec
* best to do this without a VoIP call going on ;)
*
*
*/
#ifdef WINDOWS_SYS
#include <time.h>
#include <sys/timeb.h>
#endif
static double getCurrentTS()
{
#ifndef WINDOWS_SYS
struct timeval cts_tmp;
gettimeofday(&cts_tmp, NULL);
double cts = (cts_tmp.tv_sec) + ((double) cts_tmp.tv_usec) / 1000000.0;
#else
struct _timeb timebuf;
_ftime( &timebuf);
double cts = (timebuf.time) + ((double) timebuf.millitm) / 1000.0;
#endif
return cts;
}
static uint64_t convertTsTo64bits(double ts)
{
uint32_t secs = (uint32_t) ts;
uint32_t usecs = (uint32_t) ((ts - (double) secs) * 1000000);
uint64_t bits = (((uint64_t) secs) << 32) + usecs;
return bits;
}
static double convert64bitsToTs(uint64_t bits)
{
uint32_t usecs = (uint32_t) (bits & 0xffffffff);
uint32_t secs = (uint32_t) ((bits >> 32) & 0xffffffff);
double ts = (secs) + ((double) usecs) / 1000000.0;
return ts;
}
p3VOIP::p3VOIP(RsPluginHandler *handler,VOIPNotify *notifier)
: RsPQIService(RS_SERVICE_TYPE_VOIP_PLUGIN,0,handler), mVOIPMtx("p3VOIP"), mServiceControl(handler->getServiceControl()) , mNotify(notifier)
{
addSerialType(new RsVOIPSerialiser());
mSentPingTime = 0;
mSentBandwidthInfoTime = 0;
mCounter = 0;
//plugin default configuration
_atransmit = 0;
_voice_hold = 75;
_vadmin = 16018;
_vadmax = 23661;
_min_loudness = 4702;
_noise_suppress = -45;
_echo_cancel = true;
}
RsServiceInfo p3VOIP::getServiceInfo()
{
const std::string TURTLE_APP_NAME = "VOIP";
const uint16_t TURTLE_APP_MAJOR_VERSION = 1;
const uint16_t TURTLE_APP_MINOR_VERSION = 0;
const uint16_t TURTLE_MIN_MAJOR_VERSION = 1;
const uint16_t TURTLE_MIN_MINOR_VERSION = 0;
return RsServiceInfo(RS_SERVICE_TYPE_VOIP_PLUGIN,
TURTLE_APP_NAME,
TURTLE_APP_MAJOR_VERSION,
TURTLE_APP_MINOR_VERSION,
TURTLE_MIN_MAJOR_VERSION,
TURTLE_MIN_MINOR_VERSION);
}
void RsVOIPDataChunk::clear()
{
if(data)
free(data) ;
data=NULL;
size=0 ;
}
int p3VOIP::tick()
{
#ifdef DEBUG_VOIP
std::cerr << "ticking p3VOIP" << std::endl;
#endif
//processIncoming();
sendPackets();
return 0;
}
int p3VOIP::status()
{
return 1;
}
int p3VOIP::sendPackets()
{
time_t now = time(NULL);
time_t pt;
time_t pt2;
{
RsStackMutex stack(mVOIPMtx); /****** LOCKED MUTEX *******/
pt = mSentPingTime;
pt2 = mSentBandwidthInfoTime;
}
if (now > pt + VOIP_PING_PERIOD)
{
sendPingMeasurements();
RsStackMutex stack(mVOIPMtx); /****** LOCKED MUTEX *******/
mSentPingTime = now;
}
if (now > pt2 + VOIP_BANDWIDTH_PERIOD)
{
sendBandwidthInfo();
RsStackMutex stack(mVOIPMtx); /****** LOCKED MUTEX *******/
mSentBandwidthInfoTime = now;
}
return true ;
}
void p3VOIP::sendBandwidthInfo()
{
std::set<RsPeerId> onlineIds;
mServiceControl->getPeersConnected(getServiceInfo().mServiceType, onlineIds);
RsStackMutex stack(mVOIPMtx); /****** LOCKED MUTEX *******/
for(std::map<RsPeerId,VOIPPeerInfo>::iterator it(mPeerInfo.begin());it!=mPeerInfo.end();++it)
{
it->second.average_incoming_bandwidth = 0.75 * it->second.average_incoming_bandwidth + 0.25 * it->second.total_bytes_received / VOIP_BANDWIDTH_PERIOD ;
it->second.total_bytes_received = 0 ;
if(onlineIds.find(it->first) == onlineIds.end() || it->second.average_incoming_bandwidth == 0)
continue ;
std::cerr << "average bandwidth for peer " << it->first << ": " << it->second.average_incoming_bandwidth << " Bps" << std::endl;
sendVoipBandwidth(it->first,it->second.average_incoming_bandwidth) ;
}
}
int p3VOIP::sendVoipHangUpCall(const RsPeerId &peer_id, uint32_t flags)
{
RsVOIPProtocolItem *item = new RsVOIPProtocolItem ;
item->protocol = RsVOIPProtocolItem::VoipProtocol_Close;
item->flags = flags ;
item->PeerId(peer_id) ;
sendItem(item) ;
return true ;
}
int p3VOIP::sendVoipAcceptCall(const RsPeerId& peer_id, uint32_t flags)
{
RsVOIPProtocolItem *item = new RsVOIPProtocolItem ;
item->protocol = RsVOIPProtocolItem::VoipProtocol_Ackn ;
item->flags = flags ;
item->PeerId(peer_id) ;
sendItem(item) ;
return true ;
}
int p3VOIP::sendVoipRinging(const RsPeerId &peer_id, uint32_t flags)
{
RsVOIPProtocolItem *item = new RsVOIPProtocolItem ;
item->protocol = RsVOIPProtocolItem::VoipProtocol_Ring ;
item->flags = flags ;
item->PeerId(peer_id) ;
sendItem(item) ;
return true ;
}
int p3VOIP::sendVoipBandwidth(const RsPeerId &peer_id,uint32_t bytes_per_sec)
{
RsVOIPProtocolItem *item = new RsVOIPProtocolItem ;
item->protocol = RsVOIPProtocolItem::VoipProtocol_Bandwidth ;
item->flags = bytes_per_sec ;
item->PeerId(peer_id) ;
sendItem(item) ;
return true ;
}
int p3VOIP::sendVoipData(const RsPeerId& peer_id,const RsVOIPDataChunk& chunk)
{
#ifdef DEBUG_VOIP
std::cerr << "Sending " << chunk.size << " bytes of voip data." << std::endl;
#endif
RsVOIPDataItem *item = new RsVOIPDataItem ;
if(!item)
{
std::cerr << "Cannot allocate RsVOIPDataItem !" << std::endl;
return false ;
}
item->voip_data = rs_malloc(chunk.size) ;
if(item->voip_data == NULL)
{
delete item ;
return false ;
}
memcpy(item->voip_data,chunk.data,chunk.size) ;
item->PeerId(peer_id) ;
item->data_size = chunk.size;
if(chunk.type == RsVOIPDataChunk::RS_VOIP_DATA_TYPE_AUDIO)
item->flags = RS_VOIP_FLAGS_AUDIO_DATA ;
else if(chunk.type == RsVOIPDataChunk::RS_VOIP_DATA_TYPE_VIDEO)
item->flags = RS_VOIP_FLAGS_VIDEO_DATA ;
else
{
std::cerr << "(EE) p3VOIP: cannot send chunk data. Unknown data type = " << chunk.type << std::endl;
delete item ;
return false ;
}
sendItem(item) ;
return true ;
}
void p3VOIP::sendPingMeasurements()
{
/* we ping our peers */
/* who is online? */
if(!mServiceControl)
return ;
std::set<RsPeerId> onlineIds;
mServiceControl->getPeersConnected(getServiceInfo().mServiceType, onlineIds);
double ts = getCurrentTS();
#ifdef DEBUG_VOIP
std::cerr << "p3VOIP::sendPingMeasurements() @ts: " << ts;
std::cerr << std::endl;
#endif
/* prepare packets */
std::set<RsPeerId>::iterator it;
for(it = onlineIds.begin(); it != onlineIds.end(); it++)
{
#ifdef DEBUG_VOIP
std::cerr << "p3VOIP::sendPingMeasurements() Pinging: " << *it;
std::cerr << std::endl;
#endif
/* create the packet */
RsVOIPPingItem *pingPkt = new RsVOIPPingItem();
pingPkt->PeerId(*it);
pingPkt->mSeqNo = mCounter;
pingPkt->mPingTS = convertTsTo64bits(ts);
storePingAttempt(*it, ts, mCounter);
#ifdef DEBUG_VOIP
std::cerr << "p3VOIP::sendPingMeasurements() With Packet:";
std::cerr << std::endl;
pingPkt->print(std::cerr, 10);
#endif
sendItem(pingPkt);
}
RsStackMutex stack(mVOIPMtx); /****** LOCKED MUTEX *******/
mCounter++;
}
void p3VOIP::handleProtocol(RsVOIPProtocolItem *item)
{
// should we keep a list of received requests?
switch(item->protocol)
{
case RsVOIPProtocolItem::VoipProtocol_Ring: mNotify->notifyReceivedVoipInvite(item->PeerId(), (uint32_t)item->flags);
#ifdef DEBUG_VOIP
std::cerr << "p3VOIP::handleProtocol(): Received protocol ring item." << std::endl;
#endif
break ;
case RsVOIPProtocolItem::VoipProtocol_Ackn: mNotify->notifyReceivedVoipAccept(item->PeerId(), (uint32_t)item->flags);
#ifdef DEBUG_VOIP
std::cerr << "p3VOIP::handleProtocol(): Received protocol accept call" << std::endl;
#endif
break ;
case RsVOIPProtocolItem::VoipProtocol_Close: mNotify->notifyReceivedVoipHangUp(item->PeerId(), (uint32_t)item->flags);
#ifdef DEBUG_VOIP
std::cerr << "p3VOIP::handleProtocol(): Received protocol Close call." << std::endl;
#endif
break ;
case RsVOIPProtocolItem::VoipProtocol_Bandwidth: mNotify->notifyReceivedVoipBandwidth(item->PeerId(),(uint32_t)item->flags);
#ifdef DEBUG_VOIP
std::cerr << "p3VOIP::handleProtocol(): Received protocol bandwidth. Value=" << item->flags << std::endl;
#endif
break ;
default:
std::cerr << "p3VOIP::handleProtocol(): Received protocol item # " << item->protocol << ": not handled yet ! Sorry" << std::endl;
break ;
}
}
void p3VOIP::handleData(RsVOIPDataItem *item)
{
RsStackMutex stack(mVOIPMtx); /****** LOCKED MUTEX *******/
// store the data in a queue.
std::map<RsPeerId,VOIPPeerInfo>::iterator it = mPeerInfo.find(item->PeerId()) ;
if(it == mPeerInfo.end())
{
std::cerr << "Peer unknown to VOIP process. Dropping data" << std::endl;
delete item ;
return ;
}
it->second.incoming_queue.push_back(item) ; // be careful with the delete action!
// For Video data, measure the bandwidth
if(item->flags & RS_VOIP_FLAGS_VIDEO_DATA)
it->second.total_bytes_received += item->data_size ;
mNotify->notifyReceivedVoipData(item->PeerId());
}
bool p3VOIP::getIncomingData(const RsPeerId& peer_id,std::vector<RsVOIPDataChunk>& incoming_data_chunks)
{
RsStackMutex stack(mVOIPMtx); /****** LOCKED MUTEX *******/
incoming_data_chunks.clear() ;
std::map<RsPeerId,VOIPPeerInfo>::iterator it = mPeerInfo.find(peer_id) ;
if(it == mPeerInfo.end())
{
std::cerr << "Peer unknown to VOIP process. No data returned. Probably a bug !" << std::endl;
return false ;
}
for(std::list<RsVOIPDataItem*>::const_iterator it2(it->second.incoming_queue.begin());it2!=it->second.incoming_queue.end();++it2)
{
RsVOIPDataChunk chunk ;
chunk.size = (*it2)->data_size ;
chunk.data = rs_malloc((*it2)->data_size) ;
if(chunk.data == NULL)
{
delete *it2 ;
continue ;
}
uint32_t type_flags = (*it2)->flags & (RS_VOIP_FLAGS_AUDIO_DATA | RS_VOIP_FLAGS_VIDEO_DATA) ;
if(type_flags == RS_VOIP_FLAGS_AUDIO_DATA)
chunk.type = RsVOIPDataChunk::RS_VOIP_DATA_TYPE_AUDIO ;
else if(type_flags == RS_VOIP_FLAGS_VIDEO_DATA)
chunk.type = RsVOIPDataChunk::RS_VOIP_DATA_TYPE_VIDEO ;
else
{
std::cerr << "(EE) p3VOIP::getIncomingData(): error. Cannot handle item with unknown type " << type_flags << std::endl;
delete *it2 ;
free(chunk.data) ;
continue ;
}
memcpy(chunk.data,(*it2)->voip_data,(*it2)->data_size) ;
incoming_data_chunks.push_back(chunk) ;
delete *it2 ;
}
it->second.incoming_queue.clear() ;
return true ;
}
bool p3VOIP::recvItem(RsItem *item)
{
/* pass to specific handler */
bool keep = false ;
switch(item->PacketSubType())
{
case RS_PKT_SUBTYPE_VOIP_PING:
handlePing(dynamic_cast<RsVOIPPingItem*>(item));
break;
case RS_PKT_SUBTYPE_VOIP_PONG:
handlePong(dynamic_cast<RsVOIPPongItem*>(item));
break;
case RS_PKT_SUBTYPE_VOIP_PROTOCOL:
handleProtocol(dynamic_cast<RsVOIPProtocolItem*>(item)) ;
break ;
case RS_PKT_SUBTYPE_VOIP_DATA:
handleData(dynamic_cast<RsVOIPDataItem*>(item));
keep = true ;
break;
#if 0
/* THESE ARE ALL FUTURISTIC DATA TYPES */
case RS_BANDWIDTH_PING_ITEM:
handleBandwidthPing(item);
break;
case RS_BANDWIDTH_PONG_ITEM:
handleBandwidthPong(item);
break;
#endif
default:
break;
}
/* clean up */
if(!keep)
delete item;
return true ;
}
int p3VOIP::handlePing(RsVOIPPingItem *ping)
{
/* cast to right type */
#ifdef DEBUG_VOIP
std::cerr << "p3VOIP::handlePing() Recvd Packet from: " << ping->PeerId();
std::cerr << std::endl;
#endif
/* with a ping, we just respond as quickly as possible - they do all the analysis */
RsVOIPPongItem *pong = new RsVOIPPongItem();
pong->PeerId(ping->PeerId());
pong->mPingTS = ping->mPingTS;
pong->mSeqNo = ping->mSeqNo;
// add our timestamp.
double ts = getCurrentTS();
pong->mPongTS = convertTsTo64bits(ts);
#ifdef DEBUG_VOIP
std::cerr << "p3VOIP::handlePing() With Packet:";
std::cerr << std::endl;
pong->print(std::cerr, 10);
#endif
sendItem(pong);
return true ;
}
int p3VOIP::handlePong(RsVOIPPongItem *pong)
{
/* cast to right type */
#ifdef DEBUG_VOIP
std::cerr << "p3VOIP::handlePong() Recvd Packet from: " << pong->PeerId();
std::cerr << std::endl;
pong->print(std::cerr, 10);
#endif
/* with a pong, we do the maths! */
double recvTS = getCurrentTS();
double pingTS = convert64bitsToTs(pong->mPingTS);
double pongTS = convert64bitsToTs(pong->mPongTS);
double rtt = recvTS - pingTS;
double offset = pongTS - (recvTS - rtt / 2.0); // so to get to their time, we go ourTS + offset.
#ifdef DEBUG_VOIP
std::cerr << "p3VOIP::handlePong() Timing:";
std::cerr << std::endl;
std::cerr << "\tpingTS: " << pingTS;
std::cerr << std::endl;
std::cerr << "\tpongTS: " << pongTS;
std::cerr << std::endl;
std::cerr << "\trecvTS: " << recvTS;
std::cerr << std::endl;
std::cerr << "\t ==> rtt: " << rtt;
std::cerr << std::endl;
std::cerr << "\t ==> offset: " << offset;
std::cerr << std::endl;
#endif
storePongResult(pong->PeerId(), pong->mSeqNo, pingTS, rtt, offset);
return true ;
}
int p3VOIP::storePingAttempt(const RsPeerId& id, double ts, uint32_t seqno)
{
RsStackMutex stack(mVOIPMtx); /****** LOCKED MUTEX *******/
/* find corresponding local data */
VOIPPeerInfo *peerInfo = locked_GetPeerInfo(id);
peerInfo->mCurrentPingTS = ts;
peerInfo->mCurrentPingCounter = seqno;
peerInfo->mSentPings++;
if (!peerInfo->mCurrentPongRecvd)
{
peerInfo->mLostPongs++;
}
peerInfo->mCurrentPongRecvd = true;
return 1;
}
int p3VOIP::storePongResult(const RsPeerId &id, uint32_t counter, double ts, double rtt, double offset)
{
RsStackMutex stack(mVOIPMtx); /****** LOCKED MUTEX *******/
/* find corresponding local data */
VOIPPeerInfo *peerInfo = locked_GetPeerInfo(id);
if (peerInfo->mCurrentPingCounter != counter)
{
#ifdef DEBUG_VOIP
std::cerr << "p3VOIP::storePongResult() ERROR Severly Delayed Measurements!" << std::endl;
#endif
}
else
{
peerInfo->mCurrentPongRecvd = true;
}
peerInfo->mPongResults.push_back(RsVOIPPongResult(ts, rtt, offset));
while(peerInfo->mPongResults.size() > MAX_PONG_RESULTS)
{
peerInfo->mPongResults.pop_front();
}
/* should do calculations */
return 1;
}
uint32_t p3VOIP::getPongResults(const RsPeerId& id, int n, std::list<RsVOIPPongResult> &results)
{
RsStackMutex stack(mVOIPMtx); /****** LOCKED MUTEX *******/
VOIPPeerInfo *peer = locked_GetPeerInfo(id);
std::list<RsVOIPPongResult>::reverse_iterator it;
int i = 0;
for(it = peer->mPongResults.rbegin(); (it != peer->mPongResults.rend()) && (i < n); it++, i++)
{
/* reversing order - so its easy to trim later */
results.push_back(*it);
}
return i ;
}
VOIPPeerInfo *p3VOIP::locked_GetPeerInfo(const RsPeerId &id)
{
std::map<RsPeerId, VOIPPeerInfo>::iterator it;
it = mPeerInfo.find(id);
if (it == mPeerInfo.end())
{
/* add it in */
VOIPPeerInfo pinfo;
/* initialise entry */
pinfo.initialisePeerInfo(id);
mPeerInfo[id] = pinfo;
it = mPeerInfo.find(id);
}
return &(it->second);
}
bool VOIPPeerInfo::initialisePeerInfo(const RsPeerId& id)
{
mId = id;
/* reset variables */
mCurrentPingTS = 0;
mCurrentPingCounter = 0;
mCurrentPongRecvd = true;
mSentPings = 0;
mLostPongs = 0;
average_incoming_bandwidth = 0 ;
total_bytes_received = 0 ;
mPongResults.clear();
return true;
}
void p3VOIP::setVoipATransmit(int t)
{
_atransmit = t ;
IndicateConfigChanged() ;
}
void p3VOIP::setVoipVoiceHold(int vh)
{
_voice_hold = vh ;
IndicateConfigChanged() ;
}
void p3VOIP::setVoipfVADmin(int vad)
{
_vadmin = vad ;
IndicateConfigChanged() ;
}
void p3VOIP::setVoipfVADmax(int vad)
{
_vadmax = vad ;
IndicateConfigChanged() ;
}
void p3VOIP::setVoipiNoiseSuppress(int n)
{
_noise_suppress = n ;
IndicateConfigChanged() ;
}
void p3VOIP::setVoipiMinLoudness(int ml)
{
_min_loudness = ml ;
IndicateConfigChanged() ;
}
void p3VOIP::setVoipEchoCancel(bool b)
{
_echo_cancel = b ;
IndicateConfigChanged() ;
}
RsTlvKeyValue p3VOIP::push_int_value(const std::string& key,int value)
{
RsTlvKeyValue kv ;
kv.key = key ;
rs_sprintf(kv.value, "%d", value);
return kv ;
}
int p3VOIP::pop_int_value(const std::string& s)
{
std::istringstream is(s) ;
int val ;
is >> val ;
return val ;
}
bool p3VOIP::saveList(bool& cleanup, std::list<RsItem*>& lst)
{
cleanup = true ;
RsConfigKeyValueSet *vitem = new RsConfigKeyValueSet ;
vitem->tlvkvs.pairs.push_back(push_int_value("P3VOIP_CONFIG_ATRANSMIT",_atransmit)) ;
vitem->tlvkvs.pairs.push_back(push_int_value("P3VOIP_CONFIG_VOICEHOLD",_voice_hold)) ;
vitem->tlvkvs.pairs.push_back(push_int_value("P3VOIP_CONFIG_VADMIN" ,_vadmin)) ;
vitem->tlvkvs.pairs.push_back(push_int_value("P3VOIP_CONFIG_VADMAX" ,_vadmax)) ;
vitem->tlvkvs.pairs.push_back(push_int_value("P3VOIP_CONFIG_NOISE_SUP",_noise_suppress)) ;
vitem->tlvkvs.pairs.push_back(push_int_value("P3VOIP_CONFIG_MIN_LOUDN",_min_loudness)) ;
vitem->tlvkvs.pairs.push_back(push_int_value("P3VOIP_CONFIG_ECHO_CNCL",_echo_cancel)) ;
lst.push_back(vitem) ;
return true ;
}
bool p3VOIP::loadList(std::list<RsItem*>& load)
{
for(std::list<RsItem*>::const_iterator it(load.begin());it!=load.end();++it)
{
#ifdef P3TURTLE_DEBUG
assert(item!=NULL) ;
#endif
RsConfigKeyValueSet *vitem = dynamic_cast<RsConfigKeyValueSet*>(*it) ;
if(vitem != NULL)
{
for(std::list<RsTlvKeyValue>::const_iterator kit = vitem->tlvkvs.pairs.begin(); kit != vitem->tlvkvs.pairs.end(); ++kit)
if(kit->key == "P3VOIP_CONFIG_ATRANSMIT")
_atransmit = pop_int_value(kit->value) ;
else if(kit->key == "P3VOIP_CONFIG_VOICEHOLD")
_voice_hold = pop_int_value(kit->value) ;
else if(kit->key == "P3VOIP_CONFIG_VADMIN")
_vadmin = pop_int_value(kit->value) ;
else if(kit->key == "P3VOIP_CONFIG_VADMAX")
_vadmax = pop_int_value(kit->value) ;
else if(kit->key == "P3VOIP_CONFIG_NOISE_SUP")
_noise_suppress = pop_int_value(kit->value) ;
else if(kit->key == "P3VOIP_CONFIG_MIN_LOUDN")
_min_loudness = pop_int_value(kit->value) ;
else if(kit->key == "P3VOIP_CONFIG_ECHO_CNCL")
_echo_cancel = pop_int_value(kit->value) ;
}
delete vitem ;
}
load.clear() ;
return true ;
}
RsSerialiser *p3VOIP::setupSerialiser()
{
RsSerialiser *rsSerialiser = new RsSerialiser();
rsSerialiser->addSerialType(new RsVOIPSerialiser());
rsSerialiser->addSerialType(new RsGeneralConfigSerialiser());
return rsSerialiser ;
}