queuebase.h

Go to the documentation of this file.
00001 // Copyright (C) 2001,2002,2004 Federico Montesino Pouzols <fedemp@altern.org>.
00002 // 
00003 // This program is free software; you can redistribute it and/or modify
00004 // it under the terms of the GNU General Public License as published by
00005 // the Free Software Foundation; either version 2 of the License, or
00006 // (at your option) any later version.
00007 // 
00008 // This program is distributed in the hope that it will be useful,
00009 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00010 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00011 // GNU General Public License for more details.
00012 // 
00013 // You should have received a copy of the GNU General Public License
00014 // along with this program; if not, write to the Free Software 
00015 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
00016 // 
00017 // As a special exception, you may use this file as part of a free software
00018 // library without restriction.  Specifically, if other files instantiate
00019 // templates or use macros or inline functions from this file, or you compile
00020 // this file and link it with other files to produce an executable, this
00021 // file does not by itself cause the resulting executable to be covered by
00022 // the GNU General Public License.  This exception does not however    
00023 // invalidate any other reasons why the executable file might be covered by
00024 // the GNU General Public License.    
00025 //
00026 // This exception applies only to the code released under the name GNU
00027 // ccRTP.  If you copy code from other releases into a copy of GNU
00028 // ccRTP, as the General Public License permits, the exception does
00029 // not apply to the code that you add in this way.  To avoid misleading
00030 // anyone as to the status of such modified files, you must delete
00031 // this exception notice from them.
00032 //
00033 // If you write modifications of your own for GNU ccRTP, it is your choice
00034 // whether to permit this exception to apply to your modifications.
00035 // If you do not wish that, delete this exception notice.
00036 //
00037 
00044 #ifndef CCXX_RTP_QUEUEBASE_H_
00045 #define CCXX_RTP_QUEUEBASE_H_
00046 
00047 #include <cc++/pointer.h>
00048 #include <ccrtp/rtppkt.h>
00049 #include <ccrtp/sources.h>
00050 
00051 #ifdef  CCXX_NAMESPACES
00052 namespace ost {
00053 #endif
00054 
00071 class __EXPORT AppDataUnit
00072 {               
00073 public:
00074         AppDataUnit(const IncomingRTPPkt& packet, const SyncSource& src);
00075                 
00076         inline ~AppDataUnit()
00077         { }
00078                 
00082         AppDataUnit(const AppDataUnit& src);
00083                 
00090         AppDataUnit&
00091         operator=(const AppDataUnit& source);
00092                 
00096         inline PayloadType
00097         getType() const
00098         { return datablock->getPayloadType(); };
00099 
00107         inline const uint8* const
00108         getData() const
00109         { return datablock->getPayload(); };
00110                 
00114         size_t
00115         getSize() const
00116         { return datablock->getPayloadSize(); };
00117 
00121         inline const SyncSource&
00122         getSource() const
00123         { return *source; }
00124 
00130         inline bool 
00131         isMarked() const
00132         { return datablock->isMarked(); }
00133 
00137         inline uint16
00138         getSeqNum() const
00139         { return datablock->getSeqNum(); }
00140 
00144         inline uint8
00145         getContributorsCount() const
00146         { return (uint8)datablock->getCSRCsCount(); }
00147 
00153         inline const uint32*
00154         getContributorsID() const
00155         { return datablock->getCSRCs(); }
00156 
00157 private:
00158         Pointer<const IncomingRTPPkt> datablock;
00159         const SyncSource* source;
00160 };
00161 
00169 class __EXPORT RTPQueueBase
00170 {
00171 public:
00179         inline bool
00180         setPayloadFormat(const PayloadFormat& pf)
00181         { 
00182                 currentPayloadType = pf.getPayloadType();
00183                 currentRTPClockRate = pf.getRTPClockRate();
00184                 return true;
00185         }
00186 
00187         inline uint32 getLocalSSRC() const
00188         { return localSSRC; }
00189 
00198         inline uint32 getCurrentRTPClockRate() const
00199         { return currentRTPClockRate; }
00200 
00201         inline PayloadType getCurrentPayloadType() const
00202         { return currentPayloadType; }
00203 
00204         inline timeval getInitialTime() const
00205         { return initialTime; }
00206 
00207 protected:
00212         RTPQueueBase(uint32 *ssrc = NULL);
00213 
00214         inline void setLocalSSRC(uint32 ssrc)
00215         { localSSRC = ssrc; localSSRCNetwork = htonl(ssrc); }
00216 
00217         inline uint32 getLocalSSRCNetwork() const
00218         { return localSSRCNetwork; }
00219 
00220         virtual 
00221         ~RTPQueueBase()
00222         { }
00223 
00230         inline virtual size_t
00231         dispatchBYE(const std::string&)
00232         { return 0; }
00233 
00234         inline virtual void
00235         renewLocalSSRC()
00236         { }
00237 
00238 private:
00239         // local SSRC 32-bit identifier
00240         uint32 localSSRC;
00241         // SSRC in network byte order
00242         uint32 localSSRCNetwork;
00243         // RTP clock rate for the current payload type.
00244         uint32 currentRTPClockRate;
00245         // Current payload type set for outgoing packets and expected
00246         // from incoming packets.
00247         PayloadType currentPayloadType;
00248         // when the queue is created
00249         timeval initialTime;
00250 };
00251 
00257 class __EXPORT OutgoingDataQueueBase:
00258         public virtual RTPQueueBase
00259 {
00260 public:
00261         inline size_t
00262         getDefaultMaxSendSegmentSize()
00263         { return defaultMaxSendSegmentSize;}
00264 
00271         inline void
00272         setMaxSendSegmentSize(size_t size)
00273         { maxSendSegmentSize = size; }
00274 
00275         inline size_t
00276         getMaxSendSegmentSize()
00277         { return maxSendSegmentSize; }
00278 
00279 protected:
00280         OutgoingDataQueueBase();
00281 
00282         inline virtual
00283         ~OutgoingDataQueueBase()
00284         { }
00285 
00286 private:
00287         static const size_t defaultMaxSendSegmentSize;
00288         // maximum packet size before fragmenting sends.
00289         size_t maxSendSegmentSize;
00290 };
00291 
00297 class __EXPORT IncomingDataQueueBase:
00298         public virtual RTPQueueBase
00299 {
00300 public:
00301         inline size_t getDefaultMaxRecvPacketSize() const
00302         { return defaultMaxRecvPacketSize; }
00303 
00304         inline size_t
00305         getMaxRecvPacketSize() const
00306         { return maxRecvPacketSize; }
00307 
00318         inline void
00319         setMaxRecvPacketSize(size_t maxsize)
00320         { maxRecvPacketSize = maxsize; }
00321 
00322 protected:
00323         IncomingDataQueueBase()
00324         { setMaxRecvPacketSize(getDefaultMaxRecvPacketSize()); }
00325 
00326         inline virtual 
00327         ~IncomingDataQueueBase()
00328         { }
00329 
00330 private:
00331         static const size_t defaultMaxRecvPacketSize;
00332         // filter value for received packets length.
00333         size_t maxRecvPacketSize;
00334 };
00335  // queuebase
00337 
00338 #ifdef  CCXX_NAMESPACES
00339 }
00340 #endif
00341 
00342 #endif  //CCXX_RTP_QUEUEBASE_H_
00343 

Generated on Mon Apr 30 01:46:52 2007 for ccRTP by  doxygen 1.5.1