243 lines
9.5 KiB
C++
243 lines
9.5 KiB
C++
/*
|
|
*
|
|
* @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__
|
|
|