lidep.h

Go to the documentation of this file.

/*
 * lidep.h
 *
 * Line Interface Device EndPoint
 *
 * Open Phone Abstraction Library
 *
 * Copyright (c) 2001 Equivalence Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Open H323 Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Portions of this code were written with the assisance of funding from 
 * Quicknet Technologies, Inc. http://www.quicknet.net.
 * 
 * Contributor(s): ______________________________________.
 */

#ifndef OPAL_LIDS_LIDEP_H
#define OPAL_LIDS_LIDEP_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal_config.h>

#if OPAL_LID

#include <opal/endpoint.h>
#include <lids/lid.h>
#include <codec/silencedetect.h>


class OpalLineConnection;


class OpalLineEndPoint : public OpalEndPoint
{
  PCLASSINFO(OpalLineEndPoint, OpalEndPoint);

  public:
    OpalLineEndPoint(
      OpalManager & manager   
    );

    ~OpalLineEndPoint();

    virtual PSafePtr<OpalConnection> MakeConnection(
      OpalCall & call,          
      const PString & party,    
      void * userData = NULL,   
      unsigned int options = 0,  
      OpalConnection::StringOptions * stringOptions  = NULL 
    );

    virtual OpalMediaFormatList GetMediaFormats() const;

    virtual OpalLineConnection * CreateConnection(
      OpalCall & call,        
      OpalLine & line,        
      void * userData,        
      const PString & number  
    );

    PSafePtr<OpalLineConnection> GetLIDConnectionWithLock(
      const PString & token,     
      PSafetyMode mode = PSafeReadWrite   
    ) { return PSafePtrCast<OpalConnection, OpalLineConnection>(GetConnectionWithLock(token, mode)); }

    PBoolean AddLine(
      OpalLine * line
    );

    void RemoveLine(
      OpalLine * line
    );

    
    const PList<OpalLine> & GetLines() const { return m_lines; }
    
    void RemoveLine(
      const PString & token
    );

    void RemoveAllLines();

    virtual PBoolean AddLinesFromDevice(
      OpalLineInterfaceDevice & device  
    );

    void RemoveLinesFromDevice(
      OpalLineInterfaceDevice & device  
    );

    PBoolean AddDeviceNames(
      const PStringArray & descriptors  
    );

    PBoolean AddDeviceName(
      const PString & descriptor  
    );

    const OpalLineInterfaceDevice * GetDeviceByName(
      const PString & descriptor  
    );

    virtual PBoolean AddDevice(
      OpalLineInterfaceDevice * device    
    );

    void RemoveDevice(
      OpalLineInterfaceDevice * device  
    );

    void RemoveDevices() { RemoveAllLines(); }

    OpalLine * GetLine(
      const PString & lineName,  
      bool enableAudio = false,  
      bool terminating = true    
    );

    void SetDefaultLine(
      const PString & lineName  
    );

    bool SetCountryCode(
      OpalLineInterfaceDevice::T35CountryCodes country   
    );

    bool SetCountryCodeName(
      const PString & countryName   
    );


  protected:
    PDECLARE_NOTIFIER(PThread, OpalLineEndPoint, MonitorLines);
    virtual void MonitorLine(OpalLine & line);

    OpalLIDList  m_devices;
    OpalLineList m_lines;
    PString      m_defaultLine;
    PDECLARE_MUTEX(m_linesMutex);
    PThread    * m_monitorThread;
    PSyncPoint   m_exitFlag;
};


class OpalLineConnection : public OpalConnection
{
  PCLASSINFO(OpalLineConnection, OpalConnection);

  public:
    OpalLineConnection(
      OpalCall & call,              
      OpalLineEndPoint & endpoint,   
      OpalLine & line,              
      const PString & number        
    );

    virtual PString GetPrefixName() const;

    virtual bool IsNetworkConnection() const { return !m_line.IsTerminal(); }

    virtual PBoolean SetUpConnection();

    virtual PBoolean SetAlerting(
      const PString & calleeName,   
      PBoolean withMedia                
    );

    virtual PBoolean SetConnected();

