live555直播h264视频流

最新推荐文章于 2024-03-02 15:09:55 发布
最新推荐文章于 2024-03-02 15:09:55 发布
阅读量1.1k 收藏 4
点赞数 1
文章标签： live555 rtsp H264
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xushan239/article/details/79149285
版权

刚开始接触live555，在live555\testProgs中有很多很好的例子来讲解live555各方面的应用；

但是都是以文件形式给到服务器中，然后广播出来的，但是很多情况下我们是需要直播的，那就不能用文件的形式来操作了，

也试过用命名管道的方式，在linux上是可以的，但是在安卓上兼容性就不是很好了，像权限问题，以及命名管道不能在某种格式的内存中使用等，

所以本文就是描述怎样实现将已经成流的H264数据发送到网络（根据示例testH264VideoStreamer.cpp修改）。

核心部分是对类：FramedFileSource的继承；MyByteStreamFileSource

流程：

  1. 一个线程将H264数据从文件中读取出来放到缓存
  2. live555服务器不停地从缓存中获取数据
  3. live555广播出去


  1. 本地缓存需要的数据结构： 
    #include <pthread.h>
#include <semaphore.h>
#include <string.h>
#include <sys/types.h>
#include <stdlib.h>
#include <stdio.h>

#define STATIC_MEMORY

#define FRAME_MEM_SIZE	(1920*1080*2)
#define MAX_QUENE_LENGTH 10

typedef struct NODE{
	void *msg;
	unsigned int msgsize;
	struct NODE *next;
}Node_t,*pNode_t;

typedef struct{
	//depend on Linux OS
	pthread_mutex_t qlock;
	sem_t sem;
	int q_num;
	pNode_t q_head;
}Quene_t,*pQuene_t;

static Quene_t ListData;
static unsigned char availibleNode[MAX_QUENE_LENGTH]={0,0,0,0,0,0,0,0,0,0};
static Node_t nodeMemStore[MAX_QUENE_LENGTH];
static unsigned char availibleFrame[MAX_QUENE_LENGTH]={0,0,0,0,0,0,0,0,0,0};
static char frameMemStore[MAX_QUENE_LENGTH][FRAME_MEM_SIZE];

  2. 缓存申请和释放： 
    static void *mallocNode(void)
{
	unsigned char i = 0;
	for(i=0;i<MAX_QUENE_LENGTH;i++)
	{
		if(availibleNode[i] == 0)
		{
			availibleNode[i] = 1;
			return &nodeMemStore[i];
		}
	}
	return NULL;
}

static void freeNode(pNode_t node)
{
	unsigned char i = 0;
	for(i=0;i<MAX_QUENE_LENGTH;i++)
	{
		if(&nodeMemStore[i] == node)
			availibleNode[i] = 0;
	}
}

static void *mallocFrame(void)
{
	unsigned char i = 0;
	for(i=0;i<MAX_QUENE_LENGTH;i++)
	{
		if(availibleFrame[i] == 0)
		{
			availibleFrame[i] = 1;
			return &frameMemStore[i];
		}
	}
	return NULL;
}

static void freeFrame(void* frame)
{
	unsigned char i = 0;
	for(i=0;i<MAX_QUENE_LENGTH;i++)
	{
		if(&frameMemStore[i] == frame)
			availibleFrame[i] = 0;
	}
}

  3. 缓存中数据的出入： 
    static int PutData(void * msg , unsigned int * size)
{
	int ret = -1;
	dataLock();
	if(ListData.q_num < MAX_QUENE_LENGTH)
	{
#ifndef STATIC_MEMORY
		pNode_t node = malloc(sizeof(Node_t));
#else
		pNode_t node = (pNode_t)mallocNode();
#endif
		if(node == NULL)
		{
			ret = -1;
		}
		else
		{
#ifndef STATIC_MEMORY
			node->msg = malloc(*size);
#else
			node->msg = mallocFrame();
#endif
			if(node->msg == NULL)
			{
#ifndef STATIC_MEMORY
				free(node);
#else
				freeNode(node);
#endif
				ret = -1;
			}
			else
			{
				int i = ListData.q_num;
				pNode_t n = ListData.q_head;
				memcpy(node->msg,msg,*size);
				node->msgsize = *size;
				node->next = NULL;
				if(i == 0)
				{
					ListData.q_head = node;
				}
				else
				{
					while(i-1)
					{
						n = n->next;
						i--;
					}
					n->next = node;
				}
				ListData.q_num += 1;
				ret = 0;
			}
		}
	}
	dataUnlock();
	//emitDataSignal();
	return ret;
}

