mediastrm.h

Go to the documentation of this file.

/*
 * mediastrm.h
 *
 * Media Stream classes
 *
 * Open Phone Abstraction Library (OPAL)
 * Formally known as the Open H323 project.
 *
 * 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 Phone Abstraction Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 24362 $
 * $Author: rjongbloed $
 * $Date: 2010-05-20 03:24:51 -0500 (Thu, 20 May 2010) $
 */

#ifndef OPAL_OPAL_MEDIASTRM_H
#define OPAL_OPAL_MEDIASTRM_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal/buildopts.h>

#include <ptclib/delaychan.h>

#include <opal/mediafmt.h>
#include <opal/mediacmd.h>
#include <ptlib/safecoll.h>
#include <ptclib/guid.h>


class RTP_Session;
class OpalMediaPatch;
class OpalLine;
class OpalConnection;
class OpalRTPConnection;
class OpalMediaStatistics;


class OpalMediaStream : public PSafeObject
{
    PCLASSINFO(OpalMediaStream, PSafeObject);
  protected:
    OpalMediaStream(
      OpalConnection & conn,
      const OpalMediaFormat & mediaFormat, 
      unsigned sessionID,                  
      bool isSource                        
    );

  public:
    ~OpalMediaStream();

  public:
    void PrintOn(
      ostream & strm    
    ) const;

    virtual OpalMediaFormat GetMediaFormat() const;

    virtual bool UpdateMediaFormat(
      const OpalMediaFormat & mediaFormat,  
      bool fromPatch = false                
    );

    virtual PBoolean ExecuteCommand(
      const OpalMediaCommand & command    
    );

    virtual void SetCommandNotifier(
      const PNotifier & notifier    
    );

    virtual PBoolean Open();

    virtual PBoolean Start();

    virtual PBoolean Close();

    virtual void OnStartMediaPatch();

    virtual void OnStopMediaPatch(
      OpalMediaPatch & patch    
    );

    virtual PBoolean WritePackets(
      RTP_DataFrameList & packets
    );

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

    bool PushPacket(
      RTP_DataFrame & packet
    );

    virtual PBoolean SetDataSize(
      PINDEX dataSize,  
      PINDEX frameTime  
    );

    PINDEX GetDataSize() const { return defaultDataSize; }

    virtual PBoolean IsSynchronous() const = 0;

    virtual PBoolean RequiresPatchThread(
      OpalMediaStream * stream  
    ) const;
    virtual PBoolean RequiresPatchThread() const; // For backward compatibility

    virtual void EnableJitterBuffer() const;

    OpalConnection & GetConnection() const { return connection; }

    bool IsSource() const { return isSource; }

    bool IsSink() const { return !isSource; }

    unsigned GetSessionID() const { return sessionID; }

    void SetSessionID(unsigned id) { sessionID = id; }

    PString GetID() const { return identifier; }

    unsigned GetTimestamp() const { return timestamp; }

    void SetTimestamp(unsigned ts) { timestamp = ts; }

    bool GetMarker() const { return marker; }

    void SetMarker(bool m) { marker = m; }

    bool IsPaused() const { return paused; }

    virtual void SetPaused(
      bool pause    
    );

    bool IsOpen() const { return isOpen; }
    
    virtual PBoolean SetPatch(
      OpalMediaPatch * patch  
    );

    virtual void RemovePatch(OpalMediaPatch * patch);

    OpalMediaPatch * GetPatch() const { return mediaPatch; }

    void AddFilter(const PNotifier & Filter, const OpalMediaFormat & Stage =  OpalMediaFormat());

    bool RemoveFilter(const PNotifier & Filter, const OpalMediaFormat & Stage);

#if OPAL_STATISTICS
    virtual void GetStatistics(OpalMediaStatistics & statistics, bool fromPatch = false) const;
#endif


  protected:
    void IncrementTimestamp(PINDEX size);

    OpalConnection & connection;
    unsigned         sessionID;
    PString          identifier;
    OpalMediaFormat  mediaFormat;
    bool             paused;
    bool             isSource;
    bool             isOpen;
    PINDEX           defaultDataSize;
    unsigned         timestamp;
    bool             marker;
    unsigned         mismatchedPayloadTypes;

