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: 20799 $
 * $Author: rjongbloed $
 * $Date: 2008-09-01 01:17:10 +0000 (Mon, 01 Sep 2008) $
 */

#ifndef __OPAL_PATCH_H
#define __OPAL_PATCH_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal/buildopts.h>

#include <opal/mediastrm.h>
#include <opal/mediacmd.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 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()
    );

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

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

    virtual PBoolean UpdateMediaFormat(
      const OpalMediaFormat & mediaFormat,  
      PBoolean fromSink                         
    );

    virtual PBoolean ExecuteCommand(
      const OpalMediaCommand & command,   
      PBoolean fromSink                       
    );

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

    virtual PBoolean PushFrame(RTP_DataFrame & /*frame*/) { return PFalse; };

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

#ifdef OPAL_STATISTICS
    virtual void GetStatistics(OpalMediaStatistics & statistics) const;
#endif


  protected:
                
    virtual void Main();
    bool DispatchFrame(RTP_DataFrame & frame);
        
    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);
#ifdef OPAL_STATISTICS
        void GetStatistics(OpalMediaStatistics & statistics) const;
#endif

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

#if OPAL_VIDEO
        void SetRateControlParameters(const OpalMediaFormat & mediaFormat);
        bool RateControlExceeded(const PTimeInterval & currentTime);

        bool          rcEnabled;
        unsigned      rcByteRate;
        unsigned      rcWindowSize;
        unsigned      rcMaxConsecutiveFramesSkip;
        unsigned      rcConsecutiveFramesSkipped;
        PTimeInterval rcLastTime;
        PINDEX        rcTotalSize;
        
        struct FrameInfo {
          PTimeInterval time;
          PINDEX        size;
        };
        std::list<FrameInfo> frameInfoList;
#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;
        
    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;
};

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

    OpalPassiveMediaPatch(
      OpalMediaStream & source       
    );

    virtual void Start();
    virtual PBoolean PushFrame(RTP_DataFrame & frame);
};


#endif // __OPAL_PATCH_H


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

---