members.cpp

Go to the documentation of this file.

// Copyright (C) 2001,2002 Federico Montesino <p5087@quintero.fie.us.es>
//  
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software 
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
// 
// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however    
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.    
//
// This exception applies only to the code released under the name GNU
// ccRTP.  If you copy code from other releases into a copy of GNU
// ccRTP, as the General Public License permits, the exception does
// not apply to the code that you add in this way.  To avoid misleading
// anyone as to the status of such modified files, you must delete
// this exception notice from them.
//
// If you write modifications of your own for GNU ccRTP, it is your choice
// whether to permit this exception to apply to your modifications.
// If you do not wish that, delete this exception notice.
//

#include "private.h"
#include <ccrtp/cqueue.h>

#ifdef  CCXX_NAMESPACES
namespace ost {
#endif

const uint32 MembershipBookkeeping::SyncSourceLink::SEQNUMMOD = (1<<16);

MembershipBookkeeping::SyncSourceLink::~SyncSourceLink()
{ 
#ifdef  CCXX_EXCEPTIONS
        try {
#endif
                delete source;
                delete prevConflict;
                delete receiverInfo;
                delete senderInfo;
#ifdef  CCXX_EXCEPTIONS
        } catch (...) { }
#endif
}
        
void
MembershipBookkeeping::SyncSourceLink::initStats()
{
        lastPacketTime.tv_sec = lastPacketTime.tv_usec = 0;
        lastRTCPPacketTime.tv_sec = lastRTCPPacketTime.tv_usec = 0;
        lastRTCPSRTime.tv_sec = lastRTCPSRTime.tv_usec = 0;

        senderInfo = NULL;
        receiverInfo = NULL;

        obsPacketCount = obsOctetCount = 0;
        maxSeqNum = extendedMaxSeqNum = 0;
        cumulativePacketLost = 0;
        fractionLost = 0;
        jitter = 0;
        initialDataTimestamp = 0;
        initialDataTime.tv_sec = initialDataTime.tv_usec = 0;
        flag = false;

        badSeqNum = SEQNUMMOD + 1;
        probation = 0;
        baseSeqNum = 0;
        expectedPrior = 0;
        receivedPrior = 0;
        seqNumAccum = 0;
}

void
MembershipBookkeeping::SyncSourceLink::computeStats()
{
        // See Appendix A.3
        
        // compute cumulative packet lost.
        setExtendedMaxSeqNum(getMaxSeqNum() + getSeqNumAccum());
        uint32 expected = 
                (getExtendedMaxSeqNum() - getBaseSeqNum() + 1);
        uint32 pc = getObservedPacketCount();
        uint32 lost;
        if ( 0 == pc )
                lost = 0;
        else
                lost = expected - pc;
        setCumulativePacketLost(lost);
        
        // compute the fraction of packets lost during the last
        // reporting interval.
        uint32 expectedDelta = expected - expectedPrior;
        expectedPrior = expected;
        uint32 receivedDelta = getObservedPacketCount() -
                receivedPrior;
        receivedPrior = getObservedPacketCount();
        uint32 lostDelta = expectedDelta - receivedDelta;
        if ( expectedDelta == 0 || lostDelta <= 0 ) 
                setFractionLost(0);
        else 
                setFractionLost((lostDelta<<8) / expectedDelta );
}

void
MembershipBookkeeping::SyncSourceLink::setPrevConflict(InetAddress& addr, 
                                                       tpport_t dataPort,
                                                       tpport_t controlPort)
{
        delete prevConflict;
        prevConflict = 
                new ConflictingTransportAddress(addr,dataPort,controlPort);
}

void
MembershipBookkeeping::SyncSourceLink::
recordInsertion(const IncomingRTPPktLink&)
{
}

void
MembershipBookkeeping::SyncSourceLink::
setSenderInfo(unsigned char* si)
{
        if ( NULL == senderInfo )
                senderInfo = reinterpret_cast<unsigned char*>
                        (new RTCPCompoundHandler::SenderInfo);
        memcpy(senderInfo,si,sizeof(RTCPCompoundHandler::SenderInfo));
}

void
MembershipBookkeeping::SyncSourceLink::
setReceiverInfo(unsigned char* ri)
{
        if ( NULL == receiverInfo )
                receiverInfo = reinterpret_cast<unsigned char*>
                        (new RTCPCompoundHandler::ReceiverInfo);
        memcpy(receiverInfo,ri,sizeof(RTCPCompoundHandler::ReceiverInfo));
}

const size_t MembershipBookkeeping::defaultMembersHashSize = 11;
const uint32 MembershipBookkeeping::SEQNUMMOD = (1<<16);

#define HASH(a) ((a + (a >> 8)) % MembershipBookkeeping::sourceBucketsNum)

// Initializes the array (hash table) and the global list of
// SyncSourceLink objects
MembershipBookkeeping::MembershipBookkeeping(uint32 initialSize):
        SyncSourceHandler(), ParticipantHandler(), 
        ConflictHandler(), Members(),
        sourceBucketsNum(initialSize),
        sourceLinks( new SyncSourceLink* [sourceBucketsNum] ),
        first(NULL), last(NULL)
{
        for ( uint32 i = 0; i < sourceBucketsNum; i++ )
                sourceLinks[i] = NULL;
}

void 
MembershipBookkeeping::endMembers()
{
        SyncSourceLink* s;
        while( first ) {
                s = first;
                first = first->next;
#ifdef  CCXX_EXCEPTIONS
                try {
#endif
                        delete s;
#ifdef  CCXX_EXCEPTIONS
                } catch (...) {}
#endif
        }
        last = NULL;
#ifdef  CCXX_EXCEPTIONS
        try {
#endif
                delete [] sourceLinks;
#ifdef  CCXX_EXCEPTIONS
        } catch (...) {}
#endif
}

bool
MembershipBookkeeping::isRegistered(uint32 ssrc)
{
        bool result = false;
        SyncSourceLink* sl = sourceLinks[ HASH(ssrc) ];

        while ( sl != NULL ) {
                if ( ssrc == sl->getSource()->getID() ) {
                        result = true;
                        break;
                } else if ( ssrc < sl->getSource()->getID() ) {
                        break;
                } else {
                        // keep on searching
                        sl = sl->getNextCollis();
                }
        }
        return result;
}

// Gets or creates the source and its link structure.
MembershipBookkeeping::SyncSourceLink*
MembershipBookkeeping::getSourceBySSRC(uint32 ssrc, bool& created)
{
        uint32 hashing = HASH(ssrc);
        SyncSourceLink* result = sourceLinks[hashing];
        SyncSourceLink* prev = NULL;
        created = false;

        if ( NULL == result ) {
                result = sourceLinks[hashing] = 
                        new SyncSourceLink(this,new SyncSource(ssrc));
                created = true;
        } else {
                while ( NULL != result ) {
                        if ( ssrc == result->getSource()->getID() ) {
                                // we found it!
                                break;
                        } else if ( ssrc > result->getSource()->getID() ) {
                                // keep on searching
                                prev = result;
                                result = result->getNextCollis();
                        } else { 
                                // ( ssrc < result->getSource()->getID() )
                                // it isn't recorded here -> create it.
                                SyncSourceLink* newlink = 
                                        new SyncSourceLink(this,new SyncSource(ssrc));
                                if ( NULL != prev )
                                        prev->setNextCollis(newlink);
                                else
                                        sourceLinks[hashing] = newlink;
                                newlink->setNextCollis(result);
                                result = newlink;
                                created = true;
                                break;
                        }
                }
                if ( NULL == result ) {
                        // insert at the end of the collision list
                        result = 
                                new SyncSourceLink(this,new SyncSource(ssrc));
                        created = true;
                        prev->setNextCollis(result);
                }
        }
        if ( created ) {
                if ( first )
                        last->setNext(result);                  
                else
                        first =  result;
                last = result;
                increaseMembersCount();
        }

        return result;
}

bool
MembershipBookkeeping::BYESource(uint32 ssrc) 
{  
        bool found = false;
        // If the source identified by ssrc is in the table, mark it
        // as leaving the session. If it was not, do nothing.
        if ( isRegistered(ssrc) ) {
                found = true;
                decreaseMembersCount(); // TODO really decrease right now?
        }
        return found;
}

bool
MembershipBookkeeping::removeSource(uint32 ssrc) 
{  
        bool found = false;
        SyncSourceLink* old = NULL, 
                * s = sourceLinks[ HASH(ssrc) ]; 
        while ( s != NULL ){
                if ( s->getSource()->getID() == ssrc ) {
                        // we found it
                        if ( old )
                                old->setNextCollis(s->getNextCollis());
                        if ( s->getPrev() )
                                s->getPrev()->setNext(s->getNext());
                        if ( s->getNext() )
                                s->getNext()->setPrev(s->getPrev());
                        decreaseMembersCount();
                        if ( s->getSource()->isSender() )
                                decreaseSendersCount();
                        delete s;
                        found = true;
                        break;              
                } else if ( s->getSource()->getID() > ssrc ) {
                        // it wasn't here
                        break;
                } else {
                        // keep on searching
                        old = s;
                        s = s->getNextCollis();
                }
        }
        return found;
}

#ifdef  CCXX_NAMESPACES
}
#endif

---

© sourcejam.com 2005-2008