Add even more of the source

This should be about everything needed to build so far?

Server.tproj/RTPSession.h

@@ -0,0 +1,172 @@
+/*
+ *
+ * @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:       RTPSession.h
+
+    Contains:   RTPSession represents an, well, an RTP session. The server creates
+                one of these when a new client connects, and it lives for the duration
+                of an RTP presentation. It contains all the resources associated with
+                that presentation, such as RTPStream objects. It also provides an
+                API for manipulating a session (playing it, pausing it, stopping it, etc) 
+                
+                It is also the active element, ie. it is the object that gets scheduled
+                to send out & receive RTP & RTCP packets
+                
+    Change History (most recent first):
+
+    
+    
+
+*/
+
+
+#ifndef _RTPSESSION_H_
+#define _RTPSESSION_H_
+
+#include "RTPSessionInterface.h"
+#include "RTSPRequestInterface.h"
+#include "RTPStream.h"
+#include "QTSSModule.h"
+
+
+class RTPSession : public RTPSessionInterface
+{
+    public:
+    
+        RTPSession();
+        virtual ~RTPSession();
+        
+        //
+        //ACCESS FUNCTIONS
+        
+        QTSSModule* GetPacketSendingModule()                        { return fModule; }
+        Bool16      HasAnRTPStream()                                { return fHasAnRTPStream; }
+        
+        RTPStream*  FindRTPStreamForChannelNum(UInt8 inChannelNum);
+        
+        //
+        // MODIFIERS
+        
+        //This puts this session into the session map (called by the server! not the module!)
+        //If this function fails (it can return QTSS_DupName), it means that there is already
+        //a session with this session ID in the map.
+        QTSS_Error  Activate(const StrPtrLen& inSessionID);
+                
+        // The way this object is implemented currently, only one module can send the
+        // packets for a session.
+        void        SetPacketSendingModule(QTSSModule* inModule)    { fModule = inModule; }
+
+        //Once the session is bound, a module can add streams to it.
+        //It must pass in a trackID that uniquely identifies this stream.
+        //This call can only be made during an RTSP Setup request, and the
+        //RTSPRequestInterface must be provided.
+        //You may also opt to attach a codec name and type to this stream.
+        QTSS_Error  AddStream(  RTSPRequestInterface* request, RTPStream** outStream,
+                                    QTSS_AddStreamFlags inFlags);
+        
+		//Reset the thinning params for all streams using the late tolerance value
+		void SetStreamThinningParams(Float32 inLateTolerance);
+		
+		//Find the appropriate stream and set the rate adaptation stream data
+		void Set3GPPRateAdaptionData(RateAdapationStreamDataFields *rateAdaptStreamData);
+		
+		// Store the Session Interface's Link Char values
+		void Set3GPPLinkCharData(LinkCharDataFields *linkCharData);
+
+        //Begins playing all streams. Currently must be associated with an RTSP Play
+        //request, and the request interface must be provided.
+        QTSS_Error  Play(RTSPRequestInterface* request, QTSS_PlayFlags inFlags);
+        
+        //Pauses all streams.
+        void            Pause();
+        
+        // Tears down the session. This will cause QTSS_SessionClosing_Role to run
+        void            Teardown();
+
+        //Utility functions. Modules aren't required to use these, but can be useful
+        void            SendDescribeResponse(RTSPRequestInterface* request);
+        void            SendAnnounceResponse(RTSPRequestInterface* request);
+        void            SendPlayResponse(RTSPRequestInterface* request, UInt32 inFlags);
+        void            SendPauseResponse(RTSPRequestInterface* request)
+                                                                { request->SendHeader(); }
+        void            SendTeardownResponse(RTSPRequestInterface* request)
+                                    { request->SetKeepAlive(false); request->SendHeader(); }
+                                    
+        SInt32          GetQualityLevel();
+        void            SetQualityLevel(SInt32 level);
+        
+        void            SetMovieBitRateData();
+
+    private:
+    
+        //where timeouts, deletion conditions get processed
+        virtual SInt64  Run();
+        
+        // Utility function used by Play
+        UInt32 PowerOf2Floor(UInt32 inNumToFloor);
+    
+		//overbuffer logging function
+		void LogOverbufferStats();
+	
+		enum
+		{
+            kRTPStreamArraySize     = 20,
+            kCantGetMutexIdleTime   = 10
+        };
+
+        QTSSModule*         fModule;
+        Bool16              fHasAnRTPStream;
+        SInt32              fSessionQualityLevel;
+        
+        char        fRTPStreamArray[kRTPStreamArraySize];
+        
+        // Module invocation and module state.
+        // This info keeps track of our current state so that
+        // the state machine works properly.
+        enum
+        {
+            kStart                  = 0,
+            kSendingPackets         = 1
+        };
+        
+        UInt32 fCurrentModuleIndex;
+        UInt32 fCurrentState;
+        
+        QTSS_ModuleState    fModuleState;
+        QTSS_CliSesClosingReason fClosingReason;
+        
+        UInt32              fCurrentModule;
+        // This is here to give the ability to the ClientSessionClosing role to
+        // do asynchronous I/O
+        Bool16              fModuleDoingAsyncStuff;
+        
+#if DEBUG
+        Bool16 fActivateCalled;
+#endif
+        SInt64              fLastBandwidthTrackerStatsUpdate;
+
+};
+
+#endif //_RTPSESSION_H_