Add even more of the source

This should be about everything needed to build so far?

RTCPUtilitiesLib/RTCPNADUPacketFmt.h

@@ -0,0 +1,132 @@
+/*
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ *
+ * Copyright (c) 1999-2008 Apple Inc.  All Rights Reserved.
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ * 
+ * @APPLE_LICENSE_HEADER_END@
+ *
+ */
+/*
+    File:       RTCPAPPNADUPacketFmt.h
+
+    Some useful things for Generating a 3GPP NADU packet
+*/
+
+#ifndef _RTCPNADUPACKETFMT_H_
+#define _RTCPNADUPACKETFMT_H_
+
+#include "StrPtrLen.h"
+#include "arpa/inet.h"
+#include "OSHeaders.h"
+#include "MyAssert.h"
+
+class RTCPNADUPacketFmt
+{
+    enum {
+       RTP_VERSION = 2,
+       RTCP_SR   = 200,
+       RTCP_RR   = 201,
+       RTCP_SDES = 202,
+       RTCP_BYE  = 203,
+       RTCP_APP  = 204
+    };
+
+    struct NADUHeader {
+#if 0     
+        //naduheader
+        unsigned int version:2;     /* protocol version */
+        unsigned int p:1;           /* padding flag */
+        unsigned int subtype:5;     /* 0 */
+        unsigned int pt:8;          /* RTCP packet type -- which should be RTCP_APP */
+#endif
+
+        UInt16 naduHeader;
+        UInt16 length;           /* packet length in words, minus 1 word */
+        UInt32 SSRC;                /* SSRC of packet sender */
+		UInt32 name;				/* in ASCII */
+    };
+
+    struct NADUBlock {
+        UInt32 SSRC;                /* data source being reported */
+		UInt16 delay;				/* the playout delay, in milliseconds */
+		UInt16 NSN;					/* the RTP sequence number of the next ADU to be decoded; if the buffer is empty then the next not yet received sequence number */
+		UInt16 NUN;			        /* the unit number of the next ADU to be decoded */
+		UInt16 FBS;		            /* the free buffer space, in complete 64 byte blocks */
+    };
+
+	public:
+		RTCPNADUPacketFmt() : fNumNADUBlocks(0)										{}
+        RTCPNADUPacketFmt(StrPtrLen &newBuffer) : fNumNADUBlocks(0)					{ SetBuffer(newBuffer); }
+        RTCPNADUPacketFmt(char *newBuffer, UInt32 bufLen) : fNumNADUBlocks(0)		{ SetBuffer(newBuffer, bufLen); }
+
+		//Setting the buffer resets the packet content
+        void    SetBuffer(StrPtrLen &newBuffer)                                 { return this->SetBuffer(newBuffer.Ptr, newBuffer.Len); }
+        void    SetBuffer(char *newBuffer, UInt32 bufLen)
+        {
+            Assert(sizeof(NADUHeader) == 12);
+			Assert(sizeof(NADUBlock) == 12);
+            Assert(bufLen >= sizeof(NADUHeader));
+
+            fBuf.Set(newBuffer, bufLen);
+            fNumNADUBlocks = 0;
+
+            //fill in the header
+            NADUHeader &header = *reinterpret_cast<NADUHeader *>(fBuf.Ptr);
+            ::memset(&header, 0, sizeof(header));
+            header.naduHeader = htons(0x80CC); //(RTP_VERSION << 14) + RTCP_APP; 
+  			header.name = htonl(FOUR_CHARS_TO_INT('P', 'S', 'S', '0'));
+            header.length = htons(GetPacketLen() / 4 - 1);
+        }
+		
+		//units are in milliseconds and in bytes; use a playoutDelay of kUInt32_Max if the buffer is empty
+		void	AddNADUBlock(UInt32 SSRC, UInt32 nextSeqNum, UInt8 nextUnitNum, UInt32 freeBufferSpace, UInt32 playoutDelay = kUInt32_Max)
+		{
+			Assert(fBuf.Len >= GetPacketLen() + sizeof(NADUBlock));
+            NADUBlock &nadu = *reinterpret_cast<NADUBlock *>(fBuf.Ptr + GetPacketLen());
+            ::memset(&nadu, 0, sizeof(NADUBlock));
+			
+			fNumNADUBlocks++;
+			reinterpret_cast<NADUHeader *>(fBuf.Ptr)->length = htons(GetPacketLen() / 4 - 1);
+
+			nadu.SSRC = htonl(SSRC);
+			nadu.NSN = htons(static_cast<UInt16>(nextSeqNum));
+			nadu.NUN = htons(nextUnitNum & 0x1F);
+
+			//Use reserved value of 0xffff for undefined
+			playoutDelay = MIN(0xffff, playoutDelay);
+			nadu.delay = htons(static_cast<UInt16>(playoutDelay));
+
+			//the free buffer space is reported in 64 bytes blocks, and maximum value is 0xffff
+			freeBufferSpace = MIN(0xffff, freeBufferSpace / 64);
+			nadu.FBS = htons(static_cast<UInt16>(freeBufferSpace));
+		}
+
+		void		SetSSRC(UInt32 SSRC)										{ reinterpret_cast<NADUHeader *>(fBuf.Ptr)->SSRC = htonl(SSRC); }
+
+        //The length of packet written out
+        UInt32      GetPacketLen()                                              { return sizeof(NADUHeader) + sizeof(NADUBlock) * fNumNADUBlocks; }
+        StrPtrLen   GetBufferRemaining()										{ return StrPtrLen(fBuf.Ptr + GetPacketLen(), fBuf.Len - GetPacketLen()); }
+        StrPtrLen   GetPacket()													{ return StrPtrLen(fBuf.Ptr, GetPacketLen()); }
+
+	private:
+        StrPtrLen   fBuf;
+        UInt32      fNumNADUBlocks;
+};
+
+#endif //_RTCPNADUPACKETFMT_H_