    virtual void OnReleased();

    virtual PString GetDestinationAddress();

    virtual OpalMediaFormatList GetMediaFormats() const;

    virtual OpalMediaStream * CreateMediaStream(
      const OpalMediaFormat & mediaFormat, 
      unsigned sessionID,                  
      PBoolean isSource                        
    );

    virtual PBoolean OnOpenMediaStream(
      OpalMediaStream & stream    
    );

    virtual void OnClosedMediaStream(
      const OpalMediaStream & stream     
    );

    virtual PBoolean SetAudioVolume(
      PBoolean source,                  
      unsigned percentage           
    );

    virtual unsigned GetAudioSignalLevel(
      PBoolean source                   
    );

    virtual PBoolean SendUserInputString(
      const PString & value                   
    );

    virtual PBoolean SendUserInputTone(
      char tone,    
      int duration  
    );

    virtual PBoolean PromptUserInput(
      PBoolean play   
    );

    void StartIncoming();

    virtual void Monitor();


    OpalLine & GetLine() { return m_line; }

    OpalLineInterfaceDevice::CallProgressTones GetPromptTone() const { return m_promptTone; }

    void SetPromptTone(OpalLineInterfaceDevice::CallProgressTones tone) { m_promptTone = tone; }

    void setDialDelay(
      unsigned int uiDialDelay  
    ) { m_dialParams.m_dialStartDelay = uiDialDelay;}

    unsigned int getDialDelay() const { return m_dialParams.m_dialStartDelay; }
        
  protected:
    OpalLineEndPoint & m_endpoint;
    OpalLine         & m_line;
    bool               m_wasOffHook;
    unsigned           m_minimumRingCount;
    PString            m_dialedNumber;
    OpalLineInterfaceDevice::DialParams m_dialParams;
    OpalLineInterfaceDevice::CallProgressTones m_promptTone;

    PDECLARE_NOTIFIER(PThread, OpalLineConnection, HandleIncoming);
    PThread * m_handlerThread;
};


class OpalLineMediaStream : public OpalMediaStream
{
    PCLASSINFO(OpalLineMediaStream, OpalMediaStream);
  public:
    OpalLineMediaStream(
      OpalLineConnection & conn,            
      const OpalMediaFormat & mediaFormat, 
      unsigned sessionID,                  
      PBoolean isSource,                       
      OpalLine & line                      
    );

    ~OpalLineMediaStream();


    virtual PBoolean Open();

    virtual PBoolean ReadPacket(
      RTP_DataFrame & packet
    );

    virtual PBoolean WritePacket(
      RTP_DataFrame & packet
    );

    virtual PBoolean ReadData(
      BYTE * data,      
      PINDEX size,      
      PINDEX & length   
    );

    virtual PBoolean WriteData(
      const BYTE * data,   
      PINDEX length,       
      PINDEX & written     
    );

    virtual PBoolean SetDataSize(
      PINDEX dataSize,  
      PINDEX frameTime  
    );

    virtual PBoolean IsSynchronous() const;

    virtual PBoolean RequiresPatchThread(
      OpalMediaStream * stream  
    ) const;

    OpalLine & GetLine() { return m_line; }

  protected:
    virtual void InternalClose();

    OpalLine & m_line;
    bool       m_notUsingRTP;
    bool       m_useDeblocking;
    unsigned   m_missedCount;
    BYTE       m_lastSID[4];
    bool       m_lastFrameWasSignal;
    unsigned   m_directLineNumber;
};


class OpalLineSilenceDetector : public OpalSilenceDetector
{
    PCLASSINFO(OpalLineSilenceDetector, OpalSilenceDetector);
  public:
    OpalLineSilenceDetector(
      OpalLine & line,        
      const Params & newParam 
    );

    virtual unsigned GetAverageSignalLevel(
      const BYTE * buffer,  
      PINDEX size           
    );

  protected:
    OpalLine & m_line;
};


#endif // OPAL_LID

#endif // OPAL_LIDS_LIDEP_H


// End of File ///////////////////////////////////////////////////////////////