Changeset 17

Show
Ignore:
Timestamp:
08/21/07 13:29:00 (1 year ago)
Author:
sip
Message:

Fist version of Flash playback support.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • config.mk

    r6 r17  
    44LOG             = yes 
    55DEBUG           = yes 
    6 SRCDIR          = /usr/mcu 
     6FLASHSTREAMER   = yes 
     7GNASHBASE       = /root/gnash 
     8GNASHLIBS       = /usr/local/lib/gnash 
     9SRCDIR          = /root/mcu 
    710TARGET          = /usr/local 
     11 
  • media/Makefile

    r9 r17  
    3636GSMOBJ=gsmcodec.o 
    3737 
    38 OBJS=mcu.o multiconf.o participant.o videomixer.o audiomixer.o main.o xmlrpcserver.o xmlhandler.o statushandler.o xmlrpcmcu.o  tools.o rtpsession.o audiostream.o videostream.o pipeaudioinput.o pipeaudiooutput.o pipevideoinput.o pipevideooutput.o framescaler.o mosaic.o partedmosaic.o 
     38OBJS=mcu.o multiconf.o participant.o videomixer.o audiomixer.o xmlrpcserver.o xmlhandler.o statushandler.o xmlrpcmcu.o  tools.o rtpsession.o audiostream.o videostream.o pipeaudioinput.o pipeaudiooutput.o pipevideoinput.o pipevideooutput.o framescaler.o mosaic.o partedmosaic.o 
    3939OBJS+= $(G711OBJ) $(H263OBJ) $(GSMOBJ)  
    40 OBJSCLIENT = xmlrpcclient.o xmlrpcmcuclient.o 
    4140 
    42 BUILDOBJS= $(addprefix $(BUILD)/,$(OBJS)) 
    43 BUILDOBJSCLIENT= $(addprefix $(BUILD)/,$(OBJSCLIENT)) 
     41ifeq ($(FLASHSTREAMER),yes) 
     42        GNASHINCLUDE = -I$(GNASHBASE)/server -I$(GNASHBASE)/libbase -I$(GNASHBASE)/libgeometry -I$(GNASHBASE)/server/parser -I$(GNASHBASE)/server/vm -I$(GNASHBASE)/backend -DFLASHSTREAMER 
     43        GNASHLD = -lgnashbackend -lgnashserver -lagg  -L$(GNASHLIBS) 
     44        OBJSFS   = flashstreamer.o FlashPlayer.o FlashSoundHandler.o $(OBJS) 
     45        OBJS+= flash.o xmlrpcflash.o     
     46        OBJSFSCLIENT = xmlrpcclient.o xmlrpcflashclient.o 
     47endif 
     48 
     49OBJSMCU = $(OBJS) main.o 
     50OBJSMCUCLIENT = xmlrpcclient.o xmlrpcmcuclient.o 
     51 
     52BUILDOBJSMCU = $(addprefix $(BUILD)/,$(OBJSMCU)) 
     53BUILDOBJSMCUCLIENT= $(addprefix $(BUILD)/,$(OBJSMCUCLIENT)) 
     54BUILDOBJSFS= $(addprefix $(BUILD)/,$(OBJSFS))  
     55BUILDOBJSFSCLIENT= $(addprefix $(BUILD)/,$(OBJSFSCLIENT)) 
    4456 
    4557################################### 
     
    5365VPATH +=  %.cpp $(SRCDIR)/media/src/$(H263DIR) 
    5466 
    55 INCLUDE+= -I$(SRCDIR)/media/include/ -I$(SRCDIR)/xmlrpc/include -I$(SRCDIR)/xmlrpc/lib/abyss/src 
     67INCLUDE+= -I$(SRCDIR)/media/include/ -I$(SRCDIR)/xmlrpc/include -I$(SRCDIR)/xmlrpc/lib/abyss/src $(GNASHINCLUDE) 
    5668LDFLAGS+= -lavcodec -lgsm -lpthread -lswscale 
    5769LDXMLFLAGS+= -lxmlrpc -lxmlrpc_xmlparse -lxmlrpc_xmltok -lxmlrpc_abyss -lxmlrpc_server -L$(SRCDIR)/xmlrpc/lib  
     
    7486#Targets 
    7587############################################ 
    76 all: mkdirs mcu client test 
     88all: mkdirs mcu mcuclient test flashstreamer flashclient testflash 
    7789 
    7890mkdirs:   
     
    8092        mkdir -p $(BIN) 
    8193clean: 
    82         rm -f $(BUILDOBJS) 
    83         rm -f $(BUILDOBJSCLIENT) 
     94        rm -f $(BUILDOBJSMCU) 
     95        rm -f $(BUILDOBJSMCUCLIENT) 
     96        rm -f $(BUILDOBJSFS) 
     97        rm -f $(BUILDOBJSFSCLIENT) 
    8498        rm -f "$(BIN)/mcu" 
    8599        rm -f "$(BIN)/libmcuclient.so" 
    86100        rm -f "$(BIN)/test" 
     101        rm -f "$(BIN)/flashstreamer" 
     102        rm -f "$(BIN)/libflashclient.so" 
     103        rm -f "$(BIN)/testflash" 
    87104 
    88105install: 
     
    97114############################################ 
    98115 
    99 mcu: $(OBJS
    100         $(CXX) $(LDFLAGS) -o $(BIN)/$@ $(BUILDOBJS)  
     116mcu: $(OBJSMCU
     117        $(CXX) $(LDFLAGS) -o $(BIN)/$@ $(BUILDOBJSMCU)  
    101118 
    102 client: $(OBJSCLIENT) 
    103         $(CXX) $(LDXMLFLAGS) -lpthread -lcurl -shared -o $(BIN)/libmcuclient.so  $(BUILDOBJSCLIENT)  
     119mcuclient: $(OBJSMCUCLIENT) 
     120        $(CXX) $(LDXMLFLAGS) -lpthread -lcurl -shared -o $(BIN)/libmcuclient.so  $(BUILDOBJSMCUCLIENT)  
    104121 
    105122test: client.o 
    106123        $(CXX) $(LDXMLFLAGS) -lpthread -lcurl -o $(BIN)/test  -lmcuclient -L$(BIN) $(BUILD)/client.o 
     124 
     125ifeq ($(FLASHSTREAMER),yes) 
     126 
     127flashstreamer: $(OBJSFS) $(OBJS) 
     128        g++ $(LDFLAGS) $(GNASHLD) -o $(BIN)/$@ $(BUILDOBJSFS) $(BUILDOBJS) $(GNASHBASE)/backend/.libs/libgnashagg.a 
     129 
     130flashclient: $(OBJSFSCLIENT) 
     131        $(CXX) $(LDXMLFLAGS) -lpthread -lcurl -shared -o $(BIN)/libflashclient.so  $(BUILDOBJSFSCLIENT) 
     132 
     133testflash: clientflash.o 
     134        $(CXX) $(LDXMLFLAGS) -lpthread -lcurl -o $(BIN)/testflash  -lflashclient -L$(BIN) $(BUILD)/clientflash.o 
     135         
     136 
     137else 
     138 
     139flashstreamer: 
     140 
     141flashclient: 
     142 
     143testflash: 
     144 
     145endif 
  • media/include/log.h

    r2 r17  
    55#include <unistd.h> 
    66#include <stdarg.h> 
     7 
     8#define log_msg Log 
     9#define log_error Error 
    710 
    811inline void LogFile(char *msg, ...) 
  • media/include/xmlhandler.h

    r1 r17  
    33#include <xmlrpc.h> 
    44#include "xmlrpcserver.h" 
     5 
     6xmlrpc_value* xmlerror (xmlrpc_env *env,char *msg); 
     7xmlrpc_value* xmlok (xmlrpc_env *env,xmlrpc_value *array=NULL); 
     8 
     9struct XmlHandlerCmd 
     10{ 
     11        char * name; 
     12        xmlrpc_value* (*func) (xmlrpc_env *env, xmlrpc_value *param_array, void *user_data); 
     13}; 
    514 
    615class XmlHandler : 
     
    918public: 
    1019        XmlHandler(); 
     20        XmlHandler(XmlHandlerCmd *cmd,void *user_data); 
    1121        virtual int AddMethod(const char *name,xmlrpc_method method,void *user_data); 
    1222        virtual int ProcessRequest(TSession * const r); 
  • media/src/h263/h263codec.cpp

    r4 r17  
    111111int H263Encoder::OpenCodec() 
    112112{ 
     113        Log("-OpenCodec H263 [%dbps,%dfps]\n",bitrate,fps); 
     114 
    113115        // Check 
    114116        if (codec==NULL) 
     
    121123        // Bitrate,fps 
    122124        ctx->bit_rate           = bitrate; 
    123         ctx->bit_rate_tolerance = 1; 
     125        ctx->bit_rate_tolerance = bitrate/fps+1; 
    124126        ctx->time_base          = (AVRational){1,fps}; 
    125         ctx->gop_size           = (int)(fps*2);        // about one Intra frame per second 
     127        ctx->gop_size           = (int)(fps*10);       // about one Intra frame per ten seconds 
    126128        // Encoder quality 
    127129        ctx->rc_min_rate        = bitrate; 
     
    132134        ctx->mb_qmin = ctx->qmin= qMin; 
    133135        ctx->mb_qmax = ctx->qmax= qMax; 
    134         ctx->i_quant_factor   = (float)-0.6; 
    135         ctx->i_quant_offset   = (float)0.0; 
    136         ctx->b_quant_factor   = (float)1.5; 
     136        //ctx->i_quant_factor = (float)-0.6; 
     137        //ctx->i_quant_offset         = (float)0.0; 
     138        //ctx->b_quant_factor         = (float)1.5; 
    137139        // Flags 
    138140        ctx->flags |= CODEC_FLAG_PASS1;                 //PASS1  
  • media/src/main.cpp

    r1 r17  
    33#include "xmlrpcserver.h" 
    44#include "xmlhandler.h" 
    5 #include "xmlrpcmcu.h" 
    65#include "statushandler.h" 
    76#include "audiomixer.h" 
    87 
    9 extern McuCmd mcuCmdList[]; 
     8extern XmlHandlerCmd mcuCmdList[]; 
     9 
     10#ifdef FLASHSTREAMER 
     11#include "flash.h" 
     12extern XmlHandlerCmd flashCmdList[]; 
     13#endif 
    1014 
    1115int main() 
     
    1317        XmlRpcServer server; 
    1418        StatusHandler status; 
    15         XmlHandler xmlrpc; 
    1619        MCU mcu; 
     20        XmlHandler xmlrpc(mcuCmdList,(void*)&mcu); 
     21 
     22#ifdef FLASHSTREAMER 
     23        Flash flash; 
     24        XmlHandler xmlrpcFlash(flashCmdList,(void*)&flash); 
     25#endif 
    1726 
    1827        //Global Init 
    1928        AudioMixer::GlobalInit(); 
    2029 
    21         //Los rpcs de la mcu 
    22         McuCmd *cmd = (McuCmd *)mcuCmdList
     30        //Append mcu cmd handler 
     31        server.AddHandler(string("/mcu"),&xmlrpc)
    2332 
    24         //Recorremos la lista 
    25         while (cmd->name!=NULL) 
    26         { 
    27                 //Añadimos los callbacks 
    28                 xmlrpc.AddMethod(cmd->name,cmd->func,(void *)&mcu); 
    29                 //Pasamos al siguietne 
    30                 cmd++; 
    31         } 
    32  
    33         //Añadimos el xml 
    34         server.AddHandler(string("/mcu"),&xmlrpc); 
     33#ifdef FLASHSTREAMER 
     34        //Append flash cmldhandler 
     35        server.AddHandler(string("/flash"),&xmlrpcFlash); 
     36#endif 
    3537 
    3638        //Y el html 
    3739        server.AddHandler(string("/status"),&status); 
    3840 
     41#ifdef FLASHSTREAMER 
     42        //Init flash player 
     43        flash.Init(); 
     44#endif 
    3945        //Init de mcu 
    4046        mcu.Init(); 
     
    4854        mcu.End(); 
    4955 
     56#ifdef FLASHSTREAMER 
     57        //End flash player 
     58        flash.End(); 
     59#endif 
     60 
    5061        //Global Init 
    5162        AudioMixer::GlobalEnd(); 
  • media/src/videostream.cpp

    r6 r17  
    4747*       Fija el modo de envio de video  
    4848**********************************************/ 
    49 int VideoStream::SetVideoCodec(int codec,int mode,int bitrate,int fps,int quality, int fillLevel) 
    50 { 
    51         Log("-SetVideoCodec [%d,%d,%d,%d]\n",codec,bitrate,quality,fillLevel); 
     49int VideoStream::SetVideoCodec(int codec,int mode,int fps,int bitrate,int quality, int fillLevel) 
     50{ 
     51        Log("-SetVideoCodec [%d,%d,%d,%d,%d]\n",codec,fps,bitrate,quality,fillLevel); 
    5252 
    5353        //Comprobamos si soportamos el codec 
     
    532532 
    533533                        //Y obtenemos el siguiente tiempo 
    534                         getUpdDifTime(&lastFrameTime); 
     534                        frameTime+=getUpdDifTime(&lastFrameTime); 
    535535                } 
    536536 
  • media/src/xmlhandler.cpp

    r8 r17  
    44#include <log.h> 
    55#include "xmlhandler.h" 
     6 
     7xmlrpc_value* xmlerror (xmlrpc_env *env,char *msg) 
     8{ 
     9        return xmlrpc_build_value(env,"{s:i,s:s}","returnCode",0,"errorMsg",msg); 
     10} 
     11 
     12xmlrpc_value* xmlok (xmlrpc_env *env,xmlrpc_value *array) 
     13{ 
     14        //Si es null ponemos uno vacio 
     15        if (array==NULL) 
     16                array = xmlrpc_build_value(env,"()"); 
     17 
     18        //Creamos el valor de retorno 
     19        xmlrpc_value *ret = xmlrpc_build_value(env,"{s:i,s:A}","returnCode",1,"returnVal",array); 
     20 
     21        //Decrementamos el contador 
     22        xmlrpc_DECREF(array); 
     23 
     24        //Y salimos 
     25        return ret; 
     26} 
     27 
    628 
    729/************************************** 
     
    1840        //Creamos el registro 
    1941        registry = xmlrpc_registry_new(&env); 
     42} 
     43 
     44/************************************** 
     45* XmlHandler 
     46*       Constructor 
     47*************************************/ 
     48XmlHandler::XmlHandler(XmlHandlerCmd *cmd,void *user_data) 
     49{ 
     50        xmlrpc_env env; 
     51 
     52        //Build the enviroment 
     53        xmlrpc_env_init(&env); 
     54 
     55        //Creamos el registro 
     56        registry = xmlrpc_registry_new(&env); 
     57 
     58        //Append commands 
     59        while (cmd && cmd->name) 
     60        { 
     61                //Append methods 
     62                AddMethod(cmd->name,cmd->func,user_data); 
     63                //Next 
     64                cmd++; 
     65        } 
    2066} 
    2167 
  • media/src/xmlrpcmcu.cpp

    r10 r17  
    1 #include "xmlrpcmcu.h" 
     1#include "xmlhandler.h" 
    22#include "mcu.h" 
    33 
    4 McuCmd mcuCmdList[] = 
     4//CreateConference 
     5xmlrpc_value* CreateConference(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
     6
     7        MCU *mcu = (MCU *)user_data; 
     8        MultiConf *conf = NULL; 
     9 
     10         //Parseamos 
     11        char *str; 
     12        xmlrpc_parse_value(env, param_array, "(s)", &str); 
     13          
     14        //Creamos la conferencia 
     15        int confId = mcu->CreateConference(str); 
     16 
     17        //Si error 
     18        if (!confId>0) 
     19                return xmlerror(env,"No se puede crear la conferencia"); 
     20 
     21        //Obtenemos la referencia 
     22        if(!mcu->GetConferenceRef(confId,&conf)) 
     23                return xmlerror(env,"Conferencia borrada antes de poder iniciarse\n"); 
     24 
     25        //La iniciamos 
     26        int res = conf->Init(); 
     27 
     28        //Liberamos la referencia 
     29        mcu->ReleaseConferenceRef(confId); 
     30 
     31        //Salimos 
     32        if(!res) 
     33                return xmlerror(env,"No se ha podido iniciar la conferencia\n"); 
     34 
     35        //Devolvemos el resultado 
     36        return xmlok(env,xmlrpc_build_value(env,"(i)",confId)); 
     37
     38 
     39xmlrpc_value* DeleteConference(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
     40
     41        MCU *mcu = (MCU *)user_data; 
     42        MultiConf *conf = NULL; 
     43 
     44         //Parseamos 
     45        int confId; 
     46        xmlrpc_parse_value(env, param_array, "(i)", &confId); 
     47 
     48        //Comprobamos si ha habido error 
     49        if(env->fault_occurred) 
     50                return 0; 
     51 
     52        //Delete conference  
     53        if (!mcu->DeleteConference(confId)) 
     54                return xmlerror(env,"La conferencia no existe\n"); 
     55 
     56        //Devolvemos el resultado 
     57        return xmlok(env); 
     58
     59 
     60xmlrpc_value* CreateParticipant(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
     61
     62        MCU *mcu = (MCU *)user_data; 
     63        MultiConf *conf = NULL; 
     64 
     65         //Parseamos 
     66        int confId; 
     67        xmlrpc_parse_value(env, param_array, "(i)", &confId); 
     68 
     69        //Comprobamos si ha habido error 
     70        if(env->fault_occurred) 
     71                return 0; 
     72          
     73        //Obtenemos la referencia 
     74        if(!mcu->GetConferenceRef(confId,&conf)) 
     75                return xmlerror(env,"La conferencia no existe\n"); 
     76 
     77        //La borramos 
     78        int partId = conf->CreateParticipant(); 
     79 
     80        //Liberamos la referencia 
     81        mcu->ReleaseConferenceRef(confId); 
     82 
     83        //Salimos 
     84        if(!partId) 
     85                return xmlerror(env,"No se ha podido añadir el participante a la conferencia\n"); 
     86 
     87        //Devolvemos el resultado 
     88        return xmlok(env,xmlrpc_build_value(env,"(i)",partId)); 
     89
     90 
     91xmlrpc_value* DeleteParticipant(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
     92
     93        MCU *mcu = (MCU *)user_data; 
     94        MultiConf *conf = NULL; 
     95 
     96         //Parseamos 
     97        int confId; 
     98        int partId; 
     99        xmlrpc_parse_value(env, param_array, "(ii)", &confId,&partId); 
     100 
     101        //Comprobamos si ha habido error 
     102        if(env->fault_occurred) 
     103                return 0; 
     104          
     105        //Obtenemos la referencia 
     106        if(!mcu->GetConferenceRef(confId,&conf)) 
     107                return xmlerror(env,"La conferencia no existe\n"); 
     108 
     109        //La borramos 
     110        int res = conf->DeleteParticipant(partId); 
     111 
     112        //Liberamos la referencia 
     113        mcu->ReleaseConferenceRef(confId); 
     114 
     115        //Salimos 
     116        if(!res) 
     117                return xmlerror(env,"No se ha podido añadir el participante a la conferencia\n"); 
     118 
     119        //Devolvemos el resultado 
     120        return xmlok(env); 
     121
     122 
     123xmlrpc_value* SetVideoCodec(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
     124
     125        MCU *mcu = (MCU *)user_data; 
     126        MultiConf *conf = NULL; 
     127 
     128         //Parseamos 
     129        int confId; 
     130        int partId; 
     131        int codec; 
     132        int mode; 
     133        int fps; 
     134        int bitrate; 
     135        int quality; 
     136        int fillLevel; 
     137 
     138        xmlrpc_parse_value(env, param_array, "(iiiiiiii)", &confId,&partId,&codec,&mode,&fps,&bitrate,&quality,&fillLevel); 
     139 
     140        //Comprobamos si ha habido error 
     141        if(env->fault_occurred) 
     142                return 0; 
     143          
     144        //Obtenemos la referencia 
     145        if(!mcu->GetConferenceRef(confId,&conf)) 
     146                return xmlerror(env,"La conferencia no existe\n"); 
     147 
     148        //La borramos 
     149        int res = conf->SetVideoCodec(partId,codec,mode,fps,bitrate,quality,fillLevel); 
     150 
     151        //Liberamos la referencia 
     152        mcu->ReleaseConferenceRef(confId); 
     153 
     154        //Salimos 
     155        if(!res) 
     156                return xmlerror(env,"No soportado\n"); 
     157 
     158        //Devolvemos el resultado 
     159        return xmlok(env); 
     160
     161 
     162xmlrpc_value* StartSendingVideo(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
     163
     164        MCU *mcu = (MCU *)user_data; 
     165        MultiConf *conf = NULL; 
     166 
     167         //Parseamos 
     168        int confId; 
     169        int partId; 
     170        char *sendVideoIp; 
     171        int sendVideoPort; 
     172        xmlrpc_parse_value(env, param_array, "(iisi)", &confId,&partId,&sendVideoIp,&sendVideoPort); 
     173 
     174        //Comprobamos si ha habido error 
     175        if(env->fault_occurred) 
     176                return 0; 
     177          
     178        //Obtenemos la referencia 
     179        if(!mcu->GetConferenceRef(confId,&conf)) 
     180                return xmlerror(env,"La conferencia no existe\n"); 
     181 
     182        //La borramos 
     183        int res = conf->StartSendingVideo(partId,sendVideoIp,sendVideoPort); 
     184 
     185        //Liberamos la referencia 
     186        mcu->ReleaseConferenceRef(confId); 
     187 
     188        //Salimos 
     189        if(!res) 
     190                return xmlerror(env,"Error\n"); 
     191 
     192        //Devolvemos el resultado 
     193        return xmlok(env); 
     194
     195 
     196xmlrpc_value* StopSendingVideo(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
     197
     198        MCU *mcu = (MCU *)user_data; 
     199        MultiConf *conf = NULL; 
     200 
     201         //Parseamos 
     202        int confId; 
     203        int partId; 
     204        xmlrpc_parse_value(env, param_array, "(ii)", &confId,&partId); 
     205 
     206        //Comprobamos si ha habido error 
     207        if(env->fault_occurred) 
     208                return 0; 
     209          
     210        //Obtenemos la referencia 
     211        if(!mcu->GetConferenceRef(confId,&conf)) 
     212                return xmlerror(env,"La conferencia no existe\n"); 
     213 
     214        //La borramos 
     215        int res = conf->StopSendingVideo(partId); 
     216 
     217        //Liberamos la referencia 
     218        mcu->ReleaseConferenceRef(confId); 
     219 
     220        //Salimos 
     221        if(!res) 
     222                return xmlerror(env,"No se ha podido terminar la conferencia\n"); 
     223 
     224        //Devolvemos el resultado 
     225        return xmlok(env); 
     226
     227 
     228xmlrpc_value* StartReceivingVideo(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
     229
     230        MCU *mcu = (MCU *)user_data; 
     231        MultiConf *conf = NULL; 
     232 
     233         //Parseamos 
     234        int confId; 
     235        int partId; 
     236        xmlrpc_parse_value(env, param_array, "(ii)", &confId,&partId); 
     237 
     238        //Comprobamos si ha habido error 
     239        if(env->fault_occurred) 
     240                return 0; 
     241          
     242        //Obtenemos la referencia 
     243        if(!mcu->GetConferenceRef(confId,&conf)) 
     244                return xmlerror(env,"La conferencia no existe\n"); 
     245 
     246        //La borramos 
     247        int recVideoPort = conf->StartReceivingVideo(partId); 
     248 
     249        //Liberamos la referencia 
     250        mcu->ReleaseConferenceRef(confId); 
     251 
     252        //Salimos 
     253        if(!recVideoPort) 
     254                return xmlerror(env,"No se ha podido terminar la conferencia\n"); 
     255 
     256        //Devolvemos el resultado 
     257        return xmlok(env,xmlrpc_build_value(env,"(i)",recVideoPort)); 
     258
     259 
     260xmlrpc_value* StopReceivingVideo(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
     261
     262        MCU *mcu = (MCU *)user_data; 
     263        MultiConf *conf = NULL; 
     264 
     265         //Parseamos 
     266        int confId; 
     267        int partId; 
     268        xmlrpc_parse_value(env, param_array, "(ii)", &confId,&partId); 
     269 
     270        //Comprobamos si ha habido error 
     271        if(env->fault_occurred) 
     272                return 0; 
     273          
     274        //Obtenemos la referencia 
     275        if(!mcu->GetConferenceRef(confId,&conf)) 
     276                return xmlerror(env,"La conferencia no existe\n"); 
     277 
     278        //La borramos 
     279        int res = conf->StopReceivingVideo(partId); 
     280 
     281        //Liberamos la referencia 
     282        mcu->ReleaseConferenceRef(confId); 
     283 
     284        //Salimos 
     285        if(!res) 
     286                return xmlerror(env,"Error\n"); 
     287 
     288        //Devolvemos el resultado 
     289        return xmlok(env); 
     290
     291 
     292xmlrpc_value* IsSendingVideo(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
     293
     294        MCU *mcu = (MCU *)user_data; 
     295        MultiConf *conf = NULL; 
     296 
     297         //Parseamos 
     298        int partId; 
     299        int confId; 
     300        xmlrpc_parse_value(env, param_array, "(ii)", &confId,&partId); 
     301 
     302        //Comprobamos si ha habido error 
     303        if(env->fault_occurred) 
     304                return 0; 
     305          
     306        //Obtenemos la referencia 
     307        if(!mcu->GetConferenceRef(confId,&conf)) 
     308                return xmlerror(env,"La conferencia no existe\n"); 
     309 
     310        //La borramos 
     311        int res = conf->IsSendingVideo(partId); 
     312 
     313        //Liberamos la referencia 
     314        mcu->ReleaseConferenceRef(confId); 
     315 
     316        //Devolvemos el resultado 
     317        return xmlok(env,xmlrpc_build_value(env,"(i)",res)); 
     318
     319 
     320xmlrpc_value* IsReceivingVideo(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
     321
     322        MCU *mcu = (MCU *)user_data; 
     323        MultiConf *conf = NULL; 
     324 
     325         //Parseamos 
     326        int confId; 
     327        int partId; 
     328        xmlrpc_parse_value(env, param_array, "(ii)", &confId,&partId); 
     329 
     330        //Comprobamos si ha habido error 
     331        if(env->fault_occurred) 
     332                return 0; 
     333          
     334        //Obtenemos la referencia 
     335        if(!mcu->GetConferenceRef(confId,&conf)) 
     336                return xmlerror(env,"La conferencia no existe\n"); 
     337 
     338        //La borramos 
     339        int res = conf->IsReceivingVideo(partId); 
     340 
     341        //Liberamos la referencia 
     342        mcu->ReleaseConferenceRef(confId); 
     343 
     344        //Devolvemos el resultado 
     345        return xmlok(env,xmlrpc_build_value(env,"(i)",res)); 
     346
     347 
     348xmlrpc_value* SetAudioCodec(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
     349
     350        MCU *mcu = (MCU *)user_data; 
     351        MultiConf *conf = NULL; 
     352 
     353         //Parseamos 
     354        int confId; 
     355        int partId; 
     356        int codec; 
     357 
     358        xmlrpc_parse_value(env, param_array, "(iii)", &confId,&partId,&codec); 
     359 
     360        //Comprobamos si ha habido error 
     361        if(env->fault_occurred) 
     362                return 0; 
     363          
     364        //Obtenemos la referencia 
     365        if(!mcu->GetConferenceRef(confId,&conf)) 
     366                return xmlerror(env,"La conferencia no existe\n"); 
     367 
     368        //La borramos 
     369        int res = conf->SetAudioCodec(partId,codec); 
     370 
     371        //Liberamos la referencia 
     372        mcu->ReleaseConferenceRef(confId); 
     373 
     374        //Salimos 
     375        if(!res) 
     376                return xmlerror(env,"No soportado\n"); 
     377 
     378        //Devolvemos el resultado 
     379        return xmlok(env); 
     380
     381 
     382xmlrpc_value* StartSendingAudio(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
     383
     384        MCU *mcu = (MCU *)user_data; 
     385        MultiConf *conf = NULL; 
     386 
     387         //Parseamos 
     388        int confId; 
     389        int partId; 
     390        char *sendAudioIp; 
     391        int sendAudioPort; 
     392 
     393        xmlrpc_parse_value(env, param_array, "(iisi)", &confId,&partId,&sendAudioIp,&sendAudioPort); 
     394 
     395        //Comprobamos si ha habido error 
     396        if(env->fault_occurred) 
     397                return 0; 
     398          
     399        //Obtenemos la referencia 
     400        if(!mcu->GetConferenceRef(confId,&conf)) 
     401                return xmlerror(env,"La conferencia no existe\n"); 
     402 
     403        //La borramos 
     404        int res = conf->StartSendingAudio(partId,sendAudioIp,sendAudioPort); 
     405 
     406        //Liberamos la referencia 
     407        mcu->ReleaseConferenceRef(confId); 
     408 
     409        //Salimos 
     410        if(!res) 
     411                return xmlerror(env,"Error\n"); 
     412 
     413        //Devolvemos el resultado 
     414        return xmlok(env); 
     415
     416 
     417xmlrpc_value* StopSendingAudio(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
     418
     419        MCU *mcu = (MCU *)user_data; 
     420        MultiConf *conf = NULL; 
     421 
     422         //Parseamos 
     423        int confId; 
     424        int partId; 
     425        xmlrpc_parse_value(env, param_array, "(ii)", &confId,&partId); 
     426 
     427        //Comprobamos si ha habido error 
     428        if(env->fault_occurred) 
     429                return 0; 
     430          
     431        //Obtenemos la referencia 
     432        if(!mcu->GetConferenceRef(confId,&conf)) 
     433                return xmlerror(env,"La conferencia no existe\n"); 
     434 
     435        //La borramos 
     436        int res = conf->StopSendingAudio(partId); 
     437 
     438        //Liberamos la referencia 
     439        mcu->ReleaseConferenceRef(confId); 
     440 
     441        //Salimos 
     442        if(!res) 
     443                return xmlerror(env,"No se ha podido terminar la conferencia\n"); 
     444 
     445        //Devolvemos el resultado 
     446        return xmlok(env); 
     447
     448 
     449xmlrpc_value* StartReceivingAudio(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
     450
     451        MCU *mcu = (MCU *)user_data; 
     452        MultiConf *conf = NULL; 
     453 
     454         //Parseamos 
     455        int confId; 
     456        int partId; 
     457        xmlrpc_parse_value(env, param_array, "(ii)", &confId,&partId); 
     458 
     459        //Comprobamos si ha habido error 
     460        if(env->fault_occurred) 
     461                return 0; 
     462          
     463        //Obtenemos la referencia 
     464        if(!mcu->GetConferenceRef(confId,&conf)) 
     465                return xmlerror(env,"La conferencia no existe\n"); 
     466 
     467        //La borramos 
     468        int recAudioPort = conf->StartReceivingAudio(partId); 
     469 
     470        //Liberamos la referencia 
     471        mcu->ReleaseConferenceRef(confId); 
     472 
     473        //Salimos 
     474        if(!recAudioPort) 
     475                return xmlerror(env,"No se ha podido terminar la conferencia\n"); 
     476 
     477        //Devolvemos el resultado 
     478        return xmlok(env,xmlrpc_build_value(env,"(i)",recAudioPort,recAudioPort)); 
     479
     480 
     481xmlrpc_value* StopReceivingAudio(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
     482
     483        MCU *mcu = (MCU *)user_data; 
     484        MultiConf *conf = NULL; 
     485 
     486         //Parseamos 
     487        int confId; 
     488        int partId; 
     489        xmlrpc_parse_value(env, param_array, "(ii)", &confId,&partId); 
     490 
     491        //Comprobamos si ha habido error 
     492        if(env->fault_occurred) 
     493                return 0; 
     494          
     495        //Obtenemos la referencia 
     496        if(!mcu->GetConferenceRef(confId,&conf)) 
     497                return xmlerror(env,"La conferencia no existe\n"); 
     498 
     499        //La borramos 
     500        int res = conf->StopReceivingAudio(partId); 
     501 
     502        //Liberamos la referencia 
     503        mcu->ReleaseConferenceRef(confId); 
     504 
     505        //Salimos 
     506        if(!res) 
     507                return xmlerror(env,"Error\n"); 
     508 
     509        //Devolvemos el resultado 
     510        return xmlok(env); 
     511
     512 
     513xmlrpc_value* IsSendingAudio(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
     514
     515        MCU *mcu = (MCU *)user_data; 
     516        MultiConf *conf = NULL; 
     517 
     518         //Parseamos 
     519        int partId; 
     520        int confId; 
     521        xmlrpc_parse_value(env, param_array, "(ii)", &confId,&partId); 
     522 
     523        //Comprobamos si ha habido error 
     524        if(env->fault_occurred) 
     525                return 0; 
     526          
     527        //Obtenemos la referencia 
     528        if(!mcu->GetConferenceRef(confId,&conf)) 
     529                return xmlerror(env,"La conferencia no existe\n"); 
     530 
     531        //La borramos 
     532        int res = conf->IsSendingAudio(partId); 
     533 
     534        //Liberamos la referencia 
     535        mcu->ReleaseConferenceRef(confId); 
     536 
     537        //Devolvemos el resultado 
     538        return xmlok(env,xmlrpc_build_value(env,"(i)",res)); 
     539
     540 
     541xmlrpc_value* IsReceivingAudio(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
     542
     543        MCU *mcu = (MCU *)user_data; 
     544        MultiConf *conf = NULL; 
     545 
     546         //Parseamos 
     547        int confId; 
     548        int partId; 
     549        xmlrpc_parse_value(env, param_array, "(ii)", &confId,&partId); 
     550 
     551        //Comprobamos si ha habido error 
     552        if(env->fault_occurred) 
     553                return 0; 
     554          
     555        //Obtenemos la referencia 
     556        if(!mcu->GetConferenceRef(confId,&conf)) 
     557                return xmlerror(env,"La conferencia no existe\n"); 
     558 
     559        //La borramos 
     560        int res = conf->IsReceivingAudio(partId); 
     561 
     562        //Liberamos la referencia 
     563        mcu->ReleaseConferenceRef(confId); 
     564 
     565        //Devolvemos el resultado 
     566        return xmlok(env,xmlrpc_build_value(env,"(i)",res)); 
     567
     568 
     569xmlrpc_value* SetCompositionType(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
     570
     571        MCU *mcu = (MCU *)user_data; 
     572        MultiConf *conf = NULL; 
     573 
     574         //Parseamos 
     575        int confId; 
     576        int comp; 
     577        int size; 
     578        xmlrpc_parse_value(env, param_array, "(iii)", &confId,&comp,&size); 
     579 
     580        //Comprobamos si ha habido error 
     581        if(env->fault_occurred) 
     582                return 0; 
     583          
     584        //Obtenemos la referencia 
     585        if(!mcu->GetConferenceRef(confId,&conf)) 
     586                return xmlerror(env,"La conferencia no existe\n"); 
     587 
     588        //La borramos 
     589        int res = conf->SetCompositionType(comp,size); 
     590 
     591        //Liberamos la referencia 
     592        mcu->ReleaseConferenceRef(confId); 
     593 
     594        //Salimos 
     595        if(!res) 
     596                return xmlerror(env,"Error\n"); 
     597 
     598        //Devolvemos el resultado 
     599        return xmlok(env); 
     600
     601 
     602XmlHandlerCmd mcuCmdList[] = 
    5603{ 
    6604        {"CreateConference",CreateConference}, 
     
    25623        {NULL,NULL} 
    26624}; 
    27  
    28 xmlrpc_value* xmlerror (xmlrpc_env *env,char *msg) 
    29 { 
    30         return xmlrpc_build_value(env,"{s:i,s:s}","returnCode",0,"errorMsg",msg); 
    31 } 
    32  
    33 xmlrpc_value* xmlok (xmlrpc_env *env,xmlrpc_value *array=NULL) 
    34 { 
    35  
    36         //Si es null ponemos uno vacio 
    37         if (array==NULL) 
    38                 array = xmlrpc_build_value(env,"()"); 
    39  
    40         //Creamos el valor de retorno 
    41         xmlrpc_value *ret = xmlrpc_build_value(env,"{s:i,s:A}","returnCode",1,"returnVal",array); 
    42  
    43         //Decrementamos el contador 
    44         xmlrpc_DECREF(array);    
    45  
    46         //Y salimos 
    47         return ret; 
    48 } 
    49  
    50 //CreateConference 
    51 xmlrpc_value* CreateConference(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
    52 { 
    53         MCU *mcu = (MCU *)user_data; 
    54         MultiConf *conf = NULL; 
    55  
    56          //Parseamos 
    57         char *str; 
    58         xmlrpc_parse_value(env, param_array, "(s)", &str); 
    59           
    60         //Creamos la conferencia 
    61         int confId = mcu->CreateConference(str); 
    62  
    63         //Si error 
    64         if (!confId>0) 
    65                 return xmlerror(env,"No se puede crear la conferencia"); 
    66  
    67         //Obtenemos la referencia 
    68         if(!mcu->GetConferenceRef(confId,&conf)) 
    69                 return xmlerror(env,"Conferencia borrada antes de poder iniciarse\n"); 
    70  
    71         //La iniciamos 
    72         int res = conf->Init(); 
    73  
    74         //Liberamos la referencia 
    75         mcu->ReleaseConferenceRef(confId); 
    76  
    77         //Salimos 
    78         if(!res) 
    79                 return xmlerror(env,"No se ha podido iniciar la conferencia\n"); 
    80  
    81         //Devolvemos el resultado 
    82         return xmlok(env,xmlrpc_build_value(env,"(i)",confId)); 
    83 } 
    84  
    85 xmlrpc_value* DeleteConference(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
    86 { 
    87         MCU *mcu = (MCU *)user_data; 
    88         MultiConf *conf = NULL; 
    89  
    90          //Parseamos 
    91         int confId; 
    92         xmlrpc_parse_value(env, param_array, "(i)", &confId); 
    93  
    94         //Comprobamos si ha habido error 
    95         if(env->fault_occurred) 
    96                 return 0; 
    97  
    98         //Delete conference  
    99         if (!mcu->DeleteConference(confId)) 
    100                 return xmlerror(env,"La conferencia no existe\n"); 
    101  
    102         //Devolvemos el resultado 
    103         return xmlok(env); 
    104 } 
    105  
    106 xmlrpc_value* CreateParticipant(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data) 
    107 { 
    108         MCU *mcu = (MCU *)user_data; 
    109         MultiConf *conf = NULL; 
    110  
    111          //Parseamos 
    112         int confId; 
    113         xmlrpc_parse_value(env, param_array, "(i)", &confId); 
    114  
    115         //Comprobamos si ha habido error 
    116         if(env->fault_occurred) 
    117                 return 0; 
    118           
    119         //Obtenemos la referencia 
    120         if(!mcu->GetConferenceRef(confId,&conf)) 
    121                 return xmlerror(env,"La conferencia no existe\n"); 
    122  
    123         //La borramos 
    124         int partId = conf->CreateParticipant();&nb