IOMultiplex (一)- select/epoll

最新推荐文章于 2022-05-04 19:27:54 发布
最新推荐文章于 2022-05-04 19:27:54 发布
阅读量1.4k 收藏
点赞数
分类专栏： 技术文章 朱韦刚的流媒体技术专栏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhuweigangzwg/article/details/40372761
版权

IOMultiplex (一)- select/epoll

一：epoll和select区别

1.select的句柄数目受限，在linux/posix_types.h头文件有这样的声明：#define__FD_SETSIZE    1024  表示select最多同时监听1024个fd。而epoll没有，它的限制是最大的打开文件句柄数目。

2.epoll的最大好处是不会随着FD的数目增长而降低效率，在selec中采用轮询处理，其中的数据结构类似一个数组的数据结构，而epoll是维护一个队列，直接看队列是不是空就可以了。epoll只会对"活跃"的socket进行操作---这是因为在内核实现中epoll是根据每个fd上面的callback函数实现的。那么，只有"活跃"的socket才会主动的去调用 callback函数（把这个句柄加入队列），其他idle状态句柄则不会，在这点上，epoll实现了一个"伪"AIO。但是如果绝大部分的I/O都是“活跃的”，每个I/O端口使用率很高的话，epoll效率不一定比select高（可能是要维护队列复杂）。

3.使用mmap加速内核与用户空间的消息传递。无论是select,poll还是epoll都需要内核把FD消息通知给用户空间，如何避免不必要的内存拷贝就很重要，在这点上，epoll是通过内核于用户空间mmap同一块内存实现的。

4.epoll是linux 专属，windows没有，select是windows和linux都有的，windows还有个完成端口这里不讨论。

5.select是轮询fd,而epoll是轮询event。

6.select是水平触发，epoll分为水平触发和select一样(默认，EPOLLLT)，边缘触发方式(EPOLLET)。(例如：同时有5个client连接listen socket EPOLLLT会提醒5次。EPOLLET 会提醒1次，要循环做recv才能直到errno == EAGAIN才完成。)

二：程序示例

#ifdef WIN32
#define IP         "127.0.0.1"
//#define IP         "192.168.8.173"
#else
#define IP         "0.0.0.0"
//#define IP         "192.168.8.15"
#endif
#define PORT       6000
#define DLEVEL     0