    OpalMediaPatch * mediaPatch;
    PNotifier        commandNotifier;

    RTP_DataFrame::PayloadTypes m_payloadType;
    unsigned                    m_frameTime;
    PINDEX                      m_frameSize;

  private:
    P_REMOVE_VIRTUAL_VOID(OnPatchStart());
    P_REMOVE_VIRTUAL_VOID(OnPatchStop());
    P_REMOVE_VIRTUAL_VOID(OnStopMediaPatch());
};

typedef PSafePtr<OpalMediaStream> OpalMediaStreamPtr;


class OpalMediaStreamPacing
{
  public:
    OpalMediaStreamPacing(
      const OpalMediaFormat & mediaFormat 
    );

    void Pace(
      bool reading,     
      PINDEX bytes,     
      bool & marker     
    );

  protected:
    bool           m_isAudio;
    unsigned       m_frameTime;
    PINDEX         m_frameSize;
    unsigned       m_timeUnits;
    PAdaptiveDelay m_delay;
};


class OpalNullMediaStream : public OpalMediaStream, public OpalMediaStreamPacing
{
    PCLASSINFO(OpalNullMediaStream, OpalMediaStream);
  public:
    OpalNullMediaStream(
      OpalConnection & conn,
      const OpalMediaFormat & mediaFormat, 
      unsigned sessionID,                  
      bool isSource,                       
      bool isSynchronous = false           
    );
    OpalNullMediaStream(
      OpalConnection & conn,
      const OpalMediaFormat & mediaFormat, 
      unsigned sessionID,                  
      bool isSource,                       
      bool usePacingDelay,                 
      bool requiresPatchThread             
    );

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

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

    virtual PBoolean IsSynchronous() const;

  protected:
    bool m_isSynchronous;
    bool m_requiresPatchThread;
};


class OpalRTPMediaStream : public OpalMediaStream
{
    PCLASSINFO(OpalRTPMediaStream, OpalMediaStream);
  public:
    OpalRTPMediaStream(
      OpalRTPConnection & conn,
      const OpalMediaFormat & mediaFormat, 
      bool isSource,                       
      RTP_Session & rtpSession,            
      unsigned minAudioJitterDelay,        
      unsigned maxAudioJitterDelay         
    );

    ~OpalRTPMediaStream();

    virtual PBoolean Open();

    virtual PBoolean Close();

    virtual void SetPaused(
      bool pause    
    );

    virtual PBoolean ReadPacket(
      RTP_DataFrame & packet
    );

    virtual PBoolean WritePacket(
      RTP_DataFrame & packet
    );

    virtual PBoolean SetDataSize(
      PINDEX dataSize,  
      PINDEX frameTime  
    );

    virtual PBoolean IsSynchronous() const;

    virtual PBoolean RequiresPatchThread() const;

    virtual void EnableJitterBuffer() const;

    virtual PBoolean SetPatch(
      OpalMediaPatch * patch  
    );

    virtual RTP_Session & GetRtpSession() const
    { return rtpSession; }

#if OPAL_STATISTICS
    virtual void GetStatistics(OpalMediaStatistics & statistics, bool fromPatch = false) const;
#endif


  protected:
    RTP_Session & rtpSession;
    unsigned      minAudioJitterDelay;
    unsigned      maxAudioJitterDelay;
};



class OpalRawMediaStream : public OpalMediaStream
{
    PCLASSINFO(OpalRawMediaStream, OpalMediaStream);
  protected:
    OpalRawMediaStream(
      OpalConnection & conn,
      const OpalMediaFormat & mediaFormat, 
      unsigned sessionID,                  
      bool isSource,                       
      PChannel * channel,                  
      bool autoDelete                      
    );

    ~OpalRawMediaStream();

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

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

    PChannel * GetChannel() { return m_channel; }

    bool SetChannel(
      PChannel * channel,     
      bool autoDelete = true  
    );

    virtual PBoolean Close();

    virtual unsigned GetAverageSignalLevel();

  protected:
    PChannel * m_channel;
    bool       m_autoDelete;
    PMutex     m_channelMutex;

    PBYTEArray m_silence;

