Changeset 6

Show
Ignore:
Timestamp:
06/24/07 22:31:43 (1 year ago)
Author:
sip
Message:

New mosaic struture.
Resize of incoming frames.
Change composition type on the fly.
Fixed participant hangup.
Modified Makefile and added install option.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • Makefile

    r5 r6  
    22        mkdir -p bin 
    33        make -C media 
     4clean: 
     5        make -C media clean 
     6        rm -rf bin 
     7install: 
     8        make -C media install 

  • config.mk

    r4 r6  
    11################################# 
    2 # Tipo de plataforma:  
    3 #       PLATFORM:       linux,win32 
    4 #       OS:             linux,win32 
     2# Config file 
    53################################## 
    64LOG             = yes 
    75DEBUG           = yes 
    8 SRCDIR          = /root/mcu 
     6SRCDIR          = /usr/mcu 
     7TARGET          = /usr/local 

  • media/Makefile

    r4 r6  
    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  
     38OBJS=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 
    3939OBJS+= $(G711OBJ) $(H263OBJ) $(GSMOBJ)  
    40 OBJSCLIENTE = xmlrpcclient.o xmlrpcmcuclient.o 
     40OBJSCLIENT = xmlrpcclient.o xmlrpcmcuclient.o 
    4141 
    4242BUILDOBJS= $(addprefix $(BUILD)/,$(OBJS)) 
    43 BUILDOBJSCLIENTE= $(addprefix $(BUILD)/,$(OBJSCLIENTE)) 
     43BUILDOBJSCLIENT= $(addprefix $(BUILD)/,$(OBJSCLIENT)) 
    4444 
    4545################################### 
    …… 
    7474#Targets 
    7575############################################ 
    76 all: mkdirs mcu cliente test 
     76all: mkdirs mcu client test 
    7777 
    7878mkdirs:   
    …… 
    8181clean: 
    8282        rm -f $(BUILDOBJS) 
    83         rm -f $(BUILDOBJSCLIENTE) 
     83        rm -f $(BUILDOBJSCLIENT) 
    8484        rm -f "$(BIN)/mcu" 
    85         rm -f "$(BIN)/libmcucliente.so" 
     85        rm -f "$(BIN)/libmcuclient.so" 
    8686        rm -f "$(BIN)/test" 
     87 
     88install: 
     89        mkdir -p  $(TARGET)/lib 
     90        mkdir -p  $(TARGET)/include/mcu 
     91        cp $(BIN)/libmcuclient.so $(TARGET)/lib/libmcuclient.so 
     92        cp $(SRCDIR)/media/include/xmlrpcmcuclient.h $(TARGET)/include/mcu 
     93         
    8794 
    8895############################################ 
    …… 
    93100        $(CXX) $(LDFLAGS) -o $(BIN)/$@ $(BUILDOBJS)  
    94101 
    95 cliente: $(OBJSCLIENTE) 
    96         $(CXX) $(LDXMLFLAGS) -lpthread -lcurl -shared -o $(BIN)/libmcucliente.so  $(BUILDOBJSCLIENTE)  
     102client: $(OBJSCLIENT) 
     103        $(CXX) $(LDXMLFLAGS) -lpthread -lcurl -shared -o $(BIN)/libmcuclient.so  $(BUILDOBJSCLIENT)  
    97104 
    98 test: cliente.o 
    99         $(CXX) $(LDXMLFLAGS) -lpthread -lcurl -o $(BIN)/test  -lmcucliente -L$(BIN) $(BUILD)/cliente.o 
     105test: client.o 
     106        $(CXX) $(LDXMLFLAGS) -lpthread -lcurl -o $(BIN)/test  -lmcuclient -L$(BIN) $(BUILD)/client.o 

  • media/include/audiomixer.h

    r4 r6  
    2424        int Init(); 
    2525        int CreateMixer(int id); 
    26         //int InitMixer(int id); 
    27         //int EndMixer(int id); 
     26        int InitMixer(int id); 
     27        int EndMixer(int id); 
    2828        int DeleteMixer(int id); 
    2929        AudioInput*  GetInput(int id); 

  • media/include/codecs.h

    r4 r6  
    99#define H261            31 
    1010#define H263_1996       34 
    11 #define H263_1998       96 
    12 #define MPEG4           35 
     11#define H263_1998       103 
     12#define MPEG4           104 
    1313 
    1414class AudioCodec 

  • media/include/multiconf.h

    r2 r6  
    1717        int Init(); 
    1818        int CreateParticipant(); 
     19        int SetCompositionType(int comp,int size); 
    1920 
    2021        //Video 

  • media/include/pipeaudioinput.h

    r1 r6  
    1414        virtual int StartRecording(); 
    1515        virtual int StopRecording(); 
    16 //    int Init(); 
     16      int Init(); 
    1717        int PutSamples(WORD *buffer,DWORD size); 
    18 //    int End(); 
     18      int End(); 
    1919 
    2020private: 
    …… 
    2626        fifo<WORD,2048> fifoBuffer; 
    2727        int             recording; 
     28        int             inited; 
    2829 
    2930 

  • media/include/pipeaudiooutput.h

    r1 r6  
    1717 
    1818        int GetSamples(WORD *buffer,DWORD size); 
    19         //int Int(); 
    20         //int End(); 
     19        int Init(); 
     20        int End(); 
    2121private: 
    2222        //Mutex 
    …… 
    2525        //Members 
    2626        fifo<WORD,2048> fifoBuffer; 
     27        int             inited; 
    2728         
    2829 

  • media/include/pipevideoinput.h

    r1 r6  
    1717        virtual int   StopVideoCapture(); 
    1818 
    19         //int Init(); 
     19        int Init(); 
    2020        int SetFrame(BYTE * buffer, int height, int width); 
    21         //int End(); 
     21        int End(); 
    2222 
    2323private: 
    …… 
    2828        int imgPos; 
    2929        int imgNew; 
    30         //int inited; 
     30        int inited; 
    3131        int capturing; 
    3232        BYTE *imgBuffer[2]; 

  • media/include/pipevideooutput.h

    r1 r6  
    1818        int     GetWidth(){return videoWidth;}; 
    1919        int     GetHeight(){return videoHeight;}; 
    20         //int Init(); 
    21         //int End(); 
     20        int   Init(); 
     21        int   End(); 
    2222private: 
    2323        BYTE*   buffer; 
    …… 
    2626        int     videoHeight; 
    2727        int     isChanged; 
     28        int     inited; 
    2829 
    2930        pthread_mutex_t* videoMixerMutex; 

  • media/include/videomixer.h

    r1 r6  
    66#include "pipevideoinput.h" 
    77#include "pipevideooutput.h" 
     8#include "mosaic.h" 
    89#include <map> 
    910using namespace std; 
     11 
     12typedef enum  
     13{ 
     14        mosaic1x1 = 0,  
     15        mosaic2x2 = 1, 
     16        mosaic3x3 = 2 
     17} CompositionType; 
    1018 
    1119class VideoMixer  
    …… 
    1321public: 
    1422        // Los valores indican el número de mosaicos por composicion 
    15         enum CompositionType {mosaic1x1, mosaic2x1, mosaic2x2}; 
    1623 
    1724        VideoMixer(); 
    …… 
    2027        int Init(); 
    2128        int CreateMixer(int id); 
    22 //    int InitMixer(int id); 
    23 //    int EndMixer(int id); 
     29      int InitMixer(int id); 
     30      int EndMixer(int id); 
    2431        int DeleteMixer(int id); 
    2532        VideoInput*  GetInput(int id); 
    2633        VideoOutput* GetOutput(int id); 
    27         int SetCompositionType(CompositionType comp,int type); 
    28         CompositionType GetCompositionType(); 
     34        int GetCompositionType(); 
     35        int SetCompositionType(CompositionType comp,int size); 
    2936        int End(); 
    3037 
    …… 
    3441private: 
    3542        static void * startMixingVideo(void *par); 
    36         int UpdatePosition(int pos, BYTE *image, int imgWidth, int imgHeight); 
    3743 
    3844private: 
    …… 
    5258        //Las propiedades del mosaico 
    5359        CompositionType compositionType; 
    54         int     mosaicCols; 
    55         int     mosaicRows; 
    56         int     mosaicNum; 
    57         int     mosaicWidth; 
    58         int     mosaicHeight; 
    59         int     mosaicTotalWidth; 
    60         int     mosaicTotalHeight; 
    61         int     mosaicSize; 
    62         int     logoSize; 
    63         BYTE    *mosaic; 
    6460        BYTE    *logo; 
     61        Mosaic  *mosaic; 
    6562 
    6663        //Threads, mutex y condiciones 

  • media/include/xmlrpcmcu.h

    r1 r6  
    2929xmlrpc_value* IsReceivingAudio(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data); 
    3030xmlrpc_value* DeleteParticipant(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data); 
     31xmlrpc_value* SetCompositionType(xmlrpc_env *env, xmlrpc_value *param_array, void *user_data); 
    3132 
    3233 

  • media/include/xmlrpcmcuclient.h

    r4 r6  
    11#ifndef _XMLRPCMCUCLIENT_H_ 
    22#define _XMLRPCMCUCLIENT_H_ 
     3 
     4#define PCMA 8 
     5#define PCMU 0 
     6#define GSM  3 
     7#define H261 31 
     8#define H263 103 
     9#define MPEG4 104 
     10 
     11#define MOSAIC1x1 0 
     12#define MOSAIC2x2 1 
     13#define MOSAIC3x3 2 
     14 
     15#define CIF 0 
     16#define QCIF 1 
    317 
    418#ifdef __cplusplus 
    …… 
    1630        int CreateConference(char *name); 
    1731        int CreateParticipant(int confId); 
     32        int SetCompositionType(int confId,int comp,int size); 
    1833 
    1934        //Video 
    …… 
    5772int     CreateParticipant(void *mcu,int confId) 
    5873        { return ((XmlRpcMcuClient*)mcu)->CreateParticipant(confId);            } 
     74int     SetCompositionType(void *mcu,int confId,int comp,int size) 
     75        { return ((XmlRpcMcuClient*)mcu)->SetCompositionType(confId,comp,size); } 
    5976 
    6077//Video 
    …… 
    102119int     CreateConference(void *mcu,char *name); 
    103120int     CreateParticipant(void *mcu,int confId); 
     121int     SetCompositionType(void *mcu,int confId,int comp,int size); 
    104122 
    105123//Video 

  • media/include/xmlrpcproxyclient.h

    r1 r6  
    1313        int InitConference(int confId); 
    1414        int CreateParticipant(int confId); 
     15        int SetCompositionType(int confId,int comp,int size); 
    1516 
    1617        //Video 

  • media/src/audiomixer.cpp

    r1 r6  
    302302} 
    303303 
    304 #if 0 
    305304/*********************** 
    306305* InitMixer 
    …… 
    330329 
    331330        //INiciamos los pipes 
    332         //audio->input->Init(); 
    333         //audio->output->Init(); 
     331        audio->input->Init(); 
     332        audio->output->Init(); 
    334333 
    335334        //Desprotegemos 
    …… 
    368367 
    369368        //Terminamos 
    370         //audio->input->End(); 
    371         //audio->output->End(); 
     369        audio->input->End(); 
     370        audio->output->End(); 
    372371 
    373372        //Desprotegemos 
    …… 
    377376        return true;; 
    378377} 
    379 #endif 
    380378 
    381379/*********************** 

  • media/src/client.cpp

    r4 r6  
    22#include <xmlrpc.h> 
    33#include "xmlrpcmcuclient.h" 
    4  
    5 #define PCMA 8 
    6 #define PCMU 0 
    7 #define GSM  3 
    8 #define H261 31 
    9 #define H263 96 
    10 #define MPEG4 35 
    11  
    12 #define CIF 0 
    13 #define QCIF 1 
    144 
    155int main() 
    …… 
    3020        mcu.StartReceivingVideo(confId,partId,&port); 
    3121        printf("%d",port); 
     22 
     23        mcu.SetCompositionType(confId,0,0); 
    3224} 
    3325 

  • media/src/multiconf.cpp

    r4 r6  
    3838        Log("-Init multiconf\n"); 
    3939 
    40         //POnemos el tipo de video mixer 
    41         videoMixer.SetCompositionType(VideoMixer::mosaic2x2,CIF); 
     40        //Set default composition 
     41        SetCompositionType(mosaic2x2,CIF); 
    4242 
    4343        //INiciamos los mixers 
    …… 
    4949 
    5050        return 1; 
     51} 
     52 
     53/************************ 
     54* SetCompositionType 
     55*       Set mosaic type and size 
     56*************************/ 
     57int MultiConf::SetCompositionType(int comp,int size) 
     58{ 
     59        Log("-SetCompositionType [%d,%d]\n",comp,size); 
     60 
     61        //POnemos el tipo de video mixer 
     62        return videoMixer.SetCompositionType((CompositionType)comp,size); 
    5163} 
    5264 
    …… 
    8799        part->audio.SetAudioCodec(GSM); 
    88100         
    89         //E iniciamos el mixer 
    90         //videoMixer.InitMixer(partId); 
    91         //audioMixer.InitMixer(partId); 
    92  
    93101        //Iniciamos el audio y video 
    94102        part->video.Init(videoMixer.GetInput(partId),videoMixer.GetOutput(partId)); 
    95103        part->audio.Init(audioMixer.GetInput(partId),audioMixer.GetOutput(partId)); 
    96104 
     105        //E iniciamos el mixer 
     106        videoMixer.InitMixer(partId); 
     107        audioMixer.InitMixer(partId); 
    97108 
    98109        //Lo insertamos en el map 
    …… 
    120131 
    121132        //Paramos el mixer 
    122         //videoMixer.EndMixer(id); 
    123         //audioMixer.EndMixer(id); 
     133        videoMixer.EndMixer(id); 
     134        audioMixer.EndMixer(id); 
    124135         
    125136        //LO obtenemos 

  • media/src/pipeaudioinput.cpp

    r1 r6  
    120120} 
    121121 
    122 #if 0 
    123122int PipeAudioInput::Init() 
    124123{ 
    …… 
    152151        return true; 
    153152} 
    154 #endif 

  • media/src/pipeaudiooutput.cpp

    r1 r6  
    6262        return len; 
    6363} 
     64int PipeAudioOutput::Init() 
     65{ 
     66        Log("PipeAudioOutput init\n"); 
     67 
     68        //Protegemos 
     69        pthread_mutex_lock(&mutex); 
     70 
     71        //Iniciamos 
     72        inited = true; 
     73 
     74        //Protegemos 
     75        pthread_mutex_unlock(&mutex); 
     76 
     77        return true; 
     78}  
     79 
     80int PipeAudioOutput::End() 
     81{ 
     82        //Protegemos 
     83        pthread_mutex_lock(&mutex); 
     84 
     85        //Terminamos 
     86        inited = false; 
     87 
     88        //Señalizamos la condicion 
     89        //pthread_cond_signal(&newPicCond); 
     90 
     91        //Protegemos 
     92        pthread_mutex_unlock(&mutex); 
     93 
     94        return true; 
     95}  

  • media/src/pipevideoinput.cpp

    r4 r6  
    2222} 
    2323 
    24 #if 0 
    2524int PipeVideoInput::Init() 
    2625{ 
    …… 
    5554        return true; 
    5655}  
    57  
    58 #endif 
    5956 
    6057int PipeVideoInput::StartVideoCapture(int width,int height,int fps) 
    …… 
    152149int PipeVideoInput::SetFrame(BYTE * buffer, int width, int height) 
    153150{ 
    154         Log("-SetFrame [%d]\n",capturing); 
    155  
    156151        //Protegemos 
    157152        pthread_mutex_lock(&newPicMutex); 

  • media/src/pipevideooutput.cpp

    r1 r6  
    1717        videoWidth  = 0; 
    1818        videoHeight = 0; 
    19  
    2019} 
    2120 
    …… 
    2726                free(buffer); 
    2827} 
    29  
    30 /* 
    31 int PipeVideoOutput::Init() 
    32 { 
    33         return 1; 
    34 } 
    35  
    36 int PipeVideoOutput::End() 
    37 { 
    38         return 1; 
    39 } 
    40 */ 
    4128 
    4229int PipeVideoOutput::NextFrame(BYTE *pic) 
    …… 
    8875} 
    8976 
     77int PipeVideoOutput::Init() 
     78{ 
     79        Log("PipeVideoOutput init\n"); 
     80 
     81        //Protegemos 
     82        pthread_mutex_lock(videoMixerMutex); 
     83 
     84        //Iniciamos 
     85        inited = true; 
     86 
     87        //Protegemos 
     88        pthread_mutex_unlock(videoMixerMutex); 
     89 
     90        return true; 
     91}  
     92 
     93int PipeVideoOutput::End() 
     94{ 
     95        //Protegemos 
     96        pthread_mutex_lock(videoMixerMutex); 
     97 
     98        //Terminamos 
     99        inited = false; 
     100 
     101        //Señalizamos la condicion 
     102        pthread_cond_signal(videoMixerCond); 
     103 
     104        //Protegemos 
     105        pthread_mutex_unlock(videoMixerMutex); 
     106 
     107        return true; 
     108}  

  • media/src/videomixer.cpp

    r4 r6  
    33#include <pipevideoinput.h> 
    44#include <pipevideooutput.h> 
     5#include <partedmosaic.h> 
    56 
    67/*********************** 
    …… 
    1112{ 
    1213        //Incializamos a cero 
    13         mosaicSize      = 0; 
    14         mosaicWidth     = 0; 
    15         mosaicHeight    = 0; 
    16         mosaicNum       = 0; 
    17         mosaicCols      = 0; 
    18         mosaicRows      = 0; 
     14        mosaic  = NULL; 
    1915 
    2016        //Inciamos lso mutex y la condicion 
    …… 
    5955{ 
    6056        int id; 
    61         int mosaicChanged = true; 
    6257        VideoSource *video; 
    6358 
    …… 
    7469 
    7570                //Si no ha cambiado el frame volvemos al principio 
    76                 if (mosaicChanged) 
     71                if (mosaic->HasChanged()) 
    7772                { 
    78                         Log("-Updating\n"); 
    79  
    8073                        //Nos recorremos los videos 
    8174                        for (it=lstVideos.begin();it!=lstVideos.end();it++) 
    …… 
    8679 
    8780                                //Colocamos el frame 
    88                                 video->input->SetFrame(mosaic,mosaicTotalWidth,mosaicTotalHeight); 
     81                                video->input->SetFrame(mosaic->GetFrame(),mosaic->GetWidth(),mosaic->GetHeight()); 
    8982                        } 
    9083                } 
    9184 
    9285                //Reset 
    93                 mosaicChanged = false; 
     86                mosaic->Reset(); 
    9487 
    9588                //Desprotege la lista 
    …… 
    109102                        video = (*it).second; 
    110103                         
    111                         //Si ha cambiado 
     104                        //If we've got a new frame on source 
    112105                        if (video->output->IsChanged()) 
    113                         { 
    114                                 //Actualizamos el mosaico 
    115                                 UpdatePosition(id-1,video->output->GetFrame(),video->output->GetWidth(),video->output->GetHeight()); 
    116  
    117                                 //Y hemos cambiado el frame 
    118                                 mosaicChanged = true; 
    119                         } 
     106                                //Change mosaic 
     107                                mosaic->Update(id-1,video->output->GetFrame(),video->output->GetWidth(),video->output->GetHeight()); 
    120108                } 
    121109 
    …… 
    136124int VideoMixer::Init() 
    137125{ 
    138         //Alocamos el mosaico 
    139         mosaic = (BYTE *) malloc(mosaicSize); 
    140  
    141         //Lo ponemos a cero 
    142         memset(mosaic,0,mosaicSize); 
     126        //If we don't have mosaic 
     127        if (!mosaic) 
     128                //Error 
     129                return 0; 
    143130 
    144131        //Allocamos para el logo 
    145         logo = (BYTE *) malloc(logoSize); 
     132        //logo = (BYTE *) malloc(logoSize); 
    146133 
    147134        //Lo obtenemos 
    …… 
    149136 
    150137        //Ponemos el logito 
    151         for (int i=0;i<mosaicNum;i++) 
    152                 UpdatePosition(i,logo,mosaicWidth,mosaicHeight); 
     138        //for (int i=0;i<mosaicNum;i++) 
     139                //UpdatePosition(i,logo,mosaicWidth,mosaicHeight); 
    153140 
    154141        // Estamos mzclando 
    …… 
    192179                DeleteMixer((*it).first); 
    193180 
    194         //Liberamos el mosaico 
    195         free(mosaic); 
     181        //If we've got mosaic 
     182        if (mosaic) 
     183                //Delete it 
     184                delete mosaic; 
    196185 
    197186        //Y el logo 
    198         free(logo); 
     187        //free(logo); 
    199188 
    200189        Log("<End videomixer\n"); 
    …… 
    209198int VideoMixer::CreateMixer(int id) 
    210199{ 
    211         Log(">CreateMixer video [%d,%d,%d]\n",id,mosaicTotalWidth,mosaicTotalHeight); 
     200        Log(">CreateMixer video [%d]\n",id); 
    212201 
    213202        //Protegemos la lista 
    …… 
    241230} 
    242231 
    243 #if 0 
    244232/*********************** 
    245233* InitMixer 
    …… 
    316304        return true; 
    317305} 
    318 #endif  
    319306 
    320307/*********************** 
    …… 
    408395        //Si esta devolvemos el input 
    409396        return (VideoOutput*)(*it).second->output; 
     397} 
     398 
     399/************************** 
     400* GetCompositionType 
     401*       Obtiene el modo de mosaico 
     402***************************/ 
     403int VideoMixer::GetCompositionType() 
     404{ 
     405        return compositionType; 
    410406} 
    411407 
    …… 
    416412int VideoMixer::SetCompositionType(CompositionType comp, int type) 
    417413{ 
    418         //Dependiendo del tipo 
    419         switch(type) 
    420         { 
    421                 case CIF: 
    422                         mosaicTotalWidth = 352; 
    423                         mosaicTotalHeight= 288; 
     414 
     415        Log(">SetCompositionType [%d,%d]\n",comp,type); 
     416 
     417        //Protegemos la lista 
     418        lstVideosUse.WaitUnusedAndLock(); 
     419 
     420        //If we've got mosaic 
     421        if (mosaic) 
     422                //Delete it 
     423                delete mosaic; 
     424 
     425        //Create mosaic depending on composition 
     426        switch(comp) 
     427        { 
     428                case mosaic1x1: 
     429                        //Set mosaic 
     430                        mosaic = new PartedMosaic(1,type); 
    424431                        break; 
    425                 case QCIF: 
    426                         mosaicTotalWidth = 176; 
    427                         mosaicTotalHeight= 144; 
     432                case mosaic2x2: 
     433                        //Set mosaic 
     434                        mosaic = new PartedMosaic(2,type); 
     435                        break; 
     436                case mosaic3x3: 
     437                        //Set mosaic 
     438                        mosaic = new PartedMosaic(3,type); 
    428439                        break; 
    429440                default: 
    430                         return 0; 
    431         } 
    432  
    433         //El tamaño 
    434         mosaicSize = (mosaicTotalWidth * mosaicTotalHeight * 3)/2; 
    435  
    436  
    437         //Dependiendo del tipo de composicion 
    438         switch(comp) 
    439         { 
    440                 case mosaic1x1: 
    441                         mosaicNum = 1; 
    442                         mosaicCols = 1; 
    443                         mosaicRows = 1; 
    444                         mosaicWidth = mosaicTotalWidth; 
    445                         mosaicHeight = mosaicTotalHeight; 
    446                         break; 
    447                 case mosaic2x1: 
    448                         mosaicNum = 2; 
    449                         mosaicCols = 1; 
    450                         mosaicRows = 1; 
    451                         mosaicWidth = mosaicTotalWidth/2; 
    452                         mosaicHeight = mosaicTotalHeight/2; 
    453                         break; 
    454                 case mosaic2x2: 
    455                         mosaicNum = 4; 
    456                         mosaicCols = 2; 
    457                         mosaicRows = 2; 
    458                         mosaicWidth = mosaicTotalWidth/2; 
    459                         mosaicHeight = mosaicTotalHeight/2; 
    460                         break; 
    461                 default: 
    462                         return 0; 
    463         } 
    464  
    465         //Y el del logo 
    466         logoSize = (mosaicWidth*mosaicHeight*3)/2; 
    467  
    468         //Nos quedamos con el tipo 
     441                        //No mosaic 
     442                        mosaic = NULL; 
     443        } 
     444 
     445        //Save type 
    469446        compositionType = comp; 
    470447 
     448        //Desprotegemos la lista 
     449        lstVideosUse.Unlock(); 
     450 
     451        Log("<SetCompositionType\n"); 
     452 
    471453        return 1; 
    472454} 
    473455 
    474 /************************** 
    475 * GetCompositionType 
    476 *       Obtiene el modo de mosaico 
    477 ***************************/ 
    478 /*CompositionType VideoMixer::GetCompositionType(CompositionType comp) 
    479 { 
    480         return compositionType; 
    481 }*/ 
    482  
    483 /***************************** 
    484 * UpdatePosition 
    485 *       Actualiza el cuadrante del mosaico con una imagen 
    486 *****************************/ 
    487 int VideoMixer::UpdatePosition(int pos, BYTE *image, int imgWidth, int imgHeight) 
    488 { 
    489         //Los punteros 
    490         DWORD mosaicNumPixels = mosaicTotalWidth*mosaicTotalHeight; 
    491         DWORD offset,offset2; 
    492         BYTE *lineaY; 
    493         BYTE *lineaU; 
    494         BYTE *lineaV; 
    495          
    496         DWORD imgNumPixels = imgHeight*imgWidth; 
    497         BYTE *imageY = image; 
    498         BYTE *imageU  = image  + imgNumPixels; 
    499         BYTE *imageV  = imageU + imgNumPixels/4; 
    500  
    501         //Comprobamos que esta dentro 
    502         if (pos >= mosaicNum) 
    503                 return 0; 
    504  
    505         //Obtenemos la posicion en el mosaico 
    506         int i = pos / mosaicCols; 
    507         int j = pos - i*mosaicCols; 
    508  
    509         //Obtenemos el offset 
    510         offset = (mosaicTotalWidth*mosaicHeight*i) + mosaicWidth*j;  
    511         offset2 = (mosaicTotalWidth*mosaicHeight*i)/4+(mosaicWidth*j)/2; 
    512  
    513         //Y los punteros 
    514         lineaY = mosaic + offset; 
    515         lineaU = mosaic + mosaicNumPixels + offset2; 
    516         lineaV = lineaU + mosaicNumPixels/4;  
    517  
    518         //Si los tamaños son iguales 
    519         if (imgWidth == mosaicWidth)  
    520         { 
    521                 //copiamos la Y 
    522                 for (int i = 0; i<mosaicHeight; i++)  
    523                 { 
    524                         //Copiamos dos lineas de Y 
    525                         memcpy(lineaY, imageY, imgWidth); 
    526  
    527                         //Saltamos a las siguientes 
    528                         lineaY += mosaicTotalWidth; 
    529                         imageY += imgWidth; 
    530                 } 
    531  
    532                 //Y una de U y V 
    533                 for (int i = 0; i<mosaicHeight/2; i++)  
    534                 { 
    535                         //Copiamos 
    536                         memcpy(lineaU, imageU, imgWidth/2); 
    537                         memcpy(lineaV, imageV, imgWidth/2); 
    538  
    539                         lineaU += mosaicTotalWidth/2; 
    540                         lineaV += mosaicTotalWidth/2; 
    541  
    542                         imageU += imgWidth/2; 
    543                         imageV += imgWidth/2; 
    544                 } 
    545         }  
    546  
    547         return 1; 
    548 } 

  • media/src/videostream.cpp

    r4 r6  
    412412                //Nos quedamos con el puntero antes de que lo cambien 
    413413                pic=videoInput->GrabFrame(); 
    414         Log("-PIC\n"); 
    415414 
    416415                //Si es nulo 
    417416                if (!pic) 
    418                         continue; 
     417                        //Exit 
     418                        break;; 
    419419 
    420420                //Mandamos un FPU cada 220 muestras 
    …… 
    440440                                bitRateControl=0; 
    441441                } 
    442         Log("-NEC\n"); 
    443442 
    444443                //Procesamos el frame 
    445444                videoEncoder->EncodeFrame(pic,videoInput->GetBufferSize()); 
    446         Log("-ENC\n"); 
    447445 
    448446                //Actualizamos el timepod e captura y codificacion del frame