对live555封装的比较好的一个类，网上找到的，觉得不错，给大家共享

对live555封装的比较好的一个类，网上找到的，觉得不错，给大家共享，也不记得从哪里下载的了，版权归原作者！

 

这个类的主要特点是可以创建多个客户端，连接多路码流；我们可以参考他的设计，在sink中将码流回调出来，在外部解码；

 

文件如下：

#pragma once

#include "BasicUsageEnvironment\BasicUsageEnvironment.hh"
#include "groupsock\GroupsockHelper.hh"
#include "liveMedia\liveMedia.hh"
#include <iostream>
#include <list>
#include <map>

struct YHRTSPClient
{
	TaskScheduler* pTaskScheduler;
	UsageEnvironment* pEnv;
	RTSPClient* pClient;
	MediaSession *pMediaSession;
	MediaSubsessionIterator *iter;
	Boolean bMadeProgress;
	unsigned fileSinkBufferSize;
	unsigned socketInputBufferSize;
	Boolean  bStreamUsingTCP;
	Authenticator* pAuthenticator;
	char	 m_cEventLoop;
	YHRTSPClient()
	{
		pClient = NULL;
		pMediaSession = NULL;
		iter = NULL;
		bMadeProgress = False;
		fileSinkBufferSize = 100000;
		socketInputBufferSize = 524288;
		bStreamUsingTCP = False;
		pAuthenticator = NULL;
		m_cEventLoop = 0;

	}
	YHRTSPClient(RTSPClient *client)
	{
		pClient = client;
		pMediaSession = NULL;
		iter = NULL;
		bMadeProgress = False;
		fileSinkBufferSize = 100000;
		socketInputBufferSize = 524288;
		bStreamUsingTCP = False;
		pAuthenticator = NULL;
		m_cEventLoop = 0;
	}
};

class CYHMediaClient
{
public:
	static CYHMediaClient* GetInstance();
	CYHMediaClient(void);
	~CYHMediaClient(void);
public:
	BOOL CreateRTPClient(LONG lID, const char *chServerURL);
	//BOOL StartStreaming(char *chWatchVariable = NULL);
	void StopStreaming(int nClientID);

	void GetSDPDescription(RTSPClient* pRTSPClient, RTSPClient::responseHandler* afterFunc);
	void SetupStreams(RTSPClient* pRTSPClient);
	void SetupSubsession(RTSPClient* pRTSPClient,MediaSubsession* subsession, Boolean streamUsingTCP, RTSPClient::responseHandler* afterFunc);
    void StartPlayingSession(RTSPClient* pRTSPClient,MediaSession* session, double start, double end, float scale, RTSPClient::responseHandler* afterFunc);
	void TearDownSession(RTSPClient* pRTSPClient,MediaSession* session, RTSPClient::responseHandler* afterFunc);

	void SetFileSinkAndSocket(YHRTSPClient *pYHClient,unsigned fileSinkBufferSize,unsigned socketInputBufferSize);
	void SetStreamUsingTCP(YHRTSPClient* pYHClient, Boolean bStreamUsingTCP){pYHClient->bStreamUsingTCP = bStreamUsingTCP;};

	UsageEnvironment *GetEnvironment(RTSPClient* pRTSPClient)
	{
		UsageEnvironment *pEnv = NULL;
		if (NULL == pRTSPClient)
		{
			return pEnv;
		}
		YHRTSPClient *pYHClient = GetYHRTSPClient(pRTSPClient);
		if (NULL != pYHClient)
		{
			pEnv = pYHClient->pEnv;
		}
	    
		return pEnv;
	};

private:
	void GetOptions(RTSPClient* pRTSPClient, RTSPClient::responseHandler* afterFunc);
	void Shutdown(RTSPClient *pClient = NULL);
	YHRTSPClient* GetYHRTSPClient(RTSPClient *pClient);
	void EraseYHRTSPClient(RTSPClient *pClient);
	LONG GetRTSPClientID(RTSPClient* pClient);
	void CloseMediaSinks(RTSPClient *pClient);
		
