onekopaka/Darwin-Streaming-Server
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Add even more of the source

Browse source 
This should be about everything needed to build so far?
This commit is contained in:
Darren VanBuren 2017-03-07 17:14:16 -08:00
parent af3619d4fa
commit 849723c9cf
547 changed files with 149239 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

243
APIModules/QTSSReflectorModule/RTSPSourceInfo.h Normal file
View file

@ -0,0 +1,243 @@
/*
*
* @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: RTSPSourceInfo.h
Contains:
*/
#ifndef __RTSP_SOURCE_INFO_H__
#define __RTSP_SOURCE_INFO_H__
#include "QTSS.h"
#include "StrPtrLen.h"
#include "RCFSourceInfo.h"
#include "RTSPClient.h"
#include "XMLParser.h"
#include "ClientSocket.h"
#include "RelaySession.h"
class RelaySessionCreator;
class RTSPOutputInfo
{
public:
RTSPOutputInfo() : fIsAnnounced(false),
fAnnouncePort(554),
fDestURl(NULL),
fUserName(NULL),
fPassword(NULL) {}
~RTSPOutputInfo()
{
if (fDestURl != NULL) delete fDestURl;
if (fUserName != NULL) delete fUserName;
if (fPassword != NULL) delete fPassword;
}
static char* CopyString(const char* srcStr);
void Copy(const RTSPOutputInfo& copy); // copies dynamically allocated data too
Bool16 Equal(const RTSPOutputInfo* inInfo)
{ return ((inInfo != NULL) && (fIsAnnounced == inInfo->fIsAnnounced) && (fAnnouncePort == inInfo->fAnnouncePort)
&& (strcmp(fDestURl, inInfo->fDestURl) == 0)); }
Bool16 fIsAnnounced;
UInt16 fAnnouncePort;
char* fDestURl;
char* fUserName;
char* fPassword;
};
class RTSPSourceInfo : public RCFSourceInfo
{
public:
// Specify whether the client should be blocking or non-blocking
RTSPSourceInfo(Bool16 inAnnounce) : fSourceURL(NULL),
fHostAddr(0),
fHostPort(0),
fLocalAddr(0),
fUserName(NULL),
fPassword(NULL),
fRTSPInfoArray(NULL),
fClientSocket(NULL),
fClient(NULL),
fNumSetupsComplete(0),
fDescribeComplete(false),
fAnnounce(inAnnounce),
fAnnounceURL(NULL),
fAnnounceIP(0),
fAnnounceActualIP(0),
fRelaySessionCreatorTask(NULL),
fSession(NULL),
fSessionQueue(NULL),
fQueueElem() { fQueueElem.SetEnclosingObject(this); }
RTSPSourceInfo(const RTSPSourceInfo& copy); // Does copy dynamically allocated data
// Doesn't copy fClientSocket and fClient ptrs
virtual ~RTSPSourceInfo();
// Call this before calling ParsePrefs / Describe
void InitClient(UInt32 inSocketType);
void SetClientInfo(UInt32 inAddr, UInt16 inPort, char* inURL, UInt32 inLocalAddr = 0);
// Call this immediately after the constructor. This object will parse
// the config file and extract the necessary information to connect to an rtsp server.
// Specify the config file line index where the "rtsp_source" line resides
QTSS_Error ParsePrefs(XMLTag* relayTag, Bool16 inAnnounce);
// Connects, sends a DESCRIBE, and parses the incoming SDP data. After this
// function completes sucessfully, GetLocalSDP returns the data, and the
// SourceInfo & DestInfo arrays will be set up. Also sends SETUPs for all the
// tracks, and finishes by issuing a PLAY.
//
// These functions return QTSS_NoErr if the transaction has completed
// successfully. Otherwise, they return:
//
// EAGAIN: the transaction is still in progress, the call should be reissued
// QTSS_RequestFailed: the remote host responded with an error.
// Any other error means that the remote host was unavailable or refused the connection
QTSS_Error Describe();
QTSS_Error SetupAndPlay();
// This function works the same way as the above ones, and should be
// called before destroying the object to let the remote host know that
// we are going away.
QTSS_Error Teardown();
// This function uses the Parsed SDP file, and strips out all the network information,
// producing an SDP file that appears to be local.
virtual char* GetLocalSDP(UInt32* newSDPLen);
virtual char* GetAnnounceSDP(UInt32 ipAddr, UInt32* newSDPLen);
virtual StrPtrLen* GetSourceID() { return fClient->GetURL(); }
// This object looks for this keyword in the FilePrefsSource, where it
// expects the IP address, port, and URL.
static StrPtrLen& GetRTSPSourceString() { return sKeyString; }
RTSPClient* GetRTSPClient() { return fClient; }
TCPClientSocket* GetClientSocket() { return fClientSocket; }
Bool16 IsDescribeComplete(){ return fDescribeComplete; }
RTSPOutputInfo* GetRTSPOutputInfo(UInt32 index) { return &fRTSPInfoArray[index]; }
char* GetSourceURL() { return fSourceURL; }
virtual Bool16 IsRTSPSourceInfo() { return true; }
virtual Bool16 Equal(SourceInfo* inInfo);
Bool16 IsAnnounce() { return fAnnounce; }
char* GetAnnounceURL() { return fAnnounceURL; }
UInt32 GetAnnounceIP() { return fAnnounceIP; }
UInt32 GetAnnounceActualIP() { return fAnnounceActualIP; }
void SetAnnounceActualIP(UInt32 inActualIP) { fAnnounceActualIP = inActualIP; }
UInt32 GetHostAddr() { return fHostAddr; }
UInt32 GetHostPort() { return fHostPort; }
char* GetUsername() { return fUserName; }
char* GetPassword() { return fPassword; }
RelaySession* GetRelaySession() { return fSession; }
void SetSourceParameters(UInt32 inHostAddr, UInt16 inHostPort, StrPtrLen& inURL);
void StartSessionCreatorTask(OSQueue* inSessionQueue, OSQueue* inSourceQueue);
SInt64 RunCreateSession();
protected:
virtual void ParseAnnouncedDestination(XMLTag* destTag, UInt32 index);
virtual void AllocateOutputArray(UInt32 numOutputs);
private:
class RelaySessionCreator : public Task
{
public:
RelaySessionCreator(RTSPSourceInfo* inInfo) : fInfo(inInfo) {this->SetTaskName("RTSPSourceInfo::RelaySessionCreator");}
virtual SInt64 Run();
RTSPSourceInfo* fInfo;
};
class TeardownTask : public Task
{
public:
TeardownTask(TCPClientSocket* clientSocket, RTSPClient* client);
virtual ~TeardownTask();
virtual SInt64 Run();
private:
TCPClientSocket* fClientSocket;
RTSPClient* fClient;
};
char* fSourceURL;
UInt32 fHostAddr;
UInt16 fHostPort;
UInt32 fLocalAddr;
char* fUserName;
char* fPassword;
RTSPOutputInfo* fRTSPInfoArray;
TCPClientSocket* fClientSocket;
RTSPClient* fClient;
UInt32 fNumSetupsComplete;
Bool16 fDescribeComplete;
StrPtrLen fLocalSDP;
Bool16 fAnnounce;
char* fAnnounceURL;
UInt32 fAnnounceIP;
UInt32 fAnnounceActualIP;
RelaySessionCreator* fRelaySessionCreatorTask;
enum // relay session creation states
{
kSendingDescribe = 0,
kSendingSetup = 1,
kSendingPlay = 2,
kDone = 3
};
UInt32 fSessionCreationState;
RelaySession* fSession;
OSQueue* fSessionQueue;
OSQueueElem fQueueElem;
static StrPtrLen sKeyString;
static StrPtrLen sAnnouncedKeyString;
};
#endif // __RTSP_SOURCE_INFO_H__