分析一个通用的rtsp server实现过程基础模块

本文分析先分析common模块：
common 模块有tcp，udp，socket，mutex类以及cyclebuffer类，StdAfx类

1. mutux类实现,这里的类实现的方法有点冗余，源码如下，

class TLock
{
public:
TLock( void )
{
pthread_mutexattr_t mattr;
pthread_mutexattr_init( &mattr );
pthread_mutex_init( &m_mutex, &mattr );
};

virtual ~TLock( void )
{
pthread_mutex_lock( &m_mutex );
pthread_mutex_unlock( &m_mutex );
pthread_mutex_destroy( &m_mutex );
};

virtual void Lock( void )
{
pthread_mutex_lock( &m_mutex );
};

virtual void UnLock( void )
{
pthread_mutex_unlock( &m_mutex );
};

protected:
private:
pthread_mutex_t m_mutex;
};

class ATLock
{
public:
ATLock( TLock* pTLock )
{
m_pTLock = pTLock;
m_pTLock->Lock();
};

ATLock( TLock& lock )
{
m_pTLock = &lock;
m_pTLock->Lock();
};

virtual ~ATLock()
{
m_pTLock->UnLock();
};

protected:

TLock* m_pTLock;
};

这里的代码需要建议修改，建议可以参考比较规范的定义类的方式，可以复用和单独提供处理作为库，给其他模块调用，建议用下面的方式，具体的实现，需要读者来参考上面的补上相应的函数就ok了，就不贴出了！

class thread_mutex
{
public:
thread_mutex();
~thread_mutex();
public:
void lock();
void unlock();
private:

pthread_mutex_t m_mutex;
};

2. Cyclebuffer类，这个作为一个环形缓冲，可以参考前面我写的的java的双缓冲文章，基本的思路都是有的，这里直接给出另外的write和read的C++实现方式，这里有个技巧需要重新计算get_free_space的空间，然后重新给读和写的位置赋值。

write函数如下：

int cycle_buffer::write( const unsigned char* buffer, int len )
{
unsigned int free_space_size = 0;
unsigned int writed_size = len;

/* 修改获取相应的space 的信息*/
unsigned char* pRPos = NULL;
unsigned char* pWPos = NULL;
free_space_size = get_free_space( &pRPos, &pWPos );

if ( free_space_size < len )
｛
return 0;
}

if ( m_flag_buffering_data_ok != 1 )
{
//没有缓冲满，需要进行计数
m_buffering_write_count += len;

if ( m_buffering_write_count > m_bufferingsize )
{
//已经缓冲满
m_flag_buffering_data_ok = 1;
}
}

if ( ( m_cb.end - pWPos + 1 ) < len )
{
/*出现翻转的情况*/
writed_size = m_cb.end - pWPos + 1;
memcpy( pWPos, buffer, writed_size );
memcpy( m_cb.begin, buffer + writed_size, len - writed_size );
}
else
{
memcpy( pWPos, buffer, writed_size );
}

int offset = ( ( pWPos - m_cb.begin ) + len ) % m_cb.size;
m_cb.wpos = m_cb.begin + offset;

return len;
}

read函数也是一样的，和上面一样的架构！

int cycle_buffer::read( unsigned char* buffer, int len )
{
if ( m_flag_buffering_data_ok != 1 )
{
//没有缓冲满，无法进行读
return 0;
}

unsigned int valid_data_size = 0;
unsigned int read_size = len;

/* 修改获取相应的space 的信息,主要的原因就是有一个是需要空出来的*/
unsigned char* pRPos = NULL;
unsigned char* pWPos = NULL;
valid_data_size = m_cb.size - get_free_space( &pRPos, &pWPos ) - 1;

if ( valid_data_size < len )
{
return 0;
}
if ( ( m_cb.end - pRPos + 1 ) < len )
{
/*出现翻转的情况*/
read_size = m_cb.end - pRPos + 1;
memcpy( buffer, pRPos, read_size );
memcpy( buffer + read_size, m_cb.begin, len - read_size );
}
else
{
memcpy( buffer, pRPos, read_size );
}
int offset = ( ( pRPos - m_cb.begin ) + len ) % m_cb.size;
m_cb.rpos = m_cb.begin + offset;
return len;
}

从这两段的代码逻辑可以看出，简单的问题复杂化了，其实只要根据write，read和start，end的位置就可以写出具体的读写buffer了，参考前面java ringbuffer修改，相信也不是太难。当然这里可以看出，有一个地方需要锁的地方，就是：

get_free_space

这个函数，read和write不同线程，同时调用的话，会打乱write和read的位置,里面最好加一把锁！

3. tcp/ip 相关base类：

直接看bass socket类，这里才是核心的架构，

class Socket
{
public:
virtual int Write( PBYTE pBuffer, int writeSize, UINT nTimeOut = 2000000 );  // 2 sec
virtual int Read( BYTE* pBuffer, int readSize, UINT nTimeOut = 2000000 ); // 2 sec
protected:
int Select( int mode, int timeoutUsec );
SOCKET m_Socket;
SOCKADDR_IN m_BindAddr;
SOCKADDR_IN m_ConnectAddr;
};

这里可以看出，所有的网络通信是继承这个基础类，不过从整体架构感觉这里的socket类有点不规范，

如果需要重构的话，最好这里全部是虚函数，然后重新写一个类来实现，如select函数的东西，将socket里面的基本通信方式全部补上，这里比较合理。

这里m_socket就是上层打开socekt传过来的，因为所有后面的读写全部调用这里的方式实现，统一节省资源，

同时不需要锁，因为m_socket唯一性决定！

然后看tcp类的实现方式：

class Tcp : public Socket
{
public:

virtual BOOL Open( PCSTR bindIp = "", INT bindPort = 0 );

virtual BOOL Connect( PCSTR connectIp, INT connectPort );

protected:
BOOL m_isConnect;
};

这里只有open和connect函数，明显定义的不够好，并且从tcp.cpp可以看出：

open函数里面包含了bind的函数，耦合性过强，建议分开单独成函数，使架构更加清晰！

接下来看下UDP类的实现，因为数据都是rtp包发送，而rtp是通过udp来实现，因此需要实现下面的方式，来交互数据

class Udp : public Socket
{
public:
virtual BOOL Open( string bindIp = "", int bindPort = 0 );
virtual BOOL Connect( string connectIp, int connectPort );
virtual int Read( BYTE* pBuffer, UINT16 bufferSize, UINT nTimeOut = 500000 );
virtual int Write( PBYTE pBuffer, UINT16 bufferSize, UINT nTimeOut = 500000 );
protected:
BOOL m_isConnect;
};

这里就read和write函数会call子类的读写函数，当然open和上面的一样的模式，建议后期修改！

当然tcp和udp的在open的都是，可以设置一系列等参数，

用setsockopt来设置，这里就不详细的介绍了！

4. 当然为了保存兼容想，需要单独定义个类，StdAfx类

用来兼容命名的统一性，如下：

typedef unsigned char BYTE;
typedef unsigned short WORD;
typedef BYTE* PBYTE;
typedef const char* PCSTR;
typedef unsigned long ULONG;
typedef void* PVOID;

因此，这个架构就将上面的基础组件搭建好，后面就需要根据这个做具体的逻辑处理任务！

接下来，进一步介绍rtsp的相应整体架构流程，对于太细的细节不做过多的详述！