	static void ContinueAfterOptions(RTSPClient* pClient, int resultCode, char* resultString);
	static void ContinueAfterDescribe(RTSPClient* pClient, int resultCode, char* resultString);
	static void ContinueAfterSetup(RTSPClient* pClient, int resultCode, char* resultString);
	static void ContinueAfterPlay(RTSPClient* pClient, int resultCode, char* resultString);
	static void SubsessionAfterPlaying(void* clientData);
	static void SubsessionByeHandler(void* clientData);
	static void ContinueAfterTearDown(RTSPClient* pClient, int resultCode, char* resultString) ;
	
public:
	std::list<YHRTSPClient*> m_listRTSPClient;
	std::map<int, RTSPClient*> m_mapClientID;
private:
	static CYHMediaClient* pYHMediaClient;
	//TaskScheduler* pTaskScheduler;
	//UsageEnvironment* pEnv;
};



源文件如下：

<pre class="cpp" name="code">//#include "stdafx.h"
#include "YHMediaClient.h"
#include "WinCriticalSection.h"
#include "MetMediaSink.h"
//#include "YHWMPlayDemoDlg.h"
char const* clientProtocolName = "RTSP";
CYHMediaClient* CYHMediaClient::pYHMediaClient = NULL;
WinCriticalSection g_cs;

CYHMediaClient* CYHMediaClient::GetInstance()
{
	Mutex mutex(g_cs);
	if (CYHMediaClient::pYHMediaClient == NULL)
	{
		pYHMediaClient = new CYHMediaClient;
	}
	return pYHMediaClient;
}

CYHMediaClient::CYHMediaClient(void)
{
	
}

CYHMediaClient::~CYHMediaClient(void)
{
	m_listRTSPClient.empty();
}

BOOL CYHMediaClient::CreateRTPClient(LONG lID, const char *chServerURL)
{
	g_cs.Enter();
	TaskScheduler *pTaskScheduler = BasicTaskScheduler::createNew();
	UsageEnvironment *pEnv = BasicUsageEnvironment::createNew(*pTaskScheduler);
    RTSPClient* pRTSPClient = (RTSPClient*)RTSPClient::createNew(*pEnv, chServerURL, 0, NULL, 0);
    if (NULL == pRTSPClient)
    {
		*pEnv << "Failed to create" << clientProtocolName << " client: " << pEnv->getResultMsg() << "\n";
		return FALSE;
    }
    m_mapClientID.insert(std::make_pair(lID, pRTSPClient));
	YHRTSPClient *stucClient = new YHRTSPClient(pRTSPClient);
	stucClient->pTaskScheduler = pTaskScheduler;
	stucClient->pEnv = pEnv;
	CYHMediaClient::GetInstance()->m_listRTSPClient.push_back(stucClient);
	GetOptions(pRTSPClient, ContinueAfterOptions);
    g_cs.Leave();
	stucClient->pEnv->taskScheduler().doEventLoop(&stucClient->m_cEventLoop);
	if (pTaskScheduler)
	{
		delete pTaskScheduler;
		pTaskScheduler = NULL;
	}
	if(stucClient)
	{
		delete stucClient;
		stucClient = NULL;
	}
	return TRUE;
}

void CYHMediaClient::StopStreaming(int nClientID)
{
	Mutex mutex(g_cs);
	std::map<int, RTSPClient*>::iterator iter = m_mapClientID.find(nClientID);
	if (iter != m_mapClientID.end())
	{
		RTSPClient* pRTSPClient = iter->second;
		Shutdown(pRTSPClient);
		EraseYHRTSPClient(pRTSPClient);
		m_mapClientID.erase(iter); 		
	}
}

