patch.h

Go to the documentation of this file.

/*
 * patch.h
 *
 * Media stream patch thread.
 *
 * 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_PATCH_H
#define OPAL_OPAL_PATCH_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal_config.h>

#include <opal/mediastrm.h>
#include <opal/mediasession.h>
#include <opal/mediacmd.h>

#include <list>

class OpalTranscoder;

class OpalMediaPatch : public PSafeObject
{
    PCLASSINFO(OpalMediaPatch, PObject);
  private:
    PDECLARE_INSTRUMENTED_READ_WRITE_MUTEX(m_instrumentedMutex, OpalMediaPatch, 500, 100);
  public:
    OpalMediaPatch(
      OpalMediaStream & source       
    );

    ~OpalMediaPatch();

    void PrintOn(
      ostream & strm    
    ) const;

    virtual void Start();

    virtual bool OnStartMediaPatch();

    virtual void Close();

    PBoolean AddSink(
      const OpalMediaStreamPtr & stream            
    );

    void RemoveSink(
      const OpalMediaStream & stream  
    );

    OpalMediaStream & GetSource() const { return m_source; }

    OpalMediaStreamPtr GetSink(PINDEX i = 0) const;

    OpalMediaFormat GetSinkFormat(PINDEX i = 0) const;

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

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

    virtual void FilterFrame(
      RTP_DataFrame & frame,
      const OpalMediaFormat & mediaFormat
    );

    virtual bool UpdateMediaFormat(
      const OpalMediaFormat & mediaFormat  
    );

    virtual bool ExecuteCommand(
      const OpalMediaCommand & command   
    );

    virtual bool InternalSetPaused(
      bool pause,    
      bool fromUser  
    );

    virtual PBoolean PushFrame(
      RTP_DataFrame & frame   
    );

    bool SetBypassPatch(
      const OpalMediaPatchPtr & patch
    );

    bool IsBypassed() const { return m_bypassToPatch != NULL || m_bypassFromPatch != NULL; }

    virtual OpalTranscoder * GetAndLockSinkTranscoder(PINDEX i = 0) const;
    virtual void UnLockSinkTranscoder() const;

    virtual bool ResetTranscoders();
    bool EnableJitterBuffer(bool enab = true);

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


  protected:
    PDECLARE_NOTIFIER(OpalMediaCommand, OpalMediaPatch, InternalOnMediaCommand1);
    void InternalOnMediaCommand2(OpalMediaCommand * command);

    bool CanStart() const;

    virtual void Main();
    void StopThread();
    bool DispatchFrame(RTP_DataFrame & frame);
    bool DispatchFrameLocked(RTP_DataFrame & frame, bool bypassing);

    OpalMediaStream & m_source;

    class Sink : public PObject {
        PCLASSINFO(Sink, PObject);
      public:
        Sink(OpalMediaPatch & p, const OpalMediaStreamPtr & s);
        ~Sink();
        bool CreateTranscoders();
        bool UpdateMediaFormat(const OpalMediaFormat & mediaFormat);
        bool ExecuteCommand(const OpalMediaCommand & command, bool atLeastOne);
        bool WriteFrame(RTP_DataFrame & sourceFrame, bool bypassing);
#if OPAL_STATISTICS
        void GetStatistics(OpalMediaStatistics & statistics, bool fromSource) const;
#endif

        OpalMediaPatch  &  m_patch;
        OpalMediaStreamPtr m_stream;
        OpalTranscoder   * m_primaryCodec;
        OpalTranscoder   * m_secondaryCodec;
        RTP_DataFrameList  m_intermediateFrames;
        RTP_DataFrameList  m_finalFrames;

#if OPAL_STATISTICS
        OpalAudioFormat m_audioFormat;
        OpalAudioFormat::FrameDetectorPtr m_audioFrameDetector;
        struct AudioStats {
          unsigned m_silent;
          unsigned m_FEC;
          AudioStats() : m_silent(0), m_FEC(0) { }
        };
        typedef map<RTP_SyncSourceId, AudioStats> AudioStatsMap;
        AudioStatsMap m_audioStatistics;
#if OPAL_VIDEO
        OpalVideoFormat m_videoFormat;
        OpalVideoFormat::FrameDetectorPtr m_videoFrameDetector;
        typedef map<RTP_SyncSourceId, OpalVideoStatistics> VideoStatsMap;
        VideoStatsMap m_videoStatistics;
#endif // OPAL_VIDEO
        PDECLARE_MUTEX(m_statsMutex);
#endif // OPAL_STATISTICS
    };
    PList<Sink> m_sinks;

    class Filter : public PObject {
        PCLASSINFO(Filter, PObject);
      public:
        Filter(const PNotifier & n, const OpalMediaFormat & s) : m_notifier(n), m_stage(s) { }

        PNotifier       m_notifier;
        OpalMediaFormat m_stage;
    };
    PList<Filter> m_filters;

    OpalMediaPatchPtr m_bypassToPatch;
    OpalMediaPatchPtr m_bypassFromPatch;
    PSyncPoint        m_bypassEnded;

    PThread * m_patchThread;
    PDECLARE_MUTEX(m_patchThreadMutex);
#if OPAL_STATISTICS
    PThreadIdentifier m_patchThreadId;
#endif


    bool m_transcoderChanged;

  private:
    P_REMOVE_VIRTUAL(bool, OnPatchStart(), false);
};

class OpalPassiveMediaPatch : public OpalMediaPatch
{
    PCLASSINFO(OpalPassiveMediaPatch, OpalMediaPatch);
  public:

    OpalPassiveMediaPatch(
      OpalMediaStream & source       
    );

    virtual void Start();
    virtual void Close();

  protected:
    bool m_started;
};


#endif // OPAL_OPAL_PATCH_H


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