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

最新推荐文章于 2021-08-06 09:48:45 发布
最新推荐文章于 2021-08-06 09:48:45 发布
阅读量3.8k 收藏 7
点赞数
分类专栏： 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;
}


 


  

                

        

        

    




    

      

        

            

              
                
                  smilestone322
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    7
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  2
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
TS流封装（live555+faac）.rar

				
			

			

				

					08-29
				

			

		

		

			
				
使用live555的testRTSPClient来进行网络实时流获取，采用H264+AAC文件方式封装ts流文件。

			
		

	



                

              
                



	

		

			

				
					
Linux基于Live555从共享内存 获取rstp实时H264视频流并转发 附源码

					
热门推荐

				
			

			

				

					xwu122930的博客
				

				

					01-03
					
					1万+
					
				

			

		

		

			
				
1、编译生成库

从官网上下载，下载地址：http://www.live555.com/liveMedia/public/，选择live555-latest.tar.gz下载

下载的为2017.10.28版

解压：tar xzf live555-latest.tar.gz

修改权限: chmod+777 live -R

修改交叉编译工具:cp config.armlinux cpco...

			
		

	



                


  
              

                


	

		

			

				
					
live555学习笔记8

				
			

			

				

					wodamazi
				

				

					11-02
					
					405
					
				

			

		

		

			
				
八 RTSPClient分析
有RTSPServer，当然就要有RTSPClient。
如果按照Server端的架构，想一下Client端各部分的组成可能是这样：
因为要连接RTSP server，所以RTSPClient要有TCP socket。当获取到server端的DESCRIBE后，应建立一个对应于ServerMediaSession的ClientMediaSession。对应每个T...

			
		

	





	

		

			

				
					
live555中rtsp客户端对于buffer的处理方法介绍

				
			

			

				

					grr101的专栏
				

				

					03-14
					
					3078
					
				

			

		

		

			
				
A. Buffer 管理 How to control the burst input packet is a 
big topic. The leak bucker model may be useful, however, if a long burst
 of higher-rate packets arrives (in our system), the bucket will 
overflow and our control function will take actions again

			
		

	



		

			
		



	

		

			

				
					
live555代码分析

				
			

			

				

					NBA_1的博客
				

				

					10-31
					
					706
					
				

			

		

		

			
				
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wellima/article/details/77978716
Live555
Live555是一个跨平台的C++开源项目，为流媒体提供解决方案，实现了RTP/RTCP、RTSP、SIP等标准流媒体传输协议。
Live555实现了音视频数...

			
		

	





	

		

			

				
					
live555的rtsp服务器demo功能简单验证

				
			

			

				

					achina2011jy的博客
				

				

					07-15
					
					1772
					
				

			

		

		

			
				
综述：Live555是一款在安防领域非常出名的推流框架，既可以作为rtsp的服务器，也可以作为客户端，这次先使用其作为推流服务器尝下鲜，我的本地环境：Ubuntu14.04；
一、	环境搭建篇：
Live555官网：http://www.live555.com/
GitHub上源码位置：https://github.com/rgaufman/live555
官网测试码流：http://www.li...

			
		

	





	

		

			

				
					
live555服务器性能,Live555 分析（二）：服务端

				
			

			

				

					weixin_31869579的博客
				

				

					08-06
					
					1030
					
				

			

		

		

			
				
live555支持单播和组播，我们先分析单播的流媒体服务端，后面分析组播的流媒体服务端。一、单播的流媒体服务端：// Create the RTSP server:RTSPServer* rtspServer = NULL;// Normal case: Streaming from a built-in RTSP server:rtspServer = RTSPServer::createNew...

			
		

	





	

		

			

				
					
live555 rtsp封装demo

				
			

			

				

					01-30
				

			

		

		

			
				
live555 rtspclient live555 rtspclientlive555 rtspclientlive555 rtspclientlive555 rtspclientlive555 rtspclient

			
		

	





	

		

			

				
					
基于live555封装的RTSPClient

				
			

			

				

					02-28
				

			

		

		

			
				
基于live555封装的rtspClient, 解决了默认live555 rtspClient demo 掉线问题，支持网络断线重连，支持多摄像机接入。文件包括播放demo及封装的Lib，包括rtspClient的封装实现源码。

			
		

	





	

		

			

				
					
Live555 类层次图

				
			

			

				

					01-04
				

			

		

		

			
				
Live555 类层次图，包括了live555关键类的关系和继承关系图，想深入了解live555框架小伙伴，应该很有帮助的。

			
		

	





	

		

			

				
					
基于live555的rtsp客户端模块

				
			

			

				

					10-14
				

			

		

		

			
				
基于live555  testRtspClient.cpp 改造， 已经封装成 dll 模块，提供了视频帧回调接口.

live555 需要编译成静态库， 请自行编译，网上很多例子，比较简单

			
		

	





	

		

			

				
					
Linux基于Live555 实现 从网络摄像机获取实时视频流 源码

				
			

			

				

					12-13
				

			

		

		

			
				
DynamicRTSPServer.cpp live555MediaServer.cpp为mediaServer 中文件修改
H264LiveVideoServerMediaSubsession.cpp 
H264LiveVideoSource.cpp为创建对话和获取帧类 
其他为平台获取帧代码和库

			
		

	





	

		

			

				
					