static int RemoveData(void)
{
	int ret = -1;
	dataLock();
	if(0 == ListData.q_num)
		ret = -1;
	else
	{
		pNode_t n = ListData.q_head;
		ListData.q_head = ListData.q_head->next;
		ListData.q_num -= 1;
#ifndef STATIC_MEMORY
		free(n->msg);
		free(n);
#else
		freeFrame(n->msg);
		n->msgsize = 0;
		freeNode(n);
#endif
		ret = 0;
	}
	dataUnlock();
	return ret;
}
static unsigned int GetData(unsigned char * framebuf , unsigned int size)
{
	unsigned int ret = 0;
	dataLock();
	if(ListData.q_num == 0)
	{
		ret = 0;
		dataUnlock();
		return ret;
	}
	else
	{
		if(size < ListData.q_head->msgsize)
		{
			dataUnlock();
			printf("error:%s line:%d %d %d\n",__func__,__LINE__,size,ListData.q_head->msgsize);
			RemoveData();
			return ret;
		}
		memcpy(framebuf,ListData.q_head->msg,ListData.q_head->msgsize);
		ret = ListData.q_head->msgsize;
		dataUnlock();
		RemoveData();
		return ret;
	}
}

  4. 初始化缓存池： 
    //depend on Linux OS
static int InitDataList(void)
{
	if(pthread_mutex_init(&ListData.qlock,NULL) != 0)
		return -1;
	memset(availibleNode,0,sizeof(availibleNode));
	memset(nodeMemStore,0,sizeof(nodeMemStore));
	memset(availibleFrame,0,sizeof(availibleFrame));
	memset(frameMemStore,0,sizeof(frameMemStore));
	return 0;
}

  5. 缓存池同步操作： 
    //depend on Linux OS
static int dataLock(void)
{
	return pthread_mutex_lock(&ListData.qlock);
}
//depend on Linux OS
static int dataUnlock(void)
{
	return pthread_mutex_unlock(&ListData.qlock);
}

  6. 获取缓存中下一个数据的大小： 
    static unsigned int GetNextFrameSize(void)
{
	unsigned int szie = 0;
	dataLock();
	if(ListData.q_num != 0)
		szie = ListData.q_head->msgsize;
	dataUnlock();
	return szie;
}

  7. live555服务器需要的资源结构： 
    #include <liveMedia.hh>
#include <BasicUsageEnvironment.hh>
#include <GroupsockHelper.hh>

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

typedef enum{
	server_idle = 0,
	server_inited,
	server_pause
}service_status_t;

typedef struct{
	service_status_t inited;
	UsageEnvironment* env;
	TaskScheduler* scheduler;

	unsigned short rtpPortNum;
	unsigned short rtcpPortNum;
	unsigned char ttl;

	Port *rtpPort;
	Port *rtcpPort;
	Groupsock *rtpGroupsock;
	Groupsock *rtcpGroupsock;
	
	H264VideoStreamFramer* videoSource;
	RTPSink* videoSink;
	RTCPInstance* rtcp;
	RTSPServer* rtspServer;
	ServerMediaSession* sms;
	PassiveServerMediaSubsession *passiveSubsession;
	MyByteStreamFileSource* fileSource;
	
	pthread_t putdata_pid;
	pthread_t loop_pid;
}LocalServer_t;

#define SIZES	2048
#define BANDWIDTH	(512)
#define MAX_CNAME_LEN	100