void CYHMediaClient::Shutdown(RTSPClient *pClient)
{
	YHRTSPClient* pYHRTSPClient = GetYHRTSPClient(pClient);
	if (pYHRTSPClient != NULL)
	{
		if (pYHRTSPClient->pMediaSession != NULL) 
		{
			TearDownSession(pClient,pYHRTSPClient->pMediaSession, ContinueAfterTearDown);
		} 
		else
		{
			ContinueAfterTearDown(NULL, 0, NULL);
		}		
		CYHMediaClient::GetInstance()->CloseMediaSinks(pClient);
		if (pYHRTSPClient->pMediaSession)
		{
			Medium::close(pYHRTSPClient->pMediaSession);
			pYHRTSPClient->pMediaSession = NULL;
		}
		// Finally, shut down our client:
		if (pClient)
		{
			Medium::close(pClient);	
			pClient = NULL;
		}
		pYHRTSPClient->m_cEventLoop = 1;
			
	}
	
}

void CYHMediaClient::GetOptions(RTSPClient* pRTSPClient, RTSPClient::responseHandler* afterFunc)
{
	Mutex mutex(g_cs);
	if (pRTSPClient)
	{
		YHRTSPClient *pYHClient = CYHMediaClient::GetInstance()->GetYHRTSPClient(pRTSPClient);
		pRTSPClient->sendOptionsCommand(afterFunc, pYHClient->pAuthenticator);
	}	
}

void CYHMediaClient::GetSDPDescription(RTSPClient* pRTSPClient,RTSPClient::responseHandler* afterFunc)
{
	Mutex mutex(g_cs);
	if (pRTSPClient)
	{
		YHRTSPClient *pYHClient = CYHMediaClient::GetInstance()->GetYHRTSPClient(pRTSPClient);
		pRTSPClient->sendDescribeCommand(afterFunc, pYHClient->pAuthenticator);
	}
}

void CYHMediaClient::SetupSubsession(RTSPClient* pRTSPClient,MediaSubsession* subsession, Boolean streamUsingTCP, RTSPClient::responseHandler* afterFunc)
{
	Mutex mutex(g_cs);
	Boolean forceMulticastOnUnspecified = False;
	if (pRTSPClient)
	{
		YHRTSPClient *pYHClient = CYHMediaClient::GetInstance()->GetYHRTSPClient(pRTSPClient);
		pRTSPClient->sendSetupCommand(*subsession, afterFunc, False, streamUsingTCP, forceMulticastOnUnspecified, pYHClient->pAuthenticator);
	}
}

void CYHMediaClient::StartPlayingSession(RTSPClient* pRTSPClient,MediaSession* session, double start, double end, float scale, RTSPClient::responseHandler* afterFunc) 
{
	//Mutex mutex(g_cs);
	if (pRTSPClient)
	{
		YHRTSPClient *pYHClient = CYHMediaClient::GetInstance()->GetYHRTSPClient(pRTSPClient);
		pRTSPClient->sendPlayCommand(*session, afterFunc, start, end, scale, pYHClient->pAuthenticator);
	}
}

void CYHMediaClient::TearDownSession(RTSPClient* pRTSPClient,MediaSession* session, RTSPClient::responseHandler* afterFunc)
{
	Mutex mutex(g_cs);
	if (pRTSPClient)
	{
		YHRTSPClient *pYHClient = CYHMediaClient::GetInstance()->GetYHRTSPClient(pRTSPClient);
		pRTSPClient->sendTeardownCommand(*session, afterFunc, pYHClient->pAuthenticator);
	}
}

void CYHMediaClient::ContinueAfterOptions(RTSPClient* pClient, int resultCode, char* resultString)
{
	Mutex mutex(g_cs);
	if(CYHMediaClient::GetInstance() != NULL)
	{
		if (resultCode != 0)
		{
			*(CYHMediaClient::GetInstance()->GetEnvironment(pClient)) << clientProtocolName << " \"OPTIONS\" request failed: " << resultString << "\n";
			return;
		}
		else
		{
			*(CYHMediaClient::GetInstance()->GetEnvironment(pClient)) << clientProtocolName << " \"OPTIONS\" request returned: " << resultString << "\n";
		}
		delete[] resultString;

		CYHMediaClient::GetInstance()->GetSDPDescription(pClient, ContinueAfterDescribe);
	}	
    return;
}