运用live555编译后的库实现demo调用例子

				
			

			

				

					09-18
				

			

		

		

			
				
之前上传了一个编译好的库文件，这个是调用库的demo，一个简单的搭建rtsp服务器

			
		

	





	

		

			

				
					
Live555 源代码分析  之 mediaServer RTSP服务器  pdf 详解 作者灯下野狐

				
			

			

				

					11-09
				

			

		

		

			
				
Live555 源代码分析  之 mediaServer RTSP服务器  作者：灯下野狐        有幸下载到资源，共享给大家。    因为我之前下载好多源码解释 资源分最多达15分都被坑。 这把力荐。

			
		

	





	

		

			

				
					
Linux基于Live555从共享内存 获取rstp实时H264视频流并转发

				
			

			

				

					01-03
				

			

		

		

			
				
rtsp_server 为工程主目录 livelib 为live555 库目录 RtspServer.cpp 为主程序 H264LiveVideoServerMediaSubsession.cpp H264LiveVideoSource.cpp 为创建对话和获取帧类 其他为平台获取帧代码和库

			
		

	





	

		

			

				
					
Python课程设计 课设 手写数字识别卷积神经网络源码+文档说明.zip

				
			

			

				

					04-24
				

			

		

		

			
				
高分设计源码，详情请查看资源内容中使用说明
高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明

			
		

	





	

		

			

				
					
SpringBoot2.0快速开发框架权限.rar

				
			

			

				

					04-24
				

			

		

		

			
				
SpringBoot2.0快速开发框架权限.rarSpringBoot2.0快速开发框架权限.rarSpringBoot2.0快速开发框架权限.rar

			
		

	





	

		

			

				
					
大语言模型的微调和推理baichuan7B, chatglm2-6B, Qwen-7B-chat源码.zip

					
最新发布

				
			

			

				

					04-24
				

			

		

		

			
				
详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；

			
		

	





	

		

			

				
					
基于Qt与STM32平台开发的汽车车机系统上位机

				
			

			

				

					04-24
				

			

		

		

			
				
基于Qt开发的汽车车机系统上位机 & 常见类型汽车传感器信号模拟发生器
任务和要求：
任务：
根据发动机测控系统信号需求，设计一套发动机信号模拟器人机交互系统，能够根据需要向下位机输出控制信号，使其输出发动机测控系统需要的传感器模拟信号，给发动机测控系统的开发提供方便。
要求：
1.设计应包含上位机与下位机的交互程序及人机交互界面的设计，与下位机设计相结合，使其能够实现全部类型发动机传感器信号的模拟输出及显示。
2.设计中需要采用模块化开发程序。
3.所设计的人机交互界面简洁合理。
4.应考虑所设计系统的实用性。
具体工作内容:
1.根据设计目标，查阅相关设计标准和设计方法资料，对发动机信号模拟器设计中的关键工程原理和工程方法进行提炼，并围绕关键问题进行国内外设计现状调研，开展分析、评价与总结，确定主要研究内容，制定设计技术路线，制定设计计划(周进度)，撰写开题报告，并进行开题答辩，开题报告参考文献应不少于15篇(其中外文文献不少于 4 篇，近五年文献不少于三分之一)。
2.根据设计要求和技术指标，进行满足功能原理需求的多方案拟定，考虑安全、 标准等多因素进行技术性与经济性评价

			
		

	





	

		

			

				
					
live555 qt

				
			

			

				

					11-30
				

			

		

		

			
				
Live555是一个开源的C++多媒体库，它提供了一些用于流媒体的开源C++对象类库，包括RTSP / RTP客户端和服务器，RTSP / HTTP转换器，音频和视频编解码器，以及各种滤镜。Qt Creator是一个跨平台的集成开发环境，用于开发C++应用程序。下面是如何在Qt Creator中使用Live555库的步骤：

1.按照Live555官方文档说明进行安装，并将Live555库的路径添加到Qt Creator的项目配置文件中。

2.创建一个Qt控制台应用程序。在Qt Creator中创建一个空的控制台应用程序，并在项目的.pro文件中添加Live555库的链接选项，例如：

```shell
LIBS += -LLive555库的路径 -lliveMedia -lgroupsock -lUsageEnvironment -lBasicUsageEnvironment
```

3.在代码中使用Live555库。在Qt Creator中创建一个新的源文件，并在其中包含Live555库的头文件。然后，您可以使用Live555库中的类和函数来实现您的应用程序。

下面是一个使用Live555库的简单示例：

```c++
#include <liveMedia.hh>
#include <BasicUsageEnvironment.hh>

int main(int argc, char** argv) {
    TaskScheduler* scheduler = BasicTaskScheduler::createNew();
    UsageEnvironment* env = BasicUsageEnvironment::createNew(*scheduler);

    RTSPClient* rtspClient = RTSPClient::createNew(*env, "rtsp://example.com/media.mp4");
    if (rtspClient == NULL) {
        *env << "Failed to create RTSP client\n";
        return 1;
    }

    // Do something with the RTSP client...
    Medium::close(rtspClient);
    env->reclaim();
    delete scheduler;
    return 0;
}
```



			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		
评论 2

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值