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): ______________________________________.
 */

#ifndef OPAL_OPAL_MEDIASTRM_H
#define OPAL_OPAL_MEDIASTRM_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal_config.h>

#include <ptclib/delaychan.h>

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


class OpalMediaPatch;
class OpalLine;
class OpalConnection;
class OpalMediaStatistics;


typedef PSafePtr<OpalMediaPatch, PSafePtrMultiThreaded> OpalMediaPatchPtr;


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 SetMediaFormat(
      const OpalMediaFormat & mediaFormat   
    );

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

    bool ExecuteCommand(
      const OpalMediaCommand & command    
    ) const;

    virtual PBoolean Open();

    virtual bool IsOpen() const;

    virtual bool IsEstablished() const;

    virtual PBoolean Start();

    virtual PBoolean Close();

    virtual void OnStartMediaPatch();

    virtual void OnStopMediaPatch(
      OpalMediaPatch & patch    
    );

    virtual bool SetMediaPassThrough(
      OpalMediaStream & otherStream,  
      bool bypass                     
    );

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

    virtual bool PushPacket(
      RTP_DataFrame & packet
    );

    virtual PBoolean SetDataSize(
      PINDEX dataSize,  
      PINDEX frameTime  
    );

    PINDEX GetDataSize() const { return m_defaultDataSize; }

    virtual PBoolean IsSynchronous() const = 0;

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

    virtual bool RequireMediaTransportThread(
      OpalMediaStream & stream  
    ) const;

    virtual bool EnableJitterBuffer(bool enab = true);

    OpalConnection & GetConnection() const { return m_connection; }

    bool IsSource() const { return m_isSource; }

    bool IsSink() const { return !m_isSource; }

    unsigned GetSessionID() const { return m_sessionID; }

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

    PString GetID() const { return m_identifier; }

    unsigned GetTimestamp() const { return m_timestamp; }

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

    bool GetMarker() const { return m_marker; }

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

    bool IsPaused() const { return m_paused; }

    bool SetPaused(
      bool pause  
    ) { return InternalSetPaused(pause, true, false); }
    
    virtual PBoolean SetPatch(
      OpalMediaPatch * patch  
    );

    OpalMediaPatchPtr GetPatch() const { return m_mediaPatch; }

    void AddFilter(
      const PNotifier & filter,   
      const OpalMediaFormat & stage = OpalMediaFormat() 
    ) const;

    bool RemoveFilter(
      const PNotifier & filter,   
      const OpalMediaFormat & stage = OpalMediaFormat() 
    ) const;

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

    P_DECLARE_BITWISE_ENUM(Details, 6,(
      DetailMinimum,
      DetailEOL, // end of line
      DetailNAT,
      DetailSecured,
      DetailFEC,
      DetailAudio,
      DetailAddresses
    ));
    virtual void PrintDetail(
      ostream & strm,
      const char * prefix = NULL,
      Details details = Details::All()
    ) const;

    virtual PString GetPatchThreadName() const;
    virtual bool InternalUpdateMediaFormat(const OpalMediaFormat & mediaFormat);
    virtual bool InternalSetPaused(bool pause, bool fromUser, bool fromPatch);
    virtual bool InternalExecuteCommand(const OpalMediaCommand & command);

  protected:
    OpalMediaPatchPtr InternalSetPatchPart1(OpalMediaPatch * newPatch);
    void InternalSetPatchPart2(const OpalMediaPatchPtr & oldPatch);
    virtual bool InternalSetJitterBuffer(const OpalJitterBuffer::Init & init);

    virtual void InternalClose() = 0;

    OpalConnection & m_connection;
    unsigned         m_sessionID;
    WORD             m_sequenceNumber;
    RTP_SyncSourceId m_syncSourceId;
    PString          m_identifier;
    OpalMediaFormat  m_mediaFormat;
    atomic<bool>     m_paused;
    bool             m_isSource;
    atomic<bool>     m_isOpen;
    PINDEX           m_defaultDataSize;
    unsigned         m_timestamp;
    bool             m_marker;

    OpalMediaPatchPtr m_mediaPatch;

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

    typedef OpalMediaPatchPtr PatchPtr; // For backward compatibility

  private:
    P_REMOVE_VIRTUAL_VOID(OnPatchStart());
    P_REMOVE_VIRTUAL_VOID(OnPatchStop());
    P_REMOVE_VIRTUAL_VOID(OnStopMediaPatch());
    P_REMOVE_VIRTUAL_VOID(RemovePatch(OpalMediaPatch *));

  friend class OpalMediaPatch;
};

typedef PSafePtr<OpalMediaStream> OpalMediaStreamPtr;


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

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

    bool UpdateMediaFormat(
      const OpalMediaFormat & mediaFormat   
    );

  protected:
    bool           m_timeOnMarkers;
    unsigned       m_frameTime;
    PINDEX         m_frameSize;
    unsigned       m_timeUnits;
    PAdaptiveDelay m_delay;
    unsigned       m_previousDelay;

    PTRACE_THROTTLE(m_throttleLog, 4, 5000);
};


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:
    virtual void InternalClose() { }
    virtual bool InternalUpdateMediaFormat(const OpalMediaFormat & newMediaFormat);
    virtual bool InternalSetPaused(bool pause, bool fromUser, bool fromPatch);

    bool m_isSynchronous;
    bool m_requiresPatchThread;
};


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 unsigned GetAverageSignalLevel();

  protected:
    virtual void InternalClose();

    PChannel * m_channel;
    bool       m_autoDelete;
    PDECLARE_MUTEX(m_channelMutex);

    PBYTEArray m_silence;

    PUInt64    m_averageSignalSum;
    unsigned   m_averageSignalSamples;
    PDECLARE_MUTEX(m_averagingMutex);

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



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

    OpalFileMediaStream(
      OpalConnection & conn,               
      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 autoDeleteInput = true,         
      bool autoDeleteOutput = true         
    );

    ~OpalVideoMediaStream();

    virtual PBoolean Open();

    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 void SetVideoInputDevice(
      PVideoInputDevice * device,
      bool autoDelete = true
    );

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

    virtual void SetVideoOutputDevice(
      PVideoOutputDevice * device,
      bool autoDelete = true
    );

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

    virtual void SetVideoWatermarkDevice(
      PVideoInputDevice * device,
      bool autoDelete = true
    );

    virtual PVideoInputDevice * GetVideoWatermarkDevice() const
    {
      return m_watermarkDevice;
    }

  protected:
    virtual void InternalClose();
    virtual bool InternalUpdateMediaFormat(const OpalMediaFormat & newMediaFormat);
    virtual bool InternalExecuteCommand(const OpalMediaCommand & command);
    bool InternalAdjustDevices();
    virtual void ApplyWatermark(unsigned width, unsigned height, BYTE * frame);

    PVideoInputDevice  * m_inputDevice;
    PVideoInputDevice  * m_watermarkDevice;
    PVideoOutputDevice * m_outputDevice;
    bool                 m_autoDeleteInput;
    bool                 m_autoDeleteWatermark;
    bool                 m_autoDeleteOutput;
    PTimeInterval        m_lastGrabTime;
    bool                 m_needKeyFrame;
    PDECLARE_MUTEX(m_devicesMutex);
    PBYTEArray           m_watermarkData;
};

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

  private:
    virtual void InternalClose();

    OpalTransportUDP & udpTransport;
};


#endif //OPAL_OPAL_MEDIASTRM_H


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