    PUInt64    m_averageSignalSum;
    unsigned   m_averageSignalSamples;
    PMutex     m_averagingMutex;

    void CollectAverage(const BYTE * buffer, PINDEX size);
};



class OpalFileMediaStream : public OpalRawMediaStream, public OpalMediaStreamPacing
{
    PCLASSINFO(OpalFileMediaStream, OpalRawMediaStream);
  public:
    OpalFileMediaStream(
      OpalConnection &,
      const OpalMediaFormat & mediaFormat, 
      unsigned sessionID,                  
      bool isSource,                       
      PFile * file,                        
      bool autoDelete = true               
    );

    OpalFileMediaStream(
      OpalConnection & ,
      const OpalMediaFormat & mediaFormat, 
      unsigned sessionID,                  
      bool isSource,                       
      const PFilePath & path               
    );

    virtual PBoolean IsSynchronous() const;

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

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

  protected:
    PFile file;
};


#if OPAL_PTLIB_AUDIO

class PSoundChannel;

class OpalAudioMediaStream : public OpalRawMediaStream
{
    PCLASSINFO(OpalAudioMediaStream, OpalRawMediaStream);
  public:
    OpalAudioMediaStream(
      OpalConnection & conn,
      const OpalMediaFormat & mediaFormat, 
      unsigned sessionID,                  
      bool isSource,                       
      PINDEX buffers,                      
      unsigned bufferTime,                 
      PSoundChannel * channel,             
      bool autoDelete = true               
    );

    OpalAudioMediaStream(
      OpalConnection & conn,
      const OpalMediaFormat & mediaFormat, 
      unsigned sessionID,                  
      bool isSource,                       
      PINDEX buffers,                      
      unsigned bufferTime,                 
      const PString & deviceName           
    );

    virtual PBoolean SetDataSize(
      PINDEX dataSize,  
      PINDEX frameTime  
    );

    virtual PBoolean IsSynchronous() const;

  protected:
    PINDEX   m_soundChannelBuffers;
    unsigned m_soundChannelBufferTime;
};

#endif // OPAL_PTLIB_AUDIO

#if OPAL_VIDEO

class PVideoInputDevice;
class PVideoOutputDevice;

class OpalVideoMediaStream : public OpalMediaStream
{
    PCLASSINFO(OpalVideoMediaStream, OpalMediaStream);
  public:
    OpalVideoMediaStream(
      OpalConnection & conn,
      const OpalMediaFormat & mediaFormat, 
      unsigned sessionID,                  
      PVideoInputDevice * inputDevice,     
      PVideoOutputDevice * outputDevice,   
      bool autoDelete = true               
    );

    ~OpalVideoMediaStream();

    virtual PBoolean Open();

    virtual PBoolean Close();

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

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

    virtual PBoolean IsSynchronous() const;

    virtual PBoolean SetDataSize(
      PINDEX dataSize,  
      PINDEX frameTime  
    );

    virtual PVideoInputDevice * GetVideoInputDevice() const {
      return inputDevice;
    }

    virtual PVideoOutputDevice * GetVideoOutputDevice() const {
      return outputDevice;
    }


  protected:
    PVideoInputDevice  * inputDevice;
    PVideoOutputDevice * outputDevice;
    bool                 autoDelete;
    PTimeInterval        lastGrabTime;
};

#endif // OPAL_VIDEO

class OpalTransportUDP;

class OpalUDPMediaStream : public OpalMediaStream
{
    PCLASSINFO(OpalUDPMediaStream, OpalMediaStream);
  public:
    OpalUDPMediaStream(
      OpalConnection & conn,
      const OpalMediaFormat & mediaFormat, 
      unsigned sessionID,                  
      bool isSource,                       
      OpalTransportUDP & transport         
    );

    ~OpalUDPMediaStream();


    virtual PBoolean ReadPacket(
      RTP_DataFrame & packet
    );

    virtual PBoolean WritePacket(
      RTP_DataFrame & packet
    );

    virtual PBoolean IsSynchronous() const;

    virtual PBoolean Close();


  private:
    OpalTransportUDP & udpTransport;
};


#endif //OPAL_OPAL_MEDIASTRM_H


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

---