xmlrpc_value* SetMute(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
//Parseamos
int confId;
int partId;
int media;
int isMuted;
xmlrpc_parse_value(env, param_array, "(iiii)", &confId, &partId, &media, &isMuted);
//Comprobamos si ha habido error
if(env->fault_occurred)
xmlerror(env,"Fault occurred\n");
//Obtenemos la referencia
if(!mcu->GetConferenceRef(confId,&conf))
return xmlerror(env,"Conference does not exist");
//La borramos
int res = conf->SetMute(partId,(MediaFrame::Type)media,isMuted);
//Liberamos la referencia
mcu->ReleaseConferenceRef(confId);
//Salimos
if(!res)
return xmlerror(env,"Could not start playback\n");
//Devolvemos el resultado
return xmlok(env);
}
xmlrpc_value* StartBroadcaster(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
//Parseamos
int confId;
xmlrpc_parse_value(env, param_array, "(i)", &confId);
//Comprobamos si ha habido error
if(env->fault_occurred)
xmlerror(env,"Fault occurred\n");
//Obtenemos la referencia
if(!mcu->GetConferenceRef(confId,&conf))
return xmlerror(env,"Conference does not exist");
//La borramos
int port = conf->StartBroadcaster();
//Liberamos la referencia
mcu->ReleaseConferenceRef(confId);
//Salimos
if(!port)
return xmlerror(env,"No se ha podido crear el watcher FLV\n");
//Devolvemos el resultado
return xmlok(env,xmlrpc_build_value(env,"(i)",port));
}
xmlrpc_value* ResetMosaicOverlay(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
//Parseamos
int confId;
int mosaicId;
xmlrpc_parse_value(env, param_array, "(ii)", &confId,&mosaicId);
//Comprobamos si ha habido error
if(env->fault_occurred)
xmlerror(env,"Fault occurred\n");
//Obtenemos la referencia
if(!mcu->GetConferenceRef(confId,&conf))
return xmlerror(env,"Conference does not exist");
//La borramos
int res = conf->ResetMosaicOverlay(mosaicId);
//Liberamos la referencia
mcu->ReleaseConferenceRef(confId);
//Salimos
if(!res)
return xmlerror(env,"Could reset overlay image\n");
//Devolvemos el resultado
return xmlok(env,xmlrpc_build_value(env,"(i)",mosaicId));
}
xmlrpc_value* RemoveMosaicParticipant(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
//Parseamos
int confId;
int mosaicId;
int partId;
xmlrpc_parse_value(env, param_array, "(iii)", &confId,&mosaicId,&partId);
//Comprobamos si ha habido error
if(env->fault_occurred)
xmlerror(env,"Fault occurred\n");
//Obtenemos la referencia
if(!mcu->GetConferenceRef(confId,&conf))
return xmlerror(env,"Conference does not exist");
//Set slot
int res = conf->RemoveMosaicParticipant(mosaicId,partId);
//Liberamos la referencia
mcu->ReleaseConferenceRef(confId);
//Salimos
if(!res)
return xmlerror(env,"Error\n");
//Devolvemos el resultado
return xmlok(env);
}
xmlrpc_value* StopRecordingParticipant(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
//Parseamos
int confId;
int playerId;
xmlrpc_parse_value(env, param_array, "(ii)", &confId,&playerId);
//Comprobamos si ha habido error
if(env->fault_occurred)
xmlerror(env,"Fault occurred\n");
//Obtenemos la referencia
if(!mcu->GetConferenceRef(confId,&conf))
return xmlerror(env,"Conference does not exist");
//La borramos
int res = conf->StopRecordingParticipant(playerId);
//Liberamos la referencia
mcu->ReleaseConferenceRef(confId);
//Salimos
if(!res)
return xmlerror(env,"Could not stop play back in conference\n");
//Devolvemos el resultado
return xmlok(env);
}
xmlrpc_value* StopSendingAudio(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
//Parseamos
int confId;
int partId;
xmlrpc_parse_value(env, param_array, "(ii)", &confId,&partId);
//Comprobamos si ha habido error
if(env->fault_occurred)
xmlerror(env,"Fault occurred\n");
//Obtenemos la referencia
if(!mcu->GetConferenceRef(confId,&conf))
return xmlerror(env,"Conference does not exist");
//La borramos
int res = conf->StopSendingAudio(partId);
//Liberamos la referencia
mcu->ReleaseConferenceRef(confId);
//Salimos
if(!res)
return xmlerror(env,"No se ha podido terminar la conferencia\n");
//Devolvemos el resultado
return xmlok(env);
}
xmlrpc_value* SetCompositionType(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
//Parseamos
int confId;
int mosaicId;
int comp;
int size;
xmlrpc_parse_value(env, param_array, "(iiii)", &confId,&mosaicId,&comp,&size);
//Comprobamos si ha habido error
if(env->fault_occurred)
xmlerror(env,"Fault occurred\n");
//Obtenemos la referencia
if(!mcu->GetConferenceRef(confId,&conf))
return xmlerror(env,"Conference does not exist");
//La borramos
int res = conf->SetCompositionType(mosaicId,(Mosaic::Type)comp,size);
//Liberamos la referencia
mcu->ReleaseConferenceRef(confId);
//Salimos
if(!res)
return xmlerror(env,"Error\n");
//Devolvemos el resultado
return xmlok(env);
}
//CreateSession
xmlrpc_value* FLVCreateSession(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
FLVServer *flv = (FLVServer *)user_data;
FLVSession *session = NULL;
//Parseamos
char *str;
xmlrpc_parse_value(env, param_array, "(s)", &str);
//Creamos la sessionerencia
int sessionId = flv->CreateSession(str);
//Si error
if (!sessionId>0)
return xmlerror(env,"No se puede crear la sessionerencia");
//Obtenemos la referencia
if(!flv->GetSessionRef(sessionId,&session))
return xmlerror(env,"Conferencia borrada antes de poder iniciarse\n");
//La iniciamos
int port = session->Init();
//Liberamos la referencia
flv->ReleaseSessionRef(sessionId);
//Salimos
if(!port)
return xmlerror(env,"No se ha podido iniciar la sessionerencia\n");
//Devolvemos el resultado
return xmlok(env,xmlrpc_build_value(env,"(ii)",sessionId,port));
}
xmlrpc_value* FLVStopReceivingVideo(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
FLVServer *flv = (FLVServer *)user_data;
FLVSession *session = NULL;
//Parseamos
int sessionId;
xmlrpc_parse_value(env, param_array, "(i)", &sessionId);
//Comprobamos si ha habido error
if(env->fault_occurred)
return 0;
//Obtenemos la referencia
if(!flv->GetSessionRef(sessionId,&session))
return xmlerror(env,"La sessionerencia no existe\n");
//La borramos
int res = session->StopReceivingVideo();
//Liberamos la referencia
flv->ReleaseSessionRef(sessionId);
//Salimos
if(!res)
return xmlerror(env,"Error\n");
//Devolvemos el resultado
return xmlok(env);
}
xmlrpc_value* MediaGatewaySendFPU(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MediaGateway *mediaGateway = (MediaGateway *)user_data;
MediaBridgeSession *session = NULL;
//Parseamos
int sessionId;
xmlrpc_parse_value(env, param_array, "(i)", &sessionId);
//Comprobamos si ha habido error
if(env->fault_occurred)
return 0;
//Obtenemos la referencia
if(!mediaGateway->GetMediaBridgeRef(sessionId,&session))
return xmlerror(env,"La sessionerencia no existe\n");
//La borramos
int res = session->SendFPU();
//Liberamos la referencia
mediaGateway->ReleaseMediaBridgeRef(sessionId);
//Salimos
if(!res)
return xmlerror(env,"Error\n");
//Devolvemos el resultado
return xmlok(env);
}
xmlrpc_value* AddConferenceToken(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
UTF8Parser parser;
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
//Parseamos
int confId;
char *str;
xmlrpc_parse_value(env, param_array, "(is)", &confId, &str);
//Comprobamos si ha habido error
if(env->fault_occurred)
xmlerror(env,"Fault occurred\n");
//Parse string
parser.Parse((BYTE*)str,strlen(str));
//Obtenemos la referencia
if(!mcu->GetConferenceRef(confId,&conf))
return xmlerror(env,"Conference does not exist");
//La borramos
bool res = conf->AddBroadcastToken(parser.GetWString());
//Liberamos la referencia
mcu->ReleaseConferenceRef(confId);
//Salimos
if(!res)
return xmlerror(env,"Could not add pin to broadcast session\n");
//Devolvemos el resultado
return xmlok(env);
}
xmlrpc_value* DeleteSpy(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
//Parseamos
int confId;
int spyId;
xmlrpc_parse_value(env, param_array, "(ii)", &confId,&spyId);
//Comprobamos si ha habido error
if(env->fault_occurred)
xmlerror(env,"Fault occurred\n");
//Obtenemos la referencia
if(!mcu->GetConferenceRef(confId,&conf))
return xmlerror(env,"Conference does not exist");
//La borramos
int res = conf->DeleteSpy(spyId);
//Liberamos la referencia
mcu->ReleaseConferenceRef(confId);
//Salimos
if(!res)
return xmlerror(env,"Delete spy error\n");
//Devolvemos el resultado
return xmlok(env);
}
xmlrpc_value* StartSendingVideo(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
//Parseamos
int confId;
int partId;
char *sendVideoIp;
int sendVideoPort;
xmlrpc_value *rtpMap;
xmlrpc_parse_value(env, param_array, "(iisiS)", &confId,&partId,&sendVideoIp,&sendVideoPort,&rtpMap);
//Get the rtp map
VideoCodec::RTPMap map;
//Get map size
int j = xmlrpc_struct_size(env,rtpMap);
//Parse rtp map
for (int i=0;i<j;i++)
{
xmlrpc_value *key, *val;
const char *type;
int codec;
//Read member
xmlrpc_struct_read_member(env,rtpMap,i,&key,&val);
//Read name
xmlrpc_parse_value(env,key,"s",&type);
//Read value
xmlrpc_parse_value(env,val,"i",&codec);
//Add to map
map[atoi(type)] = (VideoCodec::Type) codec;
//Decrement ref counter
xmlrpc_DECREF(key);
xmlrpc_DECREF(val);
}
//Comprobamos si ha habido error
if(env->fault_occurred)
xmlerror(env,"Fault occurred\n");
//Obtenemos la referencia
if(!mcu->GetConferenceRef(confId,&conf))
return xmlerror(env,"Conference does not exist");
//La borramos
int res = conf->StartSendingVideo(partId,sendVideoIp,sendVideoPort,map) != NULL;
//Liberamos la referencia
mcu->ReleaseConferenceRef(confId);
//Salimos
if(!res)
return xmlerror(env,"Error\n");
//Devolvemos el resultado
return xmlok(env);
}
xmlrpc_value* MediaGatewayStartSendingText(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MediaGateway *mediaGateway = (MediaGateway *)user_data;
MediaBridgeSession *session = NULL;
//Parseamos
int sessionId;
char *sendTextIp;
int sendTextPort;
xmlrpc_value *rtpMap;
xmlrpc_parse_value(env, param_array, "(isiS)", &sessionId,&sendTextIp,&sendTextPort,&rtpMap);
//Comprobamos si ha habido error
if(env->fault_occurred)
return 0;
//Get the rtp map
TextCodec::RTPMap map;
//Get map size
int j = xmlrpc_struct_size(env,rtpMap);
//Parse rtp map
for (int i=0;i<j;i++)
{
xmlrpc_value *key, *val;
const char *type;
int codec;
//Read member
xmlrpc_struct_read_member(env,rtpMap,i,&key,&val);
//Read name
xmlrpc_parse_value(env,key,"s",&type);
//Read value
xmlrpc_parse_value(env,val,"i",&codec);
//Add to map
map[atoi(type)] = (TextCodec::Type) codec;
//Decrement ref counter
xmlrpc_DECREF(key);
xmlrpc_DECREF(val);
}
//Obtenemos la referencia
if(!mediaGateway->GetMediaBridgeRef(sessionId,&session))
return xmlerror(env,"La sessionerencia no existe\n");
//La borramos
int res = session->StartSendingText(sendTextIp,sendTextPort,map);
//Liberamos la referencia
mediaGateway->ReleaseMediaBridgeRef(sessionId);
//Salimos
if(!res)
return xmlerror(env,"Error\n");
//Devolvemos el resultado
return xmlok(env);
}
xmlrpc_value* StartReceivingText(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
//Parseamos
int confId;
int partId;
xmlrpc_value *rtpMap;
xmlrpc_parse_value(env, param_array, "(iiS)", &confId,&partId,&rtpMap);
//Get the rtp map
TextCodec::RTPMap map;
int j = xmlrpc_struct_size(env,rtpMap);
//Parse rtp map
for (int i=0;i<j;i++)
{
xmlrpc_value *key, *val;
const char *type;
int codec;
//Read member
xmlrpc_struct_read_member(env,rtpMap,i,&key,&val);
//Read name
xmlrpc_parse_value(env,key,"s",&type);
//Read value
xmlrpc_parse_value(env,val,"i",&codec);
//Add to map
map[atoi(type)] = (TextCodec::Type) codec;
//Decrement ref counter
xmlrpc_DECREF(key);
xmlrpc_DECREF(val);
}
//Comprobamos si ha habido error
if(env->fault_occurred)
xmlerror(env,"Fault occurred\n");
//Obtenemos la referencia
if(!mcu->GetConferenceRef(confId,&conf))
return xmlerror(env,"Conference does not exist");
//La borramos
int recTextPort = conf->StartReceivingText(partId,map);
//Liberamos la referencia
mcu->ReleaseConferenceRef(confId);
//Salimos
if(!recTextPort)
return xmlerror(env,"No se ha podido terminar la conferencia\n");
//Devolvemos el resultado
return xmlok(env,xmlrpc_build_value(env,"(i)",recTextPort,recTextPort));
}
//CreateConference
xmlrpc_value* CreateConference(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
UTF8Parser tagParser;
//Parseamos
char *str;
int queueId = 0;
xmlrpc_parse_value(env, param_array, "(si)", &str, &queueId);
//Comprobamos si ha habido error
if(env->fault_occurred)
{
//Try with old parameters
xmlrpc_parse_value(env, param_array, "(s)", &str);
//Comprobamos si ha habido error
if(env->fault_occurred)
//Send errro
xmlerror(env,"Fault occurred\n");
}
//Parse string
tagParser.Parse((BYTE*)str,strlen(str));
//Creamos la conferencia
int confId = mcu->CreateConference(tagParser.GetWString(),queueId);
//Si error
if (!confId>0)
return xmlerror(env,"No se puede crear la conferencia");
//Obtenemos la referencia
if(!mcu->GetConferenceRef(confId,&conf))
return xmlerror(env,"Conferencia borrada antes de poder iniciarse\n");
//La iniciamos
int res = conf->Init();
//Liberamos la referencia
mcu->ReleaseConferenceRef(confId);
//Salimos
if(!res)
return xmlerror(env,"No se ha podido iniciar la conferencia\n");
//Devolvemos el resultado
return xmlok(env,xmlrpc_build_value(env,"(i)",confId));
}
xmlrpc_value* GetParticipantStatistics(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
//Parseamos
int confId;
int partId;
xmlrpc_parse_value(env, param_array, "(ii)", &confId, &partId);
//Comprobamos si ha habido error
if(env->fault_occurred)
xmlerror(env,"Fault occurred\n");
//Obtenemos la referencia
if(!mcu->GetConferenceRef(confId,&conf))
return xmlerror(env,"Conference does not exist");
//Get statistics
MultiConf::ParticipantStatistics *partStats = conf->GetParticipantStatistic(partId);
//Liberamos la referencia
mcu->ReleaseConferenceRef(confId);
//Salimos
if(!partStats)
return xmlerror(env,"Participant not found\n");
//Create array
xmlrpc_value* arr = xmlrpc_array_new(env);
//Process result
for (MultiConf::ParticipantStatistics::iterator it = partStats->begin(); it!=partStats->end(); ++it)
{
//Get media
std::string media = it->first;
//Get stats
MediaStatistics stats = it->second;
//Create array
xmlrpc_value* val = xmlrpc_build_value(env,"(siiiiiii)",media.c_str(),stats.isReceiving,stats.isSending,stats.lostRecvPackets,stats.numRecvPackets,stats.numSendPackets,stats.totalRecvBytes,stats.totalSendBytes);
//Add it
xmlrpc_array_append_item(env,arr,val);
//Release
xmlrpc_DECREF(val);
}
//return
return xmlok(env,arr);
}
xmlrpc_value* MediaGatewaySetMediaBridgeOutputToken(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
UTF8Parser parser;
MediaGateway *mediaGateway = (MediaGateway *)user_data;
//Parseamos
int sessionId;
char *str;
xmlrpc_parse_value(env, param_array, "(is)", &sessionId, &str);
//Comprobamos si ha habido error
if(env->fault_occurred)
return 0;
//Parse string
parser.Parse((BYTE*)str,strlen(str));
//La borramos
bool res = mediaGateway->SetMediaBridgeOutputToken(sessionId,parser.GetWString());
//Salimos
if(!res)
return xmlerror(env,"Could not set output token to bridge session\n");
//Devolvemos el resultado
return xmlok(env);
}
xmlrpc_value* GetConferences(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MCU::ConferencesInfo list;
//Obtenemos la referencia
if(!mcu->GetConferenceList(list))
return xmlerror(env,"Could not retreive conference info list\n");
//Create array
xmlrpc_value* arr = xmlrpc_array_new(env);
//Process result
for (MCU::ConferencesInfo::iterator it = list.begin(); it!=list.end(); ++it)
{
//Create array
xmlrpc_value* val = xmlrpc_build_value(env,"(isi)",it->second.id,it->second.name.c_str(),it->second.numPart);
//Add it
xmlrpc_array_append_item(env,arr,val);
//Release
xmlrpc_DECREF(val);
}
//return
return xmlok(env,arr);
}
const XMLNodeList & XMLNode::children(const string &n) const {
if(n.empty()) {
if(nodelist.empty()) throw xmlerror(xml_childlist_empty);
return nodelist;
}
static XMLNodeList ret;
ret.clear();
XMLNodeListConstIterator it;
for(it=nodelist.begin(); it!=nodelist.end(); it++) {
if((*it)->name()==n) ret.push_back(*it);
}
if(ret.empty()) throw xmlerror(xml_name_not_found, n);
return ret;
}
xmlrpc_value* MCUEventQueueDelete(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
//Parseamos
int queueId;
xmlrpc_parse_value(env, param_array, "(i)", &queueId);
//Comprobamos si ha habido error
if(env->fault_occurred)
xmlerror(env,"Fault occurred\n");
//Delete event queue
if (!mcu->DeleteEventQueue(queueId))
return xmlerror(env,"Event queue does not exist");
//Devolvemos el resultado
return xmlok(env);
}
xmlrpc_value* DeleteConference(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
//Parseamos
int confId;
xmlrpc_parse_value(env, param_array, "(i)", &confId);
//Comprobamos si ha habido error
if(env->fault_occurred)
xmlerror(env,"Fault occurred\n");
//Delete conference
if (!mcu->DeleteConference(confId))
return xmlerror(env,"Conference does not exist");
//Devolvemos el resultado
return xmlok(env);
}
/*! \exception throws xmlpp::xmlerror if requested children was not found */
XMLNodePtr XMLNode::firstchild(const string &n) {
XMLNodeListConstIterator it;
// search for child
for(it=nodelist.begin(); it!=nodelist.end(); it++) {
if ((*it)->name() == n) return *it;
}
// no valid child found
throw xmlerror(xml_name_not_found, n);
return XMLNodePtr(NULL);
}
xmlrpc_value* SetVideoCodec(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
//Parseamos
int confId;
int partId;
int codec;
int mode;
int fps;
int bitrate;
int quality;
int fillLevel;
int intraPeriod;
xmlrpc_parse_value(env, param_array, "(iiiiiiiii)", &confId,&partId,&codec,&mode,&fps,&bitrate,&quality,&fillLevel,&intraPeriod);
//Comprobamos si ha habido error
if(env->fault_occurred)
xmlerror(env,"Fault occurred\n");
//Obtenemos la referencia
if(!mcu->GetConferenceRef(confId,&conf))
return xmlerror(env,"Conference does not exist");
//La borramos
int res = conf->SetVideoCodec(partId,codec,mode,fps,bitrate,quality,fillLevel,intraPeriod);
//Liberamos la referencia
mcu->ReleaseConferenceRef(confId);
//Salimos
if(!res)
return xmlerror(env,"No soportado\n");
//Devolvemos el resultado
return xmlok(env);
}
/*! \exception throws xmlpp::xmlerror on filename or file access error */
void XMLDocument::load_file(string f) {
string infile;
if(f.size()<1) {
if(filename_.size()<1) {
// we do not have a valid filename to use
throw xmlerror(xml_filename_invalid);
} else {
infile=filename_;
}
} else {
infile=f;
}
ifstream istr(infile.c_str());
if(istr.is_open()) {
load(istr, contextptr);
filename_=infile;
} else {
// file access error
throw xmlerror(xml_file_access, infile);
}
}
/*! \exception throws xmlpp::xmlerror on filename or file access error */
void XMLDocument::save_file(string f) {
string outfile;
if(f.size()<1) {
if(filename_.size()<1) {
// we do not have a valid filename to use
throw xmlerror(xml_filename_invalid);
} else {
outfile=filename_;
}
} else {
outfile=f;
}
ofstream outstr(outfile.c_str());
if (outstr.is_open()) {
save(outstr);
filename_=outfile;
} else {
// file access error
throw xmlerror(xml_file_access, outfile);
}
}
bool xmlelement::subparse(std::ifstream& stream)
{
bool complete = false;
while (!complete && stream) {
subelements.push_back(xmlelement());
if (!subelements.back().parse(stream,true)) {
throw xmlerror(std::string("Unexplained error"));
}
if (subelements.back().closetag) {
if (subelements.back().name == name) {
subelements.pop_back();
complete = true;
}
else {
throw xmlerror(std::string("Element <") + name + std::string("> closed with </") + subelements.back().name + std::string(">"));
}
}
}
if (!complete) {
throw xmlerror(std::string("Unexpected end of element ") + name);
}
return true;
}
xmlrpc_value* MCUEventQueueCreate(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
//Create the event queue
int queueId = mcu->CreateEventQueue();
//Si error
if (!queueId>0)
return xmlerror(env,"Could not create event queue");
//Devolvemos el resultado
return xmlok(env,xmlrpc_build_value(env,"(i)",queueId));
}
xmlrpc_value* MediaGatewayCreateMediaBridge(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
UTF8Parser nameParser;
MediaGateway *mediaGateway = (MediaGateway *)user_data;
MediaBridgeSession *session = NULL;
//Parseamos
char *str;
xmlrpc_parse_value(env, param_array, "(s)", &str);
//Parse string
nameParser.Parse((BYTE*)str,strlen(str));
//Creamos la sessionerencia
int sessionId = mediaGateway->CreateMediaBridge(nameParser.GetWString());
//Obtenemos la referencia
if(!mediaGateway->GetMediaBridgeRef(sessionId,&session))
return xmlerror(env,"Session deleted before inited\n");
//Si error
if (!sessionId>0)
return xmlerror(env,"Could not create session");
//La iniciamos
bool res = session->Init();
//Liberamos la referencia
mediaGateway->ReleaseMediaBridgeRef(sessionId);
//Salimos
if(!res)
return xmlerror(env,"Could not start bridge\n");
//Devolvemos el resultado
return xmlok(env,xmlrpc_build_value(env,"(i)",sessionId));
}
xmlrpc_value* CreateParticipant(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data)
{
MCU *mcu = (MCU *)user_data;
MultiConf *conf = NULL;
UTF8Parser parser;
//Parseamos
int confId;
int mosaicId;
char *name;
int type;
xmlrpc_parse_value(env, param_array, "(iisi)", &confId,&mosaicId,&name,&type);
//Comprobamos si ha habido error
if(env->fault_occurred)
xmlerror(env,"Fault occurred\n");
//Obtenemos la referencia
if(!mcu->GetConferenceRef(confId,&conf))
return xmlerror(env,"Conference does not exist");
//Parse string
parser.Parse((BYTE*)name,strlen(name));
//La borramos
int partId = conf->CreateParticipant(mosaicId,parser.GetWString(),(Participant::Type)type);
//Liberamos la referencia
mcu->ReleaseConferenceRef(confId);
//Salimos
if(!partId)
return xmlerror(env,"No se ha podido a�adir el participante a la conferencia\n");
//Devolvemos el resultado
return xmlok(env,xmlrpc_build_value(env,"(i)",partId));
}
