mipvideosession.h

Go to the documentation of this file.

/*
    
  This file is a part of EMIPLIB, the EDM Media over IP Library.
  
  Copyright (C) 2006-2011  Hasselt University - Expertise Centre for
                      Digital Media (EDM) (http://www.edm.uhasselt.be)

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  
  USA

*/

#ifndef MIPVIDEOSESSION_H

#define MIPVIDEOSESSION_H

#include "mipconfig.h"

#if defined(MIPCONFIG_SUPPORT_AVCODEC) && (defined(MIPCONFIG_SUPPORT_DIRECTSHOW) || defined(MIPCONFIG_SUPPORT_VIDEO4LINUX))

#include "mipcomponentchain.h"
#include "miperrorbase.h"
#include "miptime.h"
#include <jrtplib3/rtptransmitter.h>
#include <string>

namespace jrtplib
{
        class RTPSession;
        class RTPAddress;
}

class MIPRTPSynchronizer;
class MIPDirectShowCapture;
class MIPV4L2Input;
class MIPAVCodecEncoder;
class MIPRTPH263Encoder;
class MIPRTPVideoEncoder;
class MIPRTPComponent;
class MIPAverageTimer;
class MIPRTPDecoder;
class MIPRTPH263Decoder;
class MIPRTPVideoDecoder;
class MIPRTPDummyDecoder;
class MIPMediaBuffer;
class MIPAVCodecDecoder;
class MIPVideoMixer;
class MIPQtOutput;
class MIPVideoFrameStorage;
class MIPTinyJPEGDecoder;
class MIPAVCodecFrameConverter;
class MIPComponentAlias;

class EMIPLIB_IMPORTEXPORT MIPVideoSessionParams
{
public:
        enum SessionType 
        { 
                InputOutput,    
                OutputOnly      
        };
        
        enum EncodingType 
        { 
                H263,           
                IntH263,        
                IntYUV420       
        };

        MIPVideoSessionParams()                                                         
        { 
                m_devNum = 0;
                m_devName = std::string("/dev/video0"); 
                m_width = 160;
                m_height = 120;
                m_frameRate = 15.0;
                m_portbase = 5100; 
                m_acceptOwnPackets = false;
                m_bandwidth = 200000;
                m_qtoutput = true;
                m_type = InputOutput;
                m_outH263PayloadType = 34;
                m_inH263PayloadType = 34;
                m_outIntPayloadType = 103;
                m_inIntPayloadType = 103;
                m_encType = H263;
                m_waitForKeyframe = true;
                m_maxPayloadSize = 64000;
        }
        ~MIPVideoSessionParams()                                                        { }

        int getDeviceNumber() const                                                     { return m_devNum; }

        std::string getDeviceName() const                                               { return m_devName; }

        int getWidth() const                                                            { return m_width; }
        
        int getHeight() const                                                           { return m_height; }

        real_t getFrameRate() const                                                     { return m_frameRate; }

        uint16_t getPortbase() const                                                    { return m_portbase; }

        bool getAcceptOwnPackets() const                                                { return m_acceptOwnPackets; }

        int getBandwidth() const                                                        { return m_bandwidth; }
        
        bool getUseQtOutput() const                                                     { return m_qtoutput; }

        SessionType getSessionType() const                                              { return m_type; }

        uint8_t getIncomingH263PayloadType() const                                      { return m_inH263PayloadType; }

        uint8_t getOutgoingH263PayloadType() const                                      { return m_outH263PayloadType; }

        uint8_t getIncomingInternalPayloadType() const                                  { return m_inIntPayloadType; }

        uint8_t getOutgoingInternalPayloadType() const                                  { return m_outIntPayloadType; }

        EncodingType getEncodingType() const                                            { return m_encType; }

        bool getWaitForKeyframe() const                                                 { return m_waitForKeyframe; }

        int getMaximumPayloadSize() const                                               { return m_maxPayloadSize; }

        void setDevice(int n)                                                           { m_devNum = n; }

        void setDevice(const std::string &devName)                                      { m_devName = devName; }

        void setWidth(int w)                                                            { m_width = w; }
        
        void setHeight(int h)                                                           { m_height = h; }

        void setBandwidth(int b)                                                        { m_bandwidth = b; }

        void setFrameRate(real_t r)                                                     { m_frameRate = r; }

        void setPortbase(uint16_t p)                                                    { m_portbase = p; }
        
        void setAcceptOwnPackets(bool v)                                                { m_acceptOwnPackets = v; }

        void setUseQtOutput(bool f)                                                     { m_qtoutput = f; }

        void setSessionType(SessionType s)                                              { m_type = s; }

        void setIncomingH263PayloadType(uint8_t pt)                                     { m_inH263PayloadType = pt; }

        void setOutgoingH263PayloadType(uint8_t pt)                                     { m_outH263PayloadType = pt; }

        void setIncomingInternalPayloadType(uint8_t pt)                                 { m_inIntPayloadType = pt; }

        void setOutgoingInternalPayloadType(uint8_t pt)                                 { m_outIntPayloadType = pt; }

        void setEncodingType(EncodingType t)                                            { m_encType = t; }

        void setWaitForKeyframe(bool w)                                                 { m_waitForKeyframe = w; }