void CYHMediaClient::ContinueAfterDescribe(RTSPClient* pClient, int resultCode, char* resultString)
{
	Mutex mutex(g_cs);
	if (CYHMediaClient::GetInstance() != NULL)
	{
		if (resultCode != 0) 
		{
			CYHMediaClient::GetInstance()->Shutdown();
			return;
		}

		char* sdpDescription = resultString;
		// Create a media session object from this SDP description:
		MediaSession *pMediaSession = MediaSession::createNew(*(CYHMediaClient::GetInstance()->GetEnvironment(pClient)), sdpDescription);
		delete[] sdpDescription;

		if (pMediaSession == NULL) 
		{
			*(CYHMediaClient::GetInstance()->GetEnvironment(pClient)) << "Failed to create a MediaSession object from the SDP description: " << CYHMediaClient::GetInstance()->GetEnvironment(pClient)->getResultMsg() << "\n";	
			CYHMediaClient::GetInstance()->Shutdown(pClient);
			return;
		} 
		else if (!pMediaSession->hasSubsessions()) 
		{
			*(CYHMediaClient::GetInstance()->GetEnvironment(pClient)) << "This session has no media subsessions (i.e., \"m=\" lines)\n";
			CYHMediaClient::GetInstance()->Shutdown(pClient);
			return;
		}

		// Then, setup the "RTPSource"s for the session:
		MediaSubsessionIterator iter(*pMediaSession);

		MediaSubsession *subsession;
		YHRTSPClient *pYHClient = CYHMediaClient::GetInstance()->GetYHRTSPClient(pClient);
		pYHClient->bMadeProgress = False;
		pYHClient->pMediaSession = pMediaSession;

		while ((subsession = iter.next()) != NULL)
		{
			if (!subsession->initiate()) 
			{
				*(CYHMediaClient::GetInstance()->GetEnvironment(pClient)) << "Unable to create receiver for \"" << subsession->mediumName()
					<< "/" << subsession->codecName()
					<< "\" subsession: " << CYHMediaClient::GetInstance()->GetEnvironment(pClient)->getResultMsg() << "\n";
			} 
			else
			{
				*(CYHMediaClient::GetInstance()->GetEnvironment(pClient)) << "Created receiver for \"" << subsession->mediumName()
					<< "/" << subsession->codecName()
					<< "\" subsession (client ports " << subsession->clientPortNum()
					<< "-" << subsession->clientPortNum()+1 << ")\n";

				pYHClient->bMadeProgress = True;
				if (subsession->rtpSource() != NULL)
				{
					// Because we're saving the incoming data, rather than playing
					// it in real time, allow an especially large time threshold
					// (1 second) for reordering misordered incoming packets:
					unsigned const thresh = 500000; // 0.5 second
					subsession->rtpSource()->setPacketReorderingThresholdTime(thresh);

					// Set the RTP source's OS socket buffer size as appropriate - either if we were explicitly asked (using -B),
					// or if the desired FileSink buffer size happens to be larger than the current OS socket buffer size.
					// (The latter case is a heuristic, on the assumption that if the user asked for a large FileSink buffer size,
					// then the input data rate may be large enough to justify increasing the OS socket buffer size also.)
					int socketNum = subsession->rtpSource()->RTPgs()->socketNum();
					unsigned curBufferSize = getReceiveBufferSize(*CYHMediaClient::GetInstance()->GetEnvironment(pClient), socketNum);
					if (pYHClient->socketInputBufferSize > 0 || pYHClient->fileSinkBufferSize > curBufferSize)
					{
						unsigned newBufferSize = pYHClient->socketInputBufferSize > 0 ? pYHClient->socketInputBufferSize : pYHClient->fileSinkBufferSize;
						newBufferSize = setReceiveBufferTo(*CYHMediaClient::GetInstance()->GetEnvironment(pClient), socketNum, newBufferSize);
					}
				}
			}
		}
		if (!pYHClient->bMadeProgress) 
		{
			CYHMediaClient::GetInstance()->Shutdown(pClient);
			return;
		}

		// Perform additional 'setup' on each subsession, before playing them:
		CYHMediaClient::GetInstance()->SetupStreams(pClient);
	}
}

