mipaudiosession.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 MIPAUDIOSESSION_H

#define MIPAUDIOSESSION_H

#include "mipconfig.h"

#if (defined(MIPCONFIG_SUPPORT_WINMM) || defined(MIPCONFIG_SUPPORT_OSS) || defined(MIPCONFIG_SUPPORT_PORTAUDIO) )

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

namespace jrtplib
{
        class RTPSession;
        class RTPAddress;
}

class MIPComponent;
class MIPRTPComponent;
class MIPRTPSynchronizer;
class MIPRTPPacketDecoder;

class EMIPLIB_IMPORTEXPORT MIPAudioSessionParams
{
public:
        enum CompressionType 
        { 
                ULaw, 
                ALaw,
                LPC, 
                GSM, 
                Speex,
                L16Mono
        };

        enum SpeexBandWidth 
        { 
                NarrowBand,
                WideBand,               
                UltraWideBand
        };
        
        MIPAudioSessionParams()                                                         
        { 
#ifdef MIPCONFIG_SUPPORT_WINMM
                m_inputDevID = WAVE_MAPPER;
                m_outputDevID = WAVE_MAPPER;
#else
                m_inputDevID = 0;
                m_outputDevID = 0;
#endif // MIPCONFIG_SUPPORT_WINMM
                m_inputDevName = std::string("/dev/dsp"); 
                m_outputDevName = std::string("/dev/dsp"); 
                m_highPriority = false;
                m_portbase = 5000; 
                m_acceptOwnPackets = false; 
                m_speexMode = WideBand;
                m_speexIncomingPT = 96;
                m_speexOutgoingPT = 96;
#ifdef _WIN32_WCE
                m_inputMultiplier = 3;
                m_outputMultiplier = 2;
#else
                m_inputMultiplier = 1;
                m_outputMultiplier = 1;
#endif // _WIN32_WCE
                m_compType = ULaw;
                m_disableInterChainTimer = false;
        }
        ~MIPAudioSessionParams()                                                        { }
        
        unsigned int getInputDeviceID() const                                           { return m_inputDevID; }

        unsigned int getOutputDeviceID() const                                          { return m_outputDevID; }

        std::string getInputDeviceName() const                                          { return m_inputDevName; }
        
        std::string getOutputDeviceName() const                                         { return m_outputDevName; }

        bool getUseHighPriority() const                                                 { return m_highPriority; }

        uint16_t getPortbase() const                                                    { return m_portbase; }

        bool getAcceptOwnPackets() const                                                { return m_acceptOwnPackets; }
        
        CompressionType getCompressionType() const                                      { return m_compType; }
        
        SpeexBandWidth getSpeexEncoding() const                                         { return m_speexMode; }

        uint8_t getSpeexIncomingPayloadType() const                                     { return m_speexIncomingPT; }

        uint8_t getSpeexOutgoingPayloadType() const                                     { return m_speexOutgoingPT; }
        
        int getInputMultiplier() const                                                  { return m_inputMultiplier; }

        int getOutputMultiplier() const                                                 { return m_outputMultiplier; }

        bool getDisableInterChainTimer() const                                          { return m_disableInterChainTimer; }

        void setInputDevice(unsigned int ID)                                            { m_inputDevID = ID; }
        
        void setOutputDevice(unsigned int ID)                                           { m_outputDevID = ID; }

        void setInputDevice(const std::string &devName)                                 { m_inputDevName = devName; }
        
        void setOutputDevice(const std::string &devName)                                { m_outputDevName = devName; }

        void setUseHighPriority(bool f)                                                 { m_highPriority = f; }

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

        void setCompressionType(CompressionType t)                                      { m_compType = t; }

        void setSpeexEncoding(SpeexBandWidth b)                                         { m_speexMode = b; }

        void setSpeexIncomingPayloadType(uint8_t pt)                                    { m_speexIncomingPT = pt; }
        
        void setSpeexOutgoingPayloadType(uint8_t pt)                                    { m_speexOutgoingPT = pt; }

        void setInputMultiplier(int m)                                                  { m_inputMultiplier = m; }

        void setOutputMultiplier(int m)                                                 { m_outputMultiplier = m; }

        void setDisableInterChainTimer(bool f)                                          { m_disableInterChainTimer = f; }
private:
        unsigned int m_inputDevID, m_outputDevID;
        std::string m_inputDevName, m_outputDevName;
        bool m_highPriority;
        uint16_t m_portbase;
        bool m_acceptOwnPackets;
        SpeexBandWidth m_speexMode;
        int m_inputMultiplier, m_outputMultiplier;
        CompressionType m_compType;
        uint8_t m_speexOutgoingPT, m_speexIncomingPT;
        bool m_disableInterChainTimer;
};

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

        bool init(const MIPAudioSessionParams *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();
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)       { }

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

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

        class IOChain : public MIPComponentChain
        {
        public:
                IOChain(MIPAudioSession *pAudioSess) : MIPComponentChain("Input/Output chain")          { m_pAudioSess = pAudioSess; }
        protected:
                void onThreadExit(bool err, const std::string &compName, const std::string &errStr)     { m_pAudioSess->onIOThreadExit(err, compName, errStr); }
        private:
                MIPAudioSession *m_pAudioSess;
        };

        void zeroAll();
        void deleteAll();
        void storeComponent(MIPComponent *pComp);
        void storePacketDecoder(MIPRTPPacketDecoder *pDec);
        void addLink(MIPComponentChain *pChain, MIPComponent **pPrevComp, MIPComponent *pComp, 
                     bool feedback = false, uint32_t mask1 = MIPMESSAGE_TYPE_ALL, uint32_t mask2 = MIPMESSAGE_TYPE_ALL);

        bool m_init;
        
        InputChain *m_pInputChain;
        OutputChain *m_pOutputChain;
        IOChain *m_pIOChain;
        
        MIPRTPComponent *m_pRTPComp;
        jrtplib::RTPSession *m_pRTPSession;
        bool m_deleteRTPSession;
        std::list<MIPComponent *> m_components;
        std::list<MIPRTPPacketDecoder *> m_packetDecoders;
        
        friend class InputChain;
        friend class OutputChain;
        friend class IOChain;
};

#endif // MIPCONFIG_SUPPORT_WINMM || MIPCONFIG_SUPPORT_OSS || MIPCONFIG_SUPPORT_PORTAUDIO

#endif // MIPAUDIOSESSION_H