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): ______________________________________.
 *
 * $Revision: 20626 $
 * $Author: rjongbloed $
 * $Date: 2008-07-26 06:27:01 +0000 (Sat, 26 Jul 2008) $
 */

#ifndef __LIDS_LIDEP_H
#define __LIDS_LIDEP_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif


#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 PBoolean 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 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  
    );


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

    OpalLIDList  devices;
    OpalLineList lines;
    PString      defaultLine;
    PMutex       linesMutex;
    PThread    * monitorThread;
    PSyncPoint   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 !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 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();


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

        
  protected:
    OpalLineEndPoint & endpoint;
    OpalLine        & line;
    bool              wasOffHook;
    unsigned          minimumRingCount;
    OpalLineInterfaceDevice::DialParams m_dialParams;

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


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

    virtual PBoolean Open();

    virtual PBoolean Close();

    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  
    );

    virtual PBoolean IsSynchronous() const;

    virtual PBoolean RequiresPatchThread(
      OpalMediaStream * sinkStream  
    ) const;

    OpalLine & GetLine() { return line; }

  protected:
    OpalLine & line;
    bool       notUsingRTP;
    bool       useDeblocking;
    unsigned   missedCount;
    BYTE       lastSID[4];
    bool       lastFrameWasSignal;
    unsigned   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 & line;
};


#endif // __LIDS_LIDEP_H


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

---