void CYHMediaClient::SetupStreams(RTSPClient* pRTSPClient)
{
	Mutex mutex(g_cs);
	YHRTSPClient *struClient = GetYHRTSPClient(pRTSPClient);
	if (struClient->iter == NULL) 
		struClient->iter = new MediaSubsessionIterator(*(struClient->pMediaSession));
	MediaSubsession *subsession = NULL;
	while ((subsession = struClient->iter->next()) != NULL) 
	{
		// We have another subsession left to set up:
		if (subsession->clientPortNum() == 0) 
			continue; // port # was not set
		if (pRTSPClient != NULL)
		{
			SetupSubsession(pRTSPClient, subsession, /*struClient->bStreamUsingTCP*/True, ContinueAfterSetup);
		}
		return;
	}

	// We're done setting up subsessions.
	if (!struClient->bMadeProgress) 
	{
		Shutdown(pRTSPClient);
		return;
	}

	// Create and start "FileSink"s for each subsession:
	struClient->bMadeProgress = False;
	MediaSubsessionIterator iter(*(struClient->pMediaSession));
	while ((subsession = iter.next()) != NULL) 
	{
		if (subsession->readSource() == NULL) 
			continue; // was not initiated

		// Create an output file for each desired stream:
		CMetMediaSink* pMediaSink;
		unsigned int requestedBufferSize = 524288;
		pMediaSink = CMetMediaSink::createNew(*struClient->pEnv, struClient->socketInputBufferSize);
		pMediaSink->SetMediaSession(struClient->pMediaSession);
		pMediaSink->SetPlayHandle(GetRTSPClientID(pRTSPClient));
		subsession->sink = pMediaSink;
		if (subsession->sink == NULL) 
		{
			*struClient->pEnv << "Failed to create MediaSink for \"" << "MediaClient"<< "\": " << struClient->pEnv->getResultMsg() << "\n";
		} 
		else 
		{
			subsession->sink->startPlaying(*(subsession->readSource()),SubsessionAfterPlaying,subsession);

			// Also set a handler to be called if a RTCP "BYE" arrives
			// for this subsession:
			if (subsession->rtcpInstance() != NULL) 
			{
				subsession->rtcpInstance()->setByeHandler(SubsessionByeHandler, subsession);
			}
			struClient->bMadeProgress = True;
		}
	}
	if (!struClient->bMadeProgress) 
	{
		Shutdown(pRTSPClient);
		return;
	}
	double duration = 0;
	YHRTSPClient* pYHRTSPClient = GetYHRTSPClient(pRTSPClient);
	duration = pYHRTSPClient->pMediaSession->playEndTime();
	if (duration < 0) 
		duration = 0.0;

	double dwEnd = duration;
	StartPlayingSession(pRTSPClient,pYHRTSPClient->pMediaSession, 0, dwEnd, 1.0, ContinueAfterPlay);
}

void CYHMediaClient::ContinueAfterSetup(RTSPClient* pClient, int resultCode, char* resultString)
{
	Mutex mutex(g_cs);
	if (pClient == NULL)
	{
		return;
	}

	if (CYHMediaClient::GetInstance() != NULL)
	{
		if (resultCode == 0) 
		{
			YHRTSPClient *pYHClient = CYHMediaClient::GetInstance()->GetYHRTSPClient(pClient);
			pYHClient->bMadeProgress = True;
		} 
		// Set up the next subsession, if any:
		CYHMediaClient::GetInstance()->SetupStreams(pClient);
	}
}

void CYHMediaClient::ContinueAfterPlay(RTSPClient* pClient, int resultCode, char* resultString)
{
	Mutex mutex(g_cs);
	if (CYHMediaClient::GetInstance() != NULL)
	{
		if (resultCode != 0) 
		{
			*(CYHMediaClient::GetInstance()->GetEnvironment(pClient)) << "Failed to start playing session: " << resultString << "\n";
			CYHMediaClient::GetInstance()->Shutdown(pClient);
			return;
		}
		else 
		{
			*(CYHMediaClient::GetInstance()->GetEnvironment(pClient)) << "Started playing session\n";
		}
		char const* actionString ="Receiving streamed data...";
		*(CYHMediaClient::GetInstance()->GetEnvironment(pClient)) << actionString << "...\n";
	}
}

