jitter.h

Go to the documentation of this file.

/*
 * jitter.h
 *
 * Jitter buffer support
 *
 * Open H323 Library
 *
 * Copyright (c) 1999-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 H323 Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Portions of this code were written with the assisance of funding from
 * Vovida Networks, Inc. http://www.vovida.com.
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 23097 $
 * $Author: rjongbloed $
 * $Date: 2009-07-12 16:57:28 +0000 (Sun, 12 Jul 2009) $
 */

#ifndef OPAL_RTP_JITTER_H
#define OPAL_RTP_JITTER_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal/buildopts.h>

#include <rtp/rtp.h>


class RTP_JitterBuffer;
class RTP_JitterBufferAnalyser;



class OpalJitterBuffer : public PSafeObject
{
  PCLASSINFO(OpalJitterBuffer, PSafeObject);

  public:
    OpalJitterBuffer(
      unsigned minJitterDelay, 
      unsigned maxJitterDelay, 
      unsigned timeUnits = 8,  
      PINDEX packetSize = 2048 
    );
    
    virtual ~OpalJitterBuffer();

    void PrintOn(
      ostream & strm
    ) const;

    void SetDelay(
      unsigned minJitterDelay, 
      unsigned maxJitterDelay, 
      PINDEX packetSize = 2048 
    );

    void Reset() { m_resetJitterBufferNow = true; }

    virtual PBoolean WriteData(
      const RTP_DataFrame & frame   
    );

    virtual PBoolean ReadData(
      RTP_DataFrame & frame   
    );

    DWORD GetJitterTime() const { return currentJitterTime; }

    unsigned GetTimeUnits() const { return timeUnits; }
    
    DWORD GetPacketsTooLate() const { return packetsTooLate; }

    DWORD GetBufferOverruns() const { return bufferOverruns; }

    DWORD GetMaxConsecutiveMarkerBits() const { return maxConsecutiveMarkerBits; }

    void SetMaxConsecutiveMarkerBits(DWORD max) { maxConsecutiveMarkerBits = max; }

  protected:
    class Entry : public RTP_DataFrame
    {
      public:
        Entry(PINDEX sz) : RTP_DataFrame(0, sz) { }
        PTimeInterval tick;
    };
    OpalJitterBuffer::Entry * GetAvailableEntry();
    void InternalWriteData(OpalJitterBuffer::Entry * availableEntry);

    DWORD         minJitterTime;
    DWORD         maxJitterTime;
    unsigned      timeUnits;
    PINDEX        bufferSize;
    DWORD         maxConsecutiveMarkerBits;

    DWORD         currentJitterTime;
    DWORD         packetsTooLate;
    unsigned      bufferOverruns;
    unsigned      consecutiveBufferOverruns;
    DWORD         consecutiveMarkerBits;
    bool          markerWarning;
    PTimeInterval consecutiveEarlyPacketStartTime;
    DWORD         lastWriteTimestamp;
    PTimeInterval lastWriteTick;
    DWORD         jitterCalc;
    DWORD         targetJitterTime;
    unsigned      jitterCalcPacketCount;
    bool          m_resetJitterBufferNow;

    class FrameQueue : public std::deque<Entry *>
    {
      public:
        void resize(size_type _Newsize, PINDEX packetSize)
        { 
          while (size() < (size_t)_Newsize)
            push_back(new Entry(packetSize));
          while (size() > (size_t)_Newsize) {
            delete front();
            pop_front();
          }
        }

        ~FrameQueue()
        { resize(0, 0); }
    };

    FrameQueue freeFrames;
    FrameQueue jitterBuffer;
    inline Entry * GetNewest(bool pop) { Entry * e = jitterBuffer.back(); if (pop) jitterBuffer.pop_back(); return e; }
    inline Entry * GetOldest(bool pop) { Entry * e = jitterBuffer.front(); if (pop) jitterBuffer.pop_front(); return e; }

    Entry * currentFrame;    // storage of current frame

    PMutex bufferMutex;
    bool   shuttingDown;
    bool   preBuffering;
    bool   firstReadData;

    RTP_JitterBufferAnalyser * analyser;
};


class OpalJitterBufferThread : public OpalJitterBuffer
{
    PCLASSINFO(OpalJitterBufferThread, OpalJitterBuffer);
 public:
    OpalJitterBufferThread(
      unsigned minJitterDelay, 
      unsigned maxJitterDelay, 
      unsigned timeUnits = 8,  
      PINDEX packetSize = 2048 
    );
    ~OpalJitterBufferThread();

    virtual void Resume();

    virtual PBoolean OnReadPacket(RTP_DataFrame & frame, PBoolean loop) = 0;

  protected:
    PDECLARE_NOTIFIER(PThread, OpalJitterBufferThread, JitterThreadMain);

    PThread * jitterThread;
};



class RTP_JitterBuffer : public OpalJitterBufferThread
{
    PCLASSINFO(RTP_JitterBuffer, OpalJitterBufferThread);
 public:
    RTP_JitterBuffer(
      RTP_Session & session,   
      unsigned minJitterDelay, 
      unsigned maxJitterDelay, 
      unsigned timeUnits = 8,  
      PINDEX packetSize = 2048 
    );

    virtual PBoolean OnReadPacket(
      RTP_DataFrame & frame,  
      PBoolean loop           
    );

 protected:
   RTP_Session & session;
};

#endif // OPAL_RTP_JITTER_H

---