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: 31115 $
 * $Author: rjongbloed $
 * $Date: 2013-12-19 11:33:11 +1100 (Thu, 19 Dec 2013) $
 */

#ifndef OPAL_RTP_JITTER_H
#define OPAL_RTP_JITTER_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal_config.h>

#include <rtp/rtp.h>
#include <ptlib/safecoll.h>


class RTP_JitterBuffer;
class RTP_JitterBufferAnalyser;
class OpalRTPSession;



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

  public:
    struct Init {
      Init(unsigned minDelay = 0, unsigned maxDelay = 0)
        : m_minJitterDelay(minDelay)
        , m_maxJitterDelay(maxDelay != 0 ? maxDelay : minDelay)
        , m_timeUnits(8)
        , m_packetSize(2048)
      { }

      unsigned m_minJitterDelay; 
      unsigned m_maxJitterDelay; 
      unsigned m_timeUnits;      
      PINDEX m_packetSize;       
    };

    OpalJitterBuffer(
      const Init & init  
    );
    
    virtual ~OpalJitterBuffer();

    void PrintOn(
      ostream & strm
    ) const;


    virtual void Start() { }

    void SetDelay(
      const Init & init  
    );

    void Reset();

    virtual PBoolean WriteData(
      const RTP_DataFrame & frame,        
      PTimeInterval tick = PTimer::Tick() 
    );

    virtual PBoolean ReadData(
      RTP_DataFrame & frame,              
      PTimeInterval tick = PTimer::Tick() 
    );

    DWORD GetCurrentJitterDelay() const { return m_currentJitterDelay; }
    
    DWORD GetMinJitterDelay() const { return m_minJitterDelay; }
    
    DWORD GetMaxJitterDelay() const { return m_maxJitterDelay; }

    unsigned GetTimeUnits() const { return m_timeUnits; }
    
    DWORD GetPacketsTooLate() const { return m_packetsTooLate; }

    DWORD GetBufferOverruns() const { return m_bufferOverruns; }

    DWORD GetMaxConsecutiveMarkerBits() const { return m_maxConsecutiveMarkerBits; }

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

  protected:
    DWORD CalculateRequiredTimestamp(DWORD playOutTimestamp) const;
    bool AdjustCurrentJitterDelay(int delta);

    unsigned m_timeUnits;
    PINDEX   m_packetSize;
    DWORD    m_minJitterDelay;      
    DWORD    m_maxJitterDelay;      
    int      m_jitterGrowTime;      
    DWORD    m_jitterShrinkPeriod;  

    int      m_jitterShrinkTime;    
    DWORD    m_silenceShrinkPeriod; 
    int      m_silenceShrinkTime;   
    DWORD    m_jitterDriftPeriod;

    int      m_currentJitterDelay;
    DWORD    m_packetsTooLate;
    DWORD    m_bufferOverruns;
    DWORD    m_consecutiveMarkerBits;
    DWORD    m_maxConsecutiveMarkerBits;
    DWORD    m_consecutiveLatePackets;
    DWORD    m_consecutiveOverflows;
    DWORD    m_consecutiveEmpty;

    unsigned m_frameTimeCount;
    uint64_t m_frameTimeSum;
    DWORD    m_incomingFrameTime;
    DWORD    m_lastSequenceNum;
    DWORD    m_lastTimestamp;
    DWORD    m_lastSyncSource;
    DWORD    m_bufferFilledTime;
    DWORD    m_bufferLowTime;
    DWORD    m_bufferEmptiedTime;
    int      m_timestampDelta;

    enum {
      e_SynchronisationStart,
      e_SynchronisationFill,
      e_SynchronisationShrink,
      e_SynchronisationDone
    } m_synchronisationState;

    typedef std::map<DWORD, RTP_DataFrame> FrameMap;
    FrameMap m_frames;
    PMutex   m_bufferMutex;

#if PTRACING
    PTimeInterval m_lastInsertTick;
    PTimeInterval m_lastRemoveTick;
#endif

    RTP_JitterBufferAnalyser * m_analyser;
};


class OpalJitterBufferThread : public OpalJitterBuffer
{
    PCLASSINFO(OpalJitterBufferThread, OpalJitterBuffer);
 public:
    OpalJitterBufferThread(
      const Init & init  
    );
    ~OpalJitterBufferThread();

    virtual void Start();

    virtual PBoolean ReadData(
      RTP_DataFrame & frame,  
      const PTimeInterval & tick = 0 
    );

    virtual PBoolean OnReadPacket(
      RTP_DataFrame & frame   
    ) = 0;

  protected:
    PDECLARE_NOTIFIER(PThread, OpalJitterBufferThread, JitterThreadMain);

    void WaitForThreadTermination();

    PThread * m_jitterThread;
    bool      m_running;
};


#endif // OPAL_RTP_JITTER_H