static const char *scrpath = "test1.h264";
static FILE* fd = NULL;
static unsigned char running = 0;
static unsigned char CNAME[MAX_CNAME_LEN+1];
static LocalServer_t SeverSetting = {
	.inited = server_idle,
	.env = NULL,
	.scheduler = NULL,

	.rtpPortNum = 0,
	.rtcpPortNum = 0,
	.ttl = 0,

	.rtpPort = NULL,
	.rtcpPort = NULL,
	.rtpGroupsock = NULL,
	.rtcpGroupsock = NULL,
	
	.videoSource = NULL,
	.videoSink = NULL,
	.rtcp = NULL,
	.rtspServer = NULL,
	.sms = NULL,
	.passiveSubsession = NULL,
	.fileSource = NULL,
	
	.putdata_pid = 0,
	.loop_pid = 0,
};

  8. live555服务器的注册和开启： 
    static int start_play(void)
{
	// Open the input file as a 'byte-stream file source':
	SeverSetting.fileSource = MyByteStreamFileSource::createNew(*SeverSetting.env, NULL);
	if(!SeverSetting.fileSource)
	{
		//*SeverSetting.env << "Unable to open file \"" << inputFileName<< "\" as a byte-stream file source\n";
		return -1;
	}
	// Create a framer for the Video Elementary Stream:
	SeverSetting.videoSource = H264VideoStreamFramer::createNew(*SeverSetting.env,(FramedSource*)SeverSetting.fileSource);
	if(!SeverSetting.videoSource)
	{
		printf("%s %d\r\n",__func__,__LINE__);
		return -1;
	}
	// Finally, start playing:
	*SeverSetting.env << "start playing..."<<__LINE__<<"\n";
	SeverSetting.videoSink->startPlaying(*SeverSetting.videoSource, NULL, NULL);
	return 0;
}

