分析一个通用的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的相应整体架构流程，对于太细的细节不做过多的详述！