        void setMaximumPayloadSize(int s)                                               { m_maxPayloadSize = s; }
private:
        int m_devNum;
        std::string m_devName;
        int m_width, m_height;
        real_t m_frameRate;
        uint16_t m_portbase;
        bool m_acceptOwnPackets;
        int m_bandwidth;
        bool m_qtoutput;
        SessionType m_type;
        uint8_t m_inH263PayloadType;
        uint8_t m_outH263PayloadType;
        uint8_t m_inIntPayloadType;
        uint8_t m_outIntPayloadType;
        EncodingType m_encType; 
        bool m_waitForKeyframe;
        int m_maxPayloadSize;
};

class EMIPLIB_IMPORTEXPORT MIPVideoSession : public MIPErrorBase
{
public:
        MIPVideoSession();
        virtual ~MIPVideoSession();

        bool init(const MIPVideoSessionParams *pParams = 0, MIPRTPSynchronizer *pSync = 0, jrtplib::RTPSession *pRTPSession = 0);
        
        bool destroy();

        bool addDestination(const jrtplib::RTPAddress &addr);

        bool deleteDestination(const jrtplib::RTPAddress &addr);

        bool clearDestinations();

        bool supportsMulticasting();

        bool joinMulticastGroup(const jrtplib::RTPAddress &addr);

        bool leaveMulticastGroup(const jrtplib::RTPAddress &addr);

        bool leaveAllMulticastGroups();
        
        bool setReceiveMode(jrtplib::RTPTransmitter::ReceiveMode m);

        bool addToIgnoreList(const jrtplib::RTPAddress &addr);

        bool deleteFromIgnoreList(const jrtplib::RTPAddress &addr);

        bool clearIgnoreList();

        bool addToAcceptList(const jrtplib::RTPAddress &addr);

        bool deleteFromAcceptList(const jrtplib::RTPAddress &addr);

        bool clearAcceptList();

        bool getSourceIDs(std::list<uint64_t> &sourceIDs);

        bool getVideoFrame(uint64_t sourceID, uint8_t **pData, int *pWidth, int *pHeight, MIPTime minimalTime = MIPTime(0));
protected:
        virtual void onInputThreadExit(bool err, const std::string &compName, const std::string &errStr)        { }

        virtual void onOutputThreadExit(bool err, const std::string &compName, const std::string &errStr)       { }
private:
        class InputChain : public MIPComponentChain
        {
        public:
                InputChain(MIPVideoSession *pVideoSess) : MIPComponentChain("Input chain")              { m_pVideoSess = pVideoSess; }
        protected:
                void onThreadExit(bool err, const std::string &compName, const std::string &errStr)     { m_pVideoSess->onInputThreadExit(err, compName, errStr); }
        private:
                MIPVideoSession *m_pVideoSess;
        };

        class OutputChain : public MIPComponentChain
        {
        public:
                OutputChain(MIPVideoSession *pVideoSess) : MIPComponentChain("Output chain")            { m_pVideoSess = pVideoSess; }
        protected:
                void onThreadExit(bool err, const std::string &compName, const std::string &errStr)     { m_pVideoSess->onOutputThreadExit(err, compName, errStr); }
        private:
                MIPVideoSession *m_pVideoSess;
        };

        void zeroAll();
        void deleteAll();

        bool m_init;
        
        InputChain *m_pInputChain;
        OutputChain *m_pOutputChain;
        MIPAverageTimer *m_pTimer;
#ifdef MIPCONFIG_SUPPORT_DIRECTSHOW
        MIPDirectShowCapture *m_pInput;
#else
        MIPV4L2Input *m_pInput;
#endif // MIPCONFIG_SUPPORT_DIRECTSHOW
        MIPTinyJPEGDecoder *m_pTinyJpegDec;
        MIPAVCodecFrameConverter *m_pInputFrameConverter;
        MIPAVCodecFrameConverter *m_pOutputFrameConverter;
        MIPAVCodecEncoder *m_pAvcEnc;
        MIPRTPH263Encoder *m_pRTPH263Enc;
        MIPRTPVideoEncoder *m_pRTPIntVideoEnc;
        MIPRTPComponent *m_pRTPComp;
        
        jrtplib::RTPSession *m_pRTPSession;
        bool m_deleteRTPSession;
        
        MIPAverageTimer *m_pTimer2;
        MIPRTPDecoder *m_pRTPDec;
        MIPRTPH263Decoder *m_pRTPH263Dec;
        MIPRTPVideoDecoder *m_pRTPIntVideoDec;
        MIPRTPDummyDecoder *m_pRTPDummyDec;
        MIPMediaBuffer *m_pMediaBuf;
        MIPComponentAlias *m_pBufferAlias;
        MIPAVCodecDecoder *m_pAvcDec;
        MIPVideoMixer *m_pMixer;
        MIPQtOutput *m_pQtOutput;
        MIPVideoFrameStorage *m_pStorage;
        
        friend class InputChain;
        friend class OutputChain;
};

#endif // MIPCONFIG_SUPPORT_AVCODEC && (MIPCONFIG_SUPPORT_DIRECTSHOW || MIPCONFIG_SUPPORT_VIDEO4LINUX)

#endif // MIPVIDEOSESSION_H