int StartRtspServer(char *url_suffix , int port)
{
	printf("%s %d[%d]\r\n",__func__,__LINE__,SeverSetting.inited);
	if(SeverSetting.inited == server_pause)
	{
		char* url = SeverSetting.rtspServer->rtspURL(SeverSetting.sms);
		*SeverSetting.env << "Play this stream using the URL \"" << url << "\"\n";
		delete[] url;
		*SeverSetting.env << "start playing..."<<__LINE__<<"\n";
		//SeverSetting.videoSink->startPlaying(*SeverSetting.videoSource, NULL, NULL);
		SeverSetting.inited = server_inited;
		return 0;
	}
	else if(SeverSetting.inited == server_inited)
		return -1;
	if(InitDataList())
	{
		printf("InitDataLock fail\n");
		return -1;
	}
	SeverSetting.scheduler = BasicTaskScheduler::createNew();
	if(!SeverSetting.scheduler)
	{
		printf("%s %d\r\n",__func__,__LINE__);
		return -1;
	}
	SeverSetting.env = BasicUsageEnvironment::createNew(*SeverSetting.scheduler);
	if(!SeverSetting.env)
	{
		printf("%s %d\r\n",__func__,__LINE__);
		return -1;
	}
	SeverSetting.rtpPortNum = 18888;
	SeverSetting.rtcpPortNum = SeverSetting.rtpPortNum+1;
	SeverSetting.ttl = 255;
	SeverSetting.rtpPort = new Port(SeverSetting.rtpPortNum);
	if(!SeverSetting.rtpPort)
	{
		printf("%s %d\r\n",__func__,__LINE__);
		return -1;
	}
	SeverSetting.rtcpPort = new Port(SeverSetting.rtcpPortNum);
	if(!SeverSetting.rtcpPort)
	{
		printf("%s %d\r\n",__func__,__LINE__);
		return -1;
	}
	struct in_addr destinationAddress;
	destinationAddress.s_addr = chooseRandomIPv4SSMAddress(*SeverSetting.env);
	SeverSetting.rtpGroupsock = new Groupsock(*SeverSetting.env,destinationAddress,
						*SeverSetting.rtpPort,SeverSetting.ttl);
	if(!SeverSetting.rtpGroupsock)
	{
		printf("%s %d\r\n",__func__,__LINE__);
		return -1;
	}
	SeverSetting.rtpGroupsock->multicastSendOnly(); // we're a SSM source
	SeverSetting.rtcpGroupsock = new Groupsock(*SeverSetting.env,destinationAddress,
						*SeverSetting.rtcpPort,SeverSetting.ttl);
	if(!SeverSetting.rtcpGroupsock)
	{
		printf("%s %d\r\n",__func__,__LINE__);
		return -1;
	}
	SeverSetting.rtcpGroupsock->multicastSendOnly(); // we're a SSM source
	// Create a 'H264 Video RTP' sink from the RTP 'groupsock':
	OutPacketBuffer::maxSize = 1024*1024;
	SeverSetting.videoSink = H264VideoRTPSink::createNew(*SeverSetting.env,
												SeverSetting.rtpGroupsock,96);
	if(!SeverSetting.videoSink)
	{
		printf("%s %d\r\n",__func__,__LINE__);
		return -1;
	}
	// Create (and start) a 'RTCP instance' for this RTP sink:
	memset(CNAME,0,MAX_CNAME_LEN);
	gethostname((char*)CNAME, MAX_CNAME_LEN);
	CNAME[MAX_CNAME_LEN] = '\0'; // just in case
	SeverSetting.rtcp = RTCPInstance::createNew(*SeverSetting.env,SeverSetting.rtcpGroupsock,
							BANDWIDTH,// in kbps; for RTCP b/w share
							CNAME,
							SeverSetting.videoSink, NULL /* we're a server */,
							True /* we're a SSM source */);
	if(!SeverSetting.rtcp)
	{
		printf("%s %d\r\n",__func__,__LINE__);
		return -1;
	}
	SeverSetting.rtspServer = RTSPServer::createNew(*SeverSetting.env, port);
	if(SeverSetting.rtspServer == NULL)
	{
		*SeverSetting.env << "Failed to create RTSP server: " << SeverSetting.env->getResultMsg() << "\n";
		return -1;
	}
	SeverSetting.sms = ServerMediaSession::createNew(*SeverSetting.env,url_suffix,NULL,
							"Session streamed by \"testH264VideoStreamer\"",True);
	if(!SeverSetting.sms)
	{
		printf("%s %d\r\n",__func__,__LINE__);
		return -1;
	}
	SeverSetting.passiveSubsession = PassiveServerMediaSubsession::createNew(*SeverSetting.videoSink,SeverSetting.rtcp);
	if(!SeverSetting.passiveSubsession)
	{
		printf("%s %d\r\n",__func__,__LINE__);
		return -1;
	}
	SeverSetting.sms->addSubsession(SeverSetting.passiveSubsession);
	SeverSetting.rtspServer->addServerMediaSession(SeverSetting.sms);
	char* url = SeverSetting.rtspServer->rtspURL(SeverSetting.sms);
	*SeverSetting.env << "Play this stream using the URL \"" << url << "\"\n";
	delete[] url;
	// Start the streaming:
	*SeverSetting.env << "Beginning streaming...\n";
	if(start_play())
	{
		printf("%s %d\r\n",__func__,__LINE__);
		return -1;
	}
	run_tasks();
	SeverSetting.inited = server_inited;
	return 0;
}

  9. 读取数据放到缓存中： 
    int InsertFrame(char * buf ,int len)
{
	if(SeverSetting.inited == server_inited)
		return PutData((void *)buf, (unsigned int*)&len);
	else
		return -1;
}

static void* receive_thread(void* param)
{
	unsigned int len = 0;
	unsigned char buf[FRAME_MEM_SIZE];
	printf("%s %d\r\n",__func__,__LINE__);
	fd = fopen(scrpath,"rb");
	if(fd)
		printf("open ok\n");
	else
	{
		printf("open \"%s\" fail\n",scrpath);
		_exit(1);
	}
	printf("%s %d\n",__func__,__LINE__);
	running = 1;
	while(running)
	{
		if((len=fread(buf,1,SIZES,fd))>0)
		{
f_try:
			if(InsertFrame((char*)buf,(int)len) < 0)
			{
				usleep(100000);
				goto f_try;
			}
		}
		if(len < SIZES || len == 0)
			fseek(fd,0,SEEK_SET);
	}
	fclose(fd);
	printf("%s %d\n",__func__,__LINE__);
	pthread_exit(NULL);
	return NULL;
}