int main(int argc, char ** argv)
{
	int ret = 0;
	int socket = -1;
	int newsocket = -1;
	char buf[100] = "zwg";
	int bufsize = 100;
	int sendsize = 0;
	int recvsize = 0;

#if DLEVEL == 0
//tcp server
	printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Tcp Server <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
	ITcpInterface * ntcp = new CTcp();
	ISocketInterface * pSocket = (ISocketInterface*)ntcp->GetSocketInterface();
	socket = pSocket->Create(IP,PORT,SOCK_STREAM);

	ret = ntcp->Listen(socket);
	if (ret < 0)
	{
		printf("socket listen error \n");
		pSocket->Close(socket);
	}

	printf(">>>>>>>>>>>>>>> Local IP ：%s PROT : %d <<<<<<<<<<<<<<<<\n", pSocket->GetLocalIp(socket),pSocket->GetLocalPort(socket));

	pSocket->InitIOMultiplex(socket);
	pSocket->AddIOMultiplex(socket);
	for (;;)
	{
		ret = pSocket->UseIOMultiplex(TIMEOUT);
		if (ret == STATE_ERROR)
		{
			break;
		}
		else if (ret == STATE_TIMEOUT)
		{
			continue;
		}
		else if (ret >= STATE_READY)
		{
			for (int i = 0 ; i < ret ; i++)
			{
				//如果是新用户连接
				if (pSocket->IsNewConnect(socket,i))
				{
					newsocket = ntcp->Accept(socket);
					pSocket->AddIOMultiplex(newsocket);
					pSocket->DestoryReadEvent(i);
					pSocket->DestoryWriteEvent(i);
					printf(">>>>>>>>>>>>>>> new connect IP ：%s PROT : %d <<<<<<<<<<<<<<<<\n", ntcp->GetConnetIp(newsocket),ntcp->GetConnetPort(newsocket));
					continue; 
				}
				//如果是读事件
				if(pSocket->IsReadEvent(i)) 
				{  
					memset(buf,0,100);
					recvsize =  ntcp->Recv(buf,bufsize,pSocket->GetFdListOrEvents(i));
					//如果不是用户断开连接
					if(!pSocket->IsCloseEvent(i,recvsize)) 
					{
						printf("recv size = %d : %s\n",recvsize,buf);
						pSocket->DestoryReadEvent(i);
						//如果是可写事件 如果协议栈中没有满则一直可写,不是有写事件
						if (pSocket->IsWriteEvent(i))
						{
							sendsize =  ntcp->Send("zwg",bufsize,pSocket->GetFdListOrEvents(i));
							printf("send size = %d : %s\n",sendsize,buf);
							pSocket->DestoryWriteEvent(i);
							continue;
						}
					}
					else
					{
						printf(">>>>>>>>>>>>>>> connect close IP ：%s PROT : %d <<<<<<<<<<<<<<<<\n", ntcp->GetConnetIp(pSocket->GetFdListOrEvents(i)),ntcp->GetConnetPort(pSocket->GetFdListOrEvents(i)));
						pSocket->Close(pSocket->GetFdListOrEvents(i));
					}
					continue;
				}
				else
				{
					continue;
				}
			}
		}
		else
		{
			continue;
		}
	}
	pSocket->UinitIOMultiplex();
	pSocket->Close(socket);
	if (ntcp)
	{
		delete ntcp;
		ntcp = NULL;
	}
#endif
	printf("\npress any key to quit....");
	return getchar();
</pre><p>二：具体实现</p><p><strong><span style="color:#ff0000">//zsocket.h</span></strong></p><p></p><pre name="code" class="cpp">/*
* Copyright (c/c++) <2014.09.17> <zwg>
* Function  The Socket operation tcp && udp server && client && socketpair for process
*/
#ifndef __ZSOCKET__H__
#define __ZSOCKET__H__

#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <string.h>

#ifdef WIN32
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")                  //添加SOCKET库
#pragma warning(disable : 4786)                     //禁止显示4786警告
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/epoll.h>  
#endif

using namespace std;

//选择返回SOCKET当前状态类型
#define STATE_READY   1
#define STATE_ERROR   -1
#define STATE_TIMEOUT 0
//And how to "read" and "write" and " A new connection" at the same time happen
#define MAX_EVENT_NUM 1024 
#define MAX_FD_NUM    1024
//socket 超时时间    //3s
#define TIMEOUT       3

#ifdef WIN32
typedef int socklen_t;
#else
#endif

//Common interface
struct ISocketInterface
{ 
	virtual ~ISocketInterface(){};
	virtual int Create(char * ip = "", int port = 0,int sock_type = SOCK_STREAM) = 0;  
	virtual void Close(int socket) = 0; 
	virtual int InitIOMultiplex(int socket) = 0;
	virtual int UinitIOMultiplex() = 0;
	virtual int AddIOMultiplex(int socket,int epoll_modo = 0) = 0;
	virtual int UseIOMultiplex(int timeout) = 0;
	virtual int IsNewConnect(int socket,int eventlabel) = 0;
	virtual int IsReadEvent(int label) = 0;
	virtual int IsWriteEvent(int label) = 0;
	virtual void DestoryReadEvent(int label) = 0;
	virtual void DestoryWriteEvent(int label) = 0;
	virtual int IsCloseEvent(int label,int recvsize) = 0;
	virtual int GetFdListOrEvents(int label) = 0;
	virtual char * GetLocalIp(int socket) = 0;
	virtual int GetLocalPort(int socket) = 0;
};

class CSocket : public ISocketInterface
{
public:
	CSocket();
	virtual ~CSocket();
	int Create(char * ip = "", int port = 0,int sock_type = SOCK_STREAM);  
	void Close(int socket); 
	int InitIOMultiplex(int socket);
	int UinitIOMultiplex();
	int AddIOMultiplex(int socket,int epoll_modo = 0);
	int UseIOMultiplex(int timeout); 
	int IsNewConnect(int socket,int eventlabel);
	int IsReadEvent(int label);
	int IsWriteEvent(int label);
	void DestoryReadEvent(int label);
	void DestoryWriteEvent(int label);
	int IsCloseEvent(int label,int recvsize);
	int GetFdListOrEvents(int label);
	char * GetLocalIp(int socket);
    int GetLocalPort(int socket);
protected:
	//init socket lib
	int InitSocketLib();
	//uinit socket lib
	void UinitSocketLib();
	int Select(int timeout);
	int CreateEpoll(int socket);
	int AddEpoll_LT(int socket);
	int AddEpoll_ET(int socket);
	int WaitEpoll(int timeout);
	int DestroyEpoll();
private:
public:
protected:
private:
	int m_IOMultiplexFd;
#ifdef WIN32
	fd_set m_readFdset;
	fd_set m_writeFdset;
	int * m_fd_list;  
#else
	struct epoll_event * m_epl_events;  
#endif
};

#endif

//zsocket.cpp 

int CSocket::Select(int timeout)
{
	int ret = 0;
#ifdef WIN32
	timeval selectTimeout;
	selectTimeout.tv_sec  = timeout;
	selectTimeout.tv_usec = 0;

	/*
	If there is no GetLastError () always returns 10022, 
	after repeated search, finally found that 
	int nSize = select (0, & recSocketFet, 0, 0, & nTimeOut);
	After a timeout, the response would not recSocketFet socket out,
	so only a socket (recSocketFet here) next time the select, 
	because recSocketFet no longer have the socket, so return 10022 - invalid parameters, 
	this should add FD_ZERO before the select (& recSocketFet);
	*/
	FD_ZERO (&m_readFdset);
	FD_ZERO (&m_writeFdset);
	if (m_fd_list != NULL)
	{
		for (int i = 0; i< MAX_FD_NUM ;i++)
		{
			if (m_fd_list[i] != -1) {  
				FD_SET(m_fd_list[i], &m_readFdset);  
				FD_SET(m_fd_list[i], &m_writeFdset);  
			}  
		}
	}
	/*
	linux 中int maxfdp是一个整数值，是指集合中所有文件描述符的范围，
	即所有文件描述符的最大值加1，不能错！在Windows中这个参数的值无所谓，可以设置不正确。 
	*/
	ret = select (m_IOMultiplexFd + 1, &m_readFdset, &m_writeFdset, NULL, &selectTimeout);
#else
#endif
	return ret;
}

int CSocket::CreateEpoll(int socket)
{
#ifdef WIN32
	printf("win32 can not use CreateEpoll\n");
	return -1;
#else
	//Besides the size parameters are ignored, this function is identical to that of epoll_create
	m_IOMultiplexFd = epoll_create1 (0);  
	if (m_IOMultiplexFd == -1)  
	{  
		printf ("epoll_create faild\n");  
		return -1;
	} 

	//And how to "read" and "write" and " A new connection" at the same time happen
	m_epl_events = (struct epoll_event *)calloc (MAX_EVENT_NUM, sizeof(struct epoll_event));  
#endif
	return 1;
}

int CSocket::AddEpoll_LT(int socket)
{
#ifdef WIN32
	printf("win32 can not use AddEpoll\n");
	return -1;
#else
	int ret = 0;
	struct epoll_event event;  

	event.data.fd = socket;  
	event.events = EPOLLIN | EPOLLOUT ;//读,写,水平触发方式 /和select一样(默认，EPOLLLT)
	ret = epoll_ctl (m_IOMultiplexFd, EPOLL_CTL_ADD, socket, &event);  
	if (ret == -1)  
	{  
		printf ("epoll_ctl faild\n");  
		return -1;
	}  
	return 1;
#endif
}

int CSocket::AddEpoll_ET(int socket)
{
#ifdef WIN32
	printf("win32 can not use AddEpoll\n");
	return -1;
#else
	int ret = 0;
	struct epoll_event event;  

	event.data.fd = socket;  
	event.events = EPOLLIN | EPOLLOUT | EPOLLET ;//读,写,边缘触发方式  
	ret = epoll_ctl (m_IOMultiplexFd, EPOLL_CTL_ADD, socket, &event);  
	if (ret == -1)  
	{  
		printf ("epoll_ctl faild\n");  
		return -1;
	}  
	return 1;
#endif
}

int CSocket::WaitEpoll(int timeout)
{
#ifdef WIN32
	printf("win32 can not use WaitEpoll\n");
	return -1;
#else
	return epoll_wait (m_IOMultiplexFd, m_epl_events, MAX_EVENT_NUM, timeout * 1000);  
#endif
}

int CSocket::DestroyEpoll()
{
#ifdef WIN32
	printf("win32 can not use DestroyEpoll\n");
	return -1;
#else
	if (m_epl_events)
	{
		free(m_epl_events);
		m_epl_events = NULL;
	}
#endif
	return 1;
}

int CSocket::Create(char * ip, int port,int sock_type)
{
	struct sockaddr_in Addr;
	int sockfd = 0;
	unsigned long nonBlock = 1;

	sockfd = socket(AF_INET, sock_type, 0);
	if (sockfd == -1)
	{
		return sockfd;
	}

#ifdef WIN32
	//设置成非阻塞方式
	if (ioctlsocket(sockfd, FIONBIO, &nonBlock)) 
	{
		printf("TCP Can't Put Socket In Non-Blocking Mode");
		Close(sockfd);
		return 0;
	}
#else
	//Set non-blocking way
	int flags = fcntl(sockfd, F_GETFL, 0); 
	if (fcntl(sockfd, F_SETFL, flags | O_NONBLOCK)) 
	{
		printf("TCP Can't Put Socket In Non-Blocking Mode");
		Close(sockfd);
		return NULL;
	}
#endif

	if (ip != NULL && port > 0)
	{
		Addr.sin_addr.s_addr = inet_addr(ip); 
		Addr.sin_family = AF_INET;
		Addr.sin_port = htons(port);

		if (bind(sockfd, (struct sockaddr *) &Addr, sizeof(struct sockaddr_in)) ==-1)
		{
			return 0;
		}
	}
	return sockfd;
}

void CSocket::Close(int socket)
{
	if(!socket)           //如果未创建socket
	{
		return;
	}
#ifdef WIN32
	closesocket(socket);
	if (m_fd_list != NULL)
	{
		for (int i = 0; i< MAX_FD_NUM ;i++)
		{
			if (m_fd_list[i] == socket) {  
				m_fd_list[i] = -1;
				break;
			}  
		}
	}
#else
	close(socket);
#endif
}

int CSocket::InitIOMultiplex(int socket)
{
	if (socket <= 0)
	{
		printf("InitIOMultiplex faild: First createsocket\n");
		return -1;
	}
#ifdef WIN32
	m_IOMultiplexFd = socket;
	m_fd_list = (int *)calloc (MAX_FD_NUM, sizeof(int));  
	for (int i = 0; i < MAX_FD_NUM; i++) 
	{
		m_fd_list[i] = -1; 
	}
	return 1;
#else
	return CreateEpoll(socket);
#endif
}

int CSocket::UinitIOMultiplex()
{
#ifdef WIN32
	if (m_fd_list)
	{
		free(m_fd_list);
		m_fd_list = NULL;
	}
	
	return 1;
#else
	return DestroyEpoll();
#endif
}

int CSocket::AddIOMultiplex(int socket,int epoll_modo)
{
#ifdef WIN32
	for (int i = 0 ; i< MAX_FD_NUM ;i++)
	{
		if (m_fd_list[i] == -1) {  
			m_fd_list[i] = socket;  
			break;  
		}  
	}
	if (m_IOMultiplexFd < socket) {  
		m_IOMultiplexFd = socket;  
	}  
	return 1;
#else
	if (epoll_modo == 0)
	{
		return AddEpoll_LT(socket);
	}
	else
	{
		return AddEpoll_ET(socket);
	}
#endif
}

int CSocket::UseIOMultiplex(int timeout)
{
	int ret = 0;
#ifdef WIN32
	ret = Select(timeout);
	if ((ret != -1) && (ret != 0))
	{
		return MAX_FD_NUM;
	}
#else
	ret = WaitEpoll(timeout);
#endif
	return ret;
}

int CSocket::IsNewConnect(int socket,int eventlabel)
{
#ifdef WIN32
	return FD_ISSET(socket,&m_readFdset);
#else
	return m_epl_events[eventlabel].data.fd == socket;
#endif
}

int CSocket::IsReadEvent(int label)
{
	int ret = 0;
#ifdef WIN32
	if (m_fd_list[label] == -1)
	{
		return ret;
	}
	ret = FD_ISSET(m_fd_list[label], &m_readFdset);
#else
	ret = m_epl_events[label].events & EPOLLIN;
#endif
	return ret;
}

int CSocket::IsWriteEvent(int label)
{
	int ret = 0;
#ifdef WIN32
	if (m_fd_list[label] == -1)
	{
		return ret;
	}
	ret = FD_ISSET(m_fd_list[label], &m_writeFdset);
#else
	ret = m_epl_events[label].events & EPOLLOUT;
#endif
	return ret;
}

void CSocket::DestoryReadEvent(int label)
{
#ifdef WIN32
	FD_CLR(m_fd_list[label],&m_readFdset);
#else
#endif
}

void CSocket::DestoryWriteEvent(int label)
{
#ifdef WIN32
	FD_CLR(m_fd_list[label],&m_writeFdset);
#else
#endif
}

int CSocket::IsCloseEvent(int label,int recvsize)
{
#ifdef WIN32
	if((recvsize == 0)||(recvsize == -1)) 
	{
		DestoryReadEvent(label);
		DestoryWriteEvent(label);
		return 1;
	}
	return 0;
#else
	if((recvsize == 0)||(recvsize == -1)) 
	{
		return 1;
	}
	return 0;
#endif
}

int CSocket::GetFdListOrEvents(int label)
{
#ifdef WIN32
	return m_fd_list[label];
#else
	return m_epl_events[label].data.fd;
#endif
}

char * CSocket::GetLocalIp(int socket)
{
	struct sockaddr_in ConnectAddr; 
	socklen_t sin_size = sizeof(struct sockaddr_in); 

	if(!getsockname(socket, (struct sockaddr *)&ConnectAddr, &sin_size))
	{
		return inet_ntoa(ConnectAddr.sin_addr);
	}
	return NULL;
}

int CSocket::GetLocalPort(int socket)
{
	struct sockaddr_in ConnectAddr; 
	socklen_t sin_size = sizeof(struct sockaddr_in); 

	if(!getsockname(socket, (struct sockaddr *)&ConnectAddr, &sin_size))
	{
		return ntohs(ConnectAddr.sin_port);
	}
	return 0;
}<strong>
</strong>

朱韦刚
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c常用头文件——sys/socket.h
lylee1981
08-28 3万+
#include
Python IO multiplex
screaming的博客
05-12 478
python--第十天总结（IO多路复用） 服务器端编程经常需要构造高性能的IO模型，常见的IO模型有四种： （1）同步阻塞IO（Blocking IO）：即传统的IO模型。 （2）同步非阻塞IO（Non-blocking IO）：默认创建的socket都是阻塞的，非阻塞IO要求socket被设置为NONBLOCK。注意这里所说的NIO并非Java的NIO（New IO）
python io多路复用框架_Python IO模型之多路复用IO（IO multiplexing）
weixin_29205061的博客
01-28 133
多路复用IO(IO multiplexing)IO multiplexing这个词可能有点陌生，但是如果我说select/epoll，大概就都能明白了。有些地方也称这种IO方式为事件驱动IO(event driven IO)。我们都知道，select/epoll的好处就在于单个process就可以同时处理多个网络连接的IO。它的基本原理就是select/epoll这个function会不断的轮询所...
简单的多路复用编程（I/O）----select()和poll函数的运用
念愿的专栏
07-17 4497
多路复用一般用于I/O操作可能会被阻塞的情况，对可能会有阻塞的I/O的管道、网路进行编程。下面我们来看个例子来说明如何使用两个多路复用函数。         本实例中主要实现通过调用select()函数来监听3个终端的输入（分别重定向到两个管道文件的虚拟终端以及主程序所运行的虚拟终端），并分别进行相应的处理。通过监视主程序的虚拟终端标准输入来实现程序的控制（例如：程序结束）；以两个管道作为数据的
Linux系统文件I/O编程(三)---I/O多路复用
王文松的博客
05-31 4658
多路复用 函数说明     我们都知道fcntl()函数解决了文件共享的问题，如果不知道请看：http://blog.csdn.net/mybelief321/article/details/8993138。接下来该处理I/O复用的情况了。那么，什么是I/O复用呢？这个咱得先弄清楚，所谓的I/O复用无非就是多个进程共同使用一个I/O输入输出流。    在经典的《Unix网络编程第1卷》Cha
IO 多路复用 之 (select/poll/epoll)
李俊的博客
05-04 356
一、常见的IO模型 IO模型主要分为同步IO和异步IO两大类，同步IO和异步IO主要区别 同步IO: 当进程发起IO操作后，数据准备就绪做真实IO操作的时候，这个过程是阻塞的 异步IO： 当进程发起IO 操作之后，就直接返回，直到kernel发送一个信号，告诉进程IO操作完成，无需进程负责真实IO操作，所以不存在阻塞，称之为异步 同步IO模型（synchronous IO） 阻塞IO（bloking IO） 非阻塞IO（non-blocking IO） 多路复用IO（multiplex..
bio,nio,select/poll,epoll
公瑾的专栏
10-23 169
io的发展历程bio,nio,select/poll,epoll Java的nio---》指的是new io 和多路复用器有关 Linux 的nio 指的是none blocking io 指的是非阻塞（） 多路复用器有多个实现：select，poll，epoll（linux），kqueue（unix） linux系统产生了下面五种网络模式的方案。- 阻塞 I/O（blocking IO）- 非阻塞 I/O（nonblocking IO）- I/O 多路复用（ IO multiplex...
一个基于 io-uring/epoll/kqueue 和 thread-per-core 模型 Rust Runtime
最新发布
07-07
基于io_uring/epoll/kqueue 的 Runtime，Monoio目标是在兼顾平台兼容性的情况下，做最高效、性能最优的 thread-per-core Rust Runtime。
网络io与io多路复用select/poll/epoll 服务器并发代码实现
08-29
例如，我们可以创建一个主循环，调用相应的多路复用函数（如select、poll或epoll_wait），监听客户端连接，一旦有新的连接或数据到达，就处理相应事件。通过这种方式，服务器可以同时服务于大量客户端，而无需为每个...
netty-transport-classes-epoll-4.1.73.Final-API文档-中英对照版.zip
05-03
赠送jar包：netty-transport-classes-epoll-4.1.73.Final.jar； 赠送原API文档：netty-transport-classes-epoll-4.1.73.Final-javadoc.jar； 赠送源代码：netty-transport-classes-epoll-4.1.73.Final-sources.jar；...
netty-transport-classes-epoll-4.1.74.Final-API文档-中文版.zip
07-07
赠送jar包：netty-transport-classes-epoll-4.1.74.Final.jar； 赠送原API文档：netty-transport-classes-epoll-4.1.74.Final-javadoc.jar； 赠送源代码：netty-transport-classes-epoll-4.1.74.Final-sources.jar；...
netty-transport-classes-epoll-4.1.73.Final-API文档-中文版.zip
05-09
赠送jar包：netty-transport-classes-epoll-4.1.73.Final.jar； 赠送原API文档：netty-transport-classes-epoll-4.1.73.Final-javadoc.jar； 赠送源代码：netty-transport-classes-epoll-4.1.73.Final-sources.jar；...
IO模型
weixin_30340617的博客
09-01 140
阅读目录 一 IO模型介绍 二阻塞IO(blocking IO) 三非阻塞IO(non-blocking IO) 四 多路复用IO(IO multiplexing) 五 异步IO(Asynchronous I/O) 六 IO模型比较分析 七 selectors模块 回到顶部 一 IO模型介绍 为了更好地了解IO模型，我们需要事先回顾下：同步、异步...
ffmpeg处理rtmp/文件/rtsp的推流和拉流
热门推荐
朱韦刚(zhuweigangzwg)的技术博客
02-11 4万+
ffmpeg处理rtmp/文件/rtsp的推流和拉流 本demo演示了利用ffmpeg从服务器拉流或本地文件读取流，更改流url或文件类型名称发送回服务器或存到本地的作用。 由于本程序只写了3个小时，还要忙别的，所以会有一些bug和优化的地方。不过demo的意义已经达到了。 //info.h #ifndef __INFO_H__ #define __INFO_H__ #in
音视频同步(播放)原理
朱韦刚(zhuweigangzwg)的技术博客
05-14 3万+
1：音视频同步原理 每一帧音频或视频都有一个持续时间：duration： 采样频率是指将模拟声音波形进行数字化时，每秒钟抽取声波幅度样本的次数。 。正常人听觉的频率范围大约在20Hz~20kHz之间，根据奈奎斯特采样理论，为了保证声音不失真，采样频率应该在40kHz左右。常用的音频采样频率有8kHz、 11.025kHz、22.05kHz、16kHz、37.8kHz、44.1kHz、48k
FFMPEG关于推流端降低延迟调节（一）
朱韦刚(zhuweigangzwg)的技术博客
08-30 3万+
                                                 FFMPEG关于推流端降低延迟调节（一） 本文所写的是调节推流端降低延迟能调节的一些方案，有不足请补充，其他端方向类似，例如降低采集缓存，减少编码时间等等，如有需要请参考。本文以windows推流端为例做解释。 1：减少采集缓存 av_dict_set(&amp;p_device_optio...
H264的I/P/B帧类型判断(一)
朱韦刚(zhuweigangzwg)的技术博客
03-09 3万+
这里首先说明下H264的结构： 00 00 00 01/00 00 01->nal(1bytes)->slice->宏块->运动估计向量。 如果h264的body中出现了前缀则由00 00 00 01/00 00 01变为00 03 00 00 01/00 03 00 01. 我们看到常用naltype 像sps= 0x07 pps= 0x08 sei = 0x06   I/P/B=
ffmpeg实现音频resample(重采样)
朱韦刚(zhuweigangzwg)的技术博客
02-11 2万+
用ffmpeg实现音频resample(重采样) 下面代码是实现将音频的三大要素：声道，样本，采样率变更的demo例如双声道变成单声道，44100->48000，float->s16等等。 int AudioResampling(AVCodecContext * audio_dec_ctx,AVFrame * pAudioDecodeFrame, int out_sample
select/poll/epoll
07-27
select、poll和epoll都是I/O多路复用机制，用于同时监听多个I/O事件的状态。它们的基本原理是通过查询所有socket连接，如果有数据到达，就通知用户进程。\[2\]这些机制都属于同步I/O，需要在事件就绪后自己负责读写...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值