void CYHMediaClient::SubsessionAfterPlaying(void* clientData)
{
	Mutex mutex(g_cs);
	MediaSubsession* subsession = (MediaSubsession*)clientData;
	Medium::close(subsession->sink);
	subsession->sink = NULL;
}

void CYHMediaClient::SubsessionByeHandler(void* clientData)
{
	Mutex mutex(g_cs);
	MediaSubsession* subsession = (MediaSubsession*)clientData;
	if (subsession != NULL)
	{
		// Act now as if the subsession had closed:
		SubsessionAfterPlaying(subsession);
	}
}

void CYHMediaClient::ContinueAfterTearDown(RTSPClient* pClient, int resultCode, char* resultString) 
{
	/*
	Mutex mutex(g_cs);
		// Now that we've stopped any more incoming data from arriving, close our output files:
		if (CYHMediaClient::GetInstance()!= NULL)
		{
			CYHMediaClient::GetInstance()->CloseMediaSinks(pClient);
			YHRTSPClient *struClient = CYHMediaClient::GetInstance()->GetYHRTSPClient(pClient);
			if (struClient->pMediaSession)
			{
				Medium::close(struClient->pMediaSession);
			}
			// Finally, shut down our client:
			if (struClient->pAuthenticator)
			{
				delete struClient->pAuthenticator;
			}		
			Medium::close(pClient);
			struClient->m_cEventLoop = 1;
		}*/
	
}

void CYHMediaClient::CloseMediaSinks(RTSPClient *pClient)
{
	YHRTSPClient* pYHRTSPClient = GetYHRTSPClient(pClient);
	if (pYHRTSPClient->pMediaSession == NULL)
		return;
	MediaSubsessionIterator iter(*pYHRTSPClient->pMediaSession);
	MediaSubsession* subsession;
	while ((subsession = iter.next()) != NULL) 
	{
		Medium::close(subsession->sink);
		subsession->sink = NULL;
	}
}

YHRTSPClient* CYHMediaClient::GetYHRTSPClient(RTSPClient *pClient)
{
	if (m_listRTSPClient.size() == 0)
	{
		return NULL;
	}
	std::list<YHRTSPClient*>::iterator iter;
	for (iter = m_listRTSPClient.begin(); iter != m_listRTSPClient.end(); ++iter)
	{
		if (pClient == (*iter)->pClient)
		{
			return *iter;
		}
		else
			continue;
	}
	return NULL;
}

void CYHMediaClient::EraseYHRTSPClient(RTSPClient *pClient)
{
	if (m_listRTSPClient.size() == 0)
	{
		return ;
	}
	std::list<YHRTSPClient*>::iterator iter;
	for (iter = m_listRTSPClient.begin(); iter != m_listRTSPClient.end(); ++iter)
	{
		if (pClient == (*iter)->pClient)
		{
			break;
		}
		else
			continue;
	}
	m_listRTSPClient.erase(iter);
}
LONG CYHMediaClient::GetRTSPClientID(RTSPClient* pClient)
{
	std::map<int, RTSPClient*>::iterator iter = m_mapClientID.begin();
	int nClientID = -1;
	for (; iter != m_mapClientID.end(); ++iter)
	{
		if (pClient == iter->second)
		{
			nClientID = iter->first;
		}
	}
	return nClientID;
}

void CYHMediaClient::SetFileSinkAndSocket(YHRTSPClient *pYHClient,unsigned fileSinkBufferSize,unsigned socketInputBufferSize)
{
	if (NULL == pYHClient)
	{
		return;
	}
	pYHClient->fileSinkBufferSize = fileSinkBufferSize;
	pYHClient->socketInputBufferSize = socketInputBufferSize;

	return;
}