static void* loop_thread(void* param)
{
	printf("task schedule start...[%d]\n",__LINE__);
	SeverSetting.env->taskScheduler().doEventLoop();
	printf("task schedule start...[%d]\n",__LINE__);
	pthread_exit(NULL);
	return NULL;
}

static void run_tasks(void)
{
	pthread_create(&SeverSetting.putdata_pid,NULL,receive_thread,NULL);
	pthread_detach(SeverSetting.putdata_pid);
	pthread_create(&SeverSetting.loop_pid,NULL,loop_thread,NULL);
	pthread_detach(SeverSetting.loop_pid);
}

  10. 停止服务器： 
    void StopRtspServer(void)
{
	printf("%s relese\n",__func__);
	if(SeverSetting.inited == server_inited)
		SeverSetting.inited = server_pause;
	//SeverSetting.videoSink->stopPlaying();
	//Medium::close(SeverSetting.videoSource);	
	printf("%s relese all\n",__func__);
}

  11.  主函数入口： 
    int main(int argc , char *argv[])
{
	StartRtspServer((char*)"xxx",8554);
	while(1)
	{
		sleep(10);
	}
	return 0;
}

  12. 主要部分：对FramedFileSource的继承 
    class MyByteStreamFileSource: public FramedFileSource {
public:
	static MyByteStreamFileSource* createNew(UsageEnvironment& env,
										char const* fileName,
										unsigned preferredFrameSize = 0,
										unsigned playTimePerFrame = 0)
	{
		MyByteStreamFileSource* newSource
				= new MyByteStreamFileSource(env, 0, preferredFrameSize, playTimePerFrame);
		newSource->fFileSize = 0;//GetFileSize(fileName, fid);
		printf(">fFileSize %d<:%llu\n",__LINE__,newSource->fFileSize);
		return newSource;
	}
	u_int64_t fileSize() const { return fFileSize; }
      // 0 means zero-length, unbounded, or unknown

	void seekToByteAbsolute(u_int64_t byteNumber, u_int64_t numBytesToStream = 0)
	{
		printf("%s %d\n",__func__,__LINE__);
		fNumBytesToStream = numBytesToStream;
		fLimitNumBytesToStream = fNumBytesToStream > 0;
	}
    // if "numBytesToStream" is >0, then we limit the stream to that number of bytes, before treating it as EOF
	void seekToByteRelative(int64_t offset, u_int64_t numBytesToStream = 0)
	{
		printf("%s %d\n",__func__,__LINE__);
		fNumBytesToStream = numBytesToStream;
		fLimitNumBytesToStream = fNumBytesToStream > 0;
	}
	void seekToEnd()// to force EOF handling on the next read
	{
		printf("%s %d\n",__func__,__LINE__);
	}

protected:
	MyByteStreamFileSource(UsageEnvironment& env, FILE* fid,
					   unsigned preferredFrameSize,
					   unsigned playTimePerFrame)
  : FramedFileSource(env, fid), fFileSize(0), fPreferredFrameSize(preferredFrameSize),
    fPlayTimePerFrame(playTimePerFrame), fLastPlayTime(0),
    fHaveStartedReading(False), fLimitNumBytesToStream(False), fNumBytesToStream(0)
	{
		printf(">%d<\n",__LINE__);
		overFlowNum = 0;
		overFlowIndex = 0;
		// Test whether the file is seekable
		fFidIsSeekable = 0;
		printf(">fFidIsSeekable %d<:%d\n",__LINE__,fFidIsSeekable);
	}
	
	virtual ~MyByteStreamFileSource()
	{
		if (fFid == NULL)
			return;
		CloseInputFile(fFid);
	}

	static void fileReadableHandler(void* source)
	{
		MyByteStreamFileSource* pThis = (MyByteStreamFileSource*)source;
		if (!pThis->isCurrentlyAwaitingData())
		{
			pThis->doStopGettingFrames(); // we're not ready for the data yet
			return;
		}
		pThis->doReadFromFile();
	}

	void doReadFromFile()
	{
		//printf("%s %d\n",__func__,__LINE__);
		// Try to read as many bytes as will fit in the buffer provided (or "fPreferredFrameSize" if less)
		if (fLimitNumBytesToStream && fNumBytesToStream < (u_int64_t)fMaxSize)
		{
			printf("fNumBytesToStream:%llu fMaxSize:%u fPreferredFrameSize:%u\n",
						fNumBytesToStream,fMaxSize,fPreferredFrameSize);
			fMaxSize = (unsigned)fNumBytesToStream;
		}
		if (fPreferredFrameSize > 0 && fPreferredFrameSize < fMaxSize)
		{
			printf("fPreferredFrameSize:%llu fMaxSize:%u fPreferredFrameSize:%u\n",
						fNumBytesToStream,fMaxSize,fPreferredFrameSize);
			fMaxSize = fPreferredFrameSize;
		}
f_again:
		if(overFlowNum)
		{
			if(overFlowNum - overFlowIndex > fMaxSize)
			{
				memcpy(fTo,&overFlow[overFlowIndex],fMaxSize);
				fFrameSize = fMaxSize;
				overFlowIndex += fFrameSize;
				printf("%s %d>\n",__func__,__LINE__);
			}
			else
			{
				memcpy(fTo,&overFlow[overFlowIndex],overFlowNum - overFlowIndex);
				fFrameSize = overFlowNum - overFlowIndex;
				overFlowIndex += fFrameSize;
				printf("%s %d<\n",__func__,__LINE__);
			}
			if(overFlowNum == overFlowIndex)
			{
				overFlowNum = 0;
				overFlowIndex = 0;
				printf("%s %d reset\n",__func__,__LINE__);
			}
		}
		else if(overFlowNum == 0 && GetNextFrameSize() > fMaxSize)
		{
			if((overFlowNum=GetData(overFlow,FRAME_MEM_SIZE)) > 0)
			{
				printf("%s %d max\n",__func__,__LINE__);
				memcpy(fTo,overFlow,fMaxSize);
				fFrameSize = fMaxSize;
				overFlowIndex = fMaxSize;
				if(overFlowNum == overFlowIndex)
				{
					overFlowNum = 0;
					overFlowIndex = 0;
				}
			}
			else
			{
				printf("%s sleep %d\n",__func__,__LINE__);
				usleep(50000);
				goto f_again;
			}
		}
		else if((fFrameSize = GetData(fTo,fMaxSize)) == 0)
		{
			printf("%s no src data %d\n",__func__,__LINE__);
			usleep(50000);
			goto f_again;
		}
		if (fFrameSize == 0)
		{
			handleClosure();
			return;
		}
		fNumBytesToStream -= fFrameSize;
	
		// Set the 'presentation time':
		if (fPlayTimePerFrame > 0 && fPreferredFrameSize > 0)
		{
			if (fPresentationTime.tv_sec == 0 && fPresentationTime.tv_usec == 0)
			{
				// This is the first frame, so use the current time:
				gettimeofday(&fPresentationTime, NULL);
			}
			else
			{
				// Increment by the play time of the previous data:
				unsigned uSeconds	= fPresentationTime.tv_usec + fLastPlayTime;
				fPresentationTime.tv_sec += uSeconds/1000000;
				fPresentationTime.tv_usec = uSeconds%1000000;
			}
			// Remember the play time of this data:
			fLastPlayTime = (fPlayTimePerFrame*fFrameSize)/fPreferredFrameSize;
			fDurationInMicroseconds = fLastPlayTime;
		}
		else
		{
			// We don't know a specific play time duration for this data,
			// so just record the current time as being the 'presentation time':
			gettimeofday(&fPresentationTime, NULL);
		}
	
		// Because the file read was done from the event loop, we can call the
		// 'after getting' function directly, without risk of infinite recursion:
		FramedSource::afterGetting(this);
	}

private:
	// redefined virtual functions:
	virtual void doGetNextFrame()
	{
		//printf("%s %d\n",__func__,__LINE__);
		envir().taskScheduler().scheduleDelayedTask(0,fileReadableHandler, this);
	}
	virtual void doStopGettingFrames()
	{
		//printf("%s %d\n",__func__,__LINE__);
		envir().taskScheduler().unscheduleDelayedTask(nextTask());
	}

protected:
	u_int64_t fFileSize;
	u_int64_t overFlowNum;
	u_int64_t overFlowIndex;
	unsigned char overFlow[FRAME_MEM_SIZE];

private:
	unsigned fPreferredFrameSize;
	unsigned fPlayTimePerFrame;
	Boolean fFidIsSeekable;
	unsigned fLastPlayTime;
	Boolean fHaveStartedReading;
	Boolean fLimitNumBytesToStream;
	u_int64_t fNumBytesToStream; // used iff "fLimitNumBytesToStream" is True
};

值得注意的是：在类MyByteStreamFileSource中doReadFromFile的时候，往数据区fTo中拷贝数据的时候，当前一帧数据可能会超过fMaxSize的大小，如果往fTo中考入数据超过fMaxSize的大小会导致live555报错，所以我们在这里采取一个中间缓存，当fMaxSize的大小小于下一帧的大小的时候，将下一帧的数据先考到中间缓存中，再从中间缓存中拷贝fMaxSize大小的数据到fTo中，下次再将缓存中的其他数据放入到fTo中；

此处有源码下载：http://download.csdn.net/download/xushan239/10221824

xushan239
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
live555读文件改为内存读取实现
像梦一样自由
10-15 5625
live555视频直播
一个支持读取H264视频流（.264）的Source Filter
03-01
Directshow source filter，读取H264编码的裸流，一般文件后缀为.h264，.264，把读取到的帧传给下一级Filter
live555实现共享内存视频直播
xdshengk的博客
07-20 4389
在上节的基于FIFO传输的例子上修改，实现了基于共享内存的rtsp传输， 结构体share_mem保存接收到的数据长度和数据，在init函数里实现了信号量和共享内存的初始化 SendH264File不再调用SendH264Data，直接把数据和长度写进共享内存。 /****************************************************************
live555源码学习（1）
最新发布
langzi113的专栏
03-02 1005
网络接口的封装，用于数据包的接收和发送，同时支持多播和单播。当有新的数据连接请求时，GenericMediaServer::incomingConnectionHandler()被调用。MultiFramedRTPSink中的帧数据和包缓冲区共用一个，只是用一些额外的变量指明缓冲区中属于包的部分以及属于帧数据的部分（包以外的数据叫做overflow data）。main函数创建任务调度器，创建RTSPServer实例，将它的socket置于调度器的监听下，最后运行调度器，处理socket事件。
live555读文件改为读内存
qq_35151989的博客
08-25 914
live555读文件改为读内存 近期有一项工作涉及到视频流的传输，在RTSP服务器中实时转播国标服务器获取到的h264视频数据，而live555库只支持文件推流，经过几天的摸索，实现其功能，以此文档记录之。（本次记录以live555库的mediaServer案例程序为基础） live555版本为 这里 的2019.6.28版本 安装指令： 1、./genMakefiles linux (linux...
live555学习-FramedSource详解
zhangjikuan的专栏
08-14 5200
FramedSource讲解 FramedSource是一个抽象类，继承自mediaSource
live555源代码简介
嵌入式相关
03-11 2446
live555源代码简介liveMedia项目的源代码包括四个基本的库，各种测试代码以及IVE555 Media Server。四个基本的库分别是UsageEnvironment&TaskScheduler，groupsock，liveMedia，BasicUsageEnvironment。UsageEnvironment和TaskScheduler类用于事件的调度，实现异步读取事件的句柄的设
修改live555支持从缓冲区读取h264帧 (纠正下是 h264 slice)
Canok
01-28 4014
==2023.1.1 追加，归纳总结一下，作为复习的提要： ​​​​​​​ 实现新的MediaSubsession，覆盖实现其中的虚函数createNewStreamSource() ,用来创建source . 覆盖 实现 其中的虚函数createNewRTPSink() 用来创建sink 实现自己的 FrameSource, 实现其中的虚函数 doGetNextFrame(),在这个里面把自己的h264数据拷贝到 fTo 缓冲区，并且赋值成员变量fFrameSize 、时间戳、最大帧数据大小等等
通过live555直播H264的rtsp视频流
01-24
下载的最新live555源码裁剪修改后的软件，可直接编译运行
Windows下利用live555实现H264H265实时流RTSP发送
02-24
Windows下利用live555实现H264H265实时流RTSP发送,利用本地文件读入模拟，环境为VS2010。这是对大神代码的整理，可以直接编译运行。源于https://blog.csdn.net/weixinhum/article/details/38067743#comments 环境从...
live555通过读取内存发送h264视频
07-15
本资源是通过live555读取内存发送h264视频，源码本人亲自测试通过，但是使用时需要自己整理。
Linux基于Live555从共享内存 获取rstp实时H264视频流并转发
01-03
rtsp_server 为工程主目录 livelib 为live555 库目录 RtspServer.cpp 为主程序 H264LiveVideoServerMediaSubsession.cpp H264LiveVideoSource.cpp 为创建对话和获取帧类 其他为平台获取帧代码和库
live555 rtsp+x264模拟实时编码推流
12-19
live555 rtsp+x264模拟实时编码推流
live555传输实时h264视频流和mp3音频流
风斜夜的博客
10-09 4266
主要是利用live555的rtsp服务器发送实时视频和音频流，并扩大视频buffer的容量来防止视频帧较大时出现数据丢失的问题。 h264的实时视频流 live555的h264视频流是参考https://blog.csdn.net/caoshangpa/article/details/53200527 主要是创建服务器的时候 sms->addSubsession(H264VideoFi...
live555源码分析----H264的数据处理
热门推荐
gavin的专栏
12-05 2万+
现在来分析live555中关于H264的处理部分，主要包括从文件中读取数据进行并进行frame(NALU)的分割，然后对frame进行分片，这些工作都是在frame交给RTP sink之前完成的。接着上篇分析文章(RTP的打包与发送)中提到的MultiFramedRTP::packFrame函数进行分析。 void MultiFramedRTPSink::packFrame() { if (
使用live555制作rtsp客户端，捕获h264等解码
qianbo042311的博客
03-03 2091
rtsp客户端，捕获编码后解码
Web端专业级H264/H265 直播流播放器实现-JessibucaPro播放器
11-30 1691
这个主要是参加“深圳 liveVideoStack” 的ppt的文字版的分享。题目是：Web端专业级H264/H265 直播流播放器实现-JessibucaPro播放器
live555 android 直播,通过live555实现H264 RTSP直播
weixin_32184991的博客
05-28 628
前面的文章中介绍了《H264视频通过RTMP流直播》，下面将介绍一下如何将H264实时视频通过RTSP直播。实现思路是将视频流发送给live555, 由live555来实现H264数据流直播。视频采集模块通过FIFO队列将H264数据帧发送给live555. live555 在收到客户端的RTSP播放请求后，开始从FIFO中读取H264视频数据并通过RTSP直播出去。整个流程如下图所示：调整和修改...
Live555 直播性能优化
wqwqh的博客
11-20 2189
优化1：同步读取数据源修改为异步读取数据源， FramedSource的子类的doGetNextFrame函数中不要阻塞等待数据源， 在无数据时可以重新增加一个定时器任务，延时再读取数据。在无数据时增加一个等待任务： voidMyFramedSource::doGetNextFrame() { if(无数据可读){//延时3000微妙（3毫秒)再次读取数据 envir().taskScheduler().scheduleDelayedTask(3000,(TaskFunc*)Dela...
wpf vlc推送h264视频流
06-11
可以使用VLC控件在WPF中播放视频流，VLC支持直接解码H264视频流，以下是一个简单的示例代码： 首先，需要安装VLC控件，可以在NuGet中...如果视频流使用的是RTSP协议，需要安装`Live555`库和`Vlc.DotNet.Live555`包。

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值