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): ______________________________________.
 *
 * $Revision: 24856 $
 * $Author: rjongbloed $
 * $Date: 2010-11-01 22:12:28 -0500 (Mon, 01 Nov 2010) $
 */

#ifndef OPAL_OPAL_PATCH_H
#define OPAL_OPAL_PATCH_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal/buildopts.h>

#include <opal/mediastrm.h>
#include <opal/mediacmd.h>
#include <codec/ratectl.h>

#include <list>

class OpalTranscoder;

class OpalMediaPatch : public PObject
{
    PCLASSINFO(OpalMediaPatch, PObject);
  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 OpalMediaStreamPtr & stream  
    );

    OpalMediaStream & GetSource() const { return 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 PBoolean ExecuteCommand(
      const OpalMediaCommand & command,   
      PBoolean fromSink                       
    );

    virtual void SetCommandNotifier(
      const PNotifier & notifier,   
      PBoolean fromSink                 
    );

    virtual void SetPaused(
      bool pause
    );

    virtual PBoolean PushFrame(
      RTP_DataFrame & frame   
    );

    bool SetBypassPatch(
      OpalMediaPatch * patch
    );

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

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


  protected:
                
    virtual void Main();
    bool DispatchFrame(RTP_DataFrame & frame);
    bool EnableJitterBuffer();

    OpalMediaStream & source;

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

        OpalMediaPatch  &  patch;
        OpalMediaStreamPtr stream;
        OpalTranscoder   * primaryCodec;
        OpalTranscoder   * secondaryCodec;
        RTP_DataFrameList  intermediateFrames;
        RTP_DataFrameList  finalFrames;
        bool               writeSuccessful;

        RTP_DataFrame::PayloadTypes m_lastPayloadType;
        unsigned                    m_consecutivePayloadTypeMismatches;
        bool CannotTranscodeFrame(OpalTranscoder & codec, RTP_DataFrame & frame);

#if OPAL_VIDEO
        void SetRateControlParameters(const OpalMediaFormat & mediaFormat);
        bool RateControlExceeded(bool & forceIFrame);
        OpalVideoRateController * rateController;
#endif
    };
    PList<Sink> sinks;

    class Filter : public PObject {
        PCLASSINFO(Filter, PObject);
      public:
        Filter(const PNotifier & n, const OpalMediaFormat & s) : notifier(n), stage(s) { }
        PNotifier notifier;
        OpalMediaFormat stage;
    };
    PList<Filter> filters;

#if OPAL_VIDEO
    bool             m_videoDecoder;
#endif
    bool             m_bypassActive;
    OpalMediaPatch * m_bypassToPatch;
    OpalMediaPatch * m_bypassFromPatch;
    PSyncPoint       m_bypassEnded;

    class Thread : public PThread {
        PCLASSINFO(Thread, PThread);
      public:
        Thread(OpalMediaPatch & p);
        virtual void Main() { patch.Main(); };
        OpalMediaPatch & patch;
    };

    Thread * patchThread;
    PMutex patchThreadMutex;
    mutable PReadWriteMutex inUse;

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

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

    OpalPassiveMediaPatch(
      OpalMediaStream & source       
    );

    virtual void Start();
};


#endif // OPAL_OPAL_PATCH_H


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

---