循环缓存类

#include "circular_buffer.h"
#include "libOSI.h"
#include "libDSI.h"


#ifndef _min_
#define min(a,b) (((a) < (b)) ? (a) : (b)) 
#endif


#ifndef _max_  
#define max(a,b) (((a) > (b)) ? (a) : (b))  
#endif 


static circular_buffer circularbuffer[MAX_CIRCULAR_BUFFER];
circular_buffer::circular_buffer()
{

}


circular_buffer::~circular_buffer()
{


}


DECLARE OSI_VOID startAllcircular_buffer(OSI_VOID)
{
circular_buffer*pcircularbuffer;
for(OSI_INT32 index = 1;index<=MAX_CIRCULAR_BUFFER;index++)
{
pcircularbuffer = getcircular_bufferObj(index);
pcircularbuffer->Initcircularbuffer();
}
}


OSI_VOID circular_buffer::Initcircularbuffer()
{
m_buffer_size = OSI_1MB;
m_read_p = 0;
m_write_p = 0;
m_circle_buffer = (char*)OSI_Mem_Malloc(OSI_1MB);
OSI_Mem_Set(m_circle_buffer,0,OSI_1MB);
m_beUsed = OSI_FALSE;
}


OSI_VOID circular_buffer::clear()
{
m_read_p = 0;
m_write_p = 0;
m_beUsed = OSI_FALSE;
}


OSI_UINT32 circular_buffer::available()
{
return m_buffer_size - (m_write_p - m_read_p);
}


OSI_UINT32 circular_buffer::used()
{
return m_write_p - m_read_p; 
}


OSI_UINT32 circular_buffer::put_data(char * buffer,OSI_UINT32 len)
{
   unsigned int l;  
   OSI_UINT32 writeIndex = m_write_p;
   OSI_UINT32 readIndex = m_read_p;
   
   len = _min(len, m_buffer_size - writeIndex + readIndex);  


   /* first put the data starting from fifo->in to buffer end */ 


   l = _min(len, m_buffer_size - (writeIndex & (m_buffer_size - 1)));  


   memcpy(m_circle_buffer + (writeIndex & (m_buffer_size - 1)), buffer, l);  


   /* then put the rest (if any) at the beginning of the buffer */ 


   memcpy(m_circle_buffer, buffer + l, len - l);  


   //m_write_p += len;  


   return len;  
}


OSI_UINT32 circular_buffer::get_data(char *buffer,OSI_UINT32 len)
{
   unsigned int l;   
   OSI_UINT32 writeIndex = m_write_p;
   OSI_UINT32 readIndex = m_read_p;
   len = _min(len, writeIndex - readIndex);   


   /* first get the data from fifo->out until the end of the buffer */  


   l = _min(len, m_buffer_size - (readIndex & (m_buffer_size - 1)));   


   memcpy(buffer, m_circle_buffer + (readIndex & (m_buffer_size - 1)), l);   


   /* then get the rest (if any) from the beginning of the buffer */  


   memcpy(buffer + l, m_circle_buffer, len - l);   


   //m_read_p += len;   


   return len; 
}


OSI_UINT32 circular_buffer::_max(OSI_UINT32 a,OSI_UINT32 b)
{
return max(a, b);
}


OSI_UINT32 circular_buffer::_min(OSI_UINT32 a,OSI_UINT32 b)
{
return min(a, b);
}


OSI_UINT32 circular_buffer::ModifyReadIndex(OSI_UINT32 len)
{
m_read_p += len;
//m_read_p = m_read_p%OSI_1MB;
return m_read_p;
}


OSI_UINT32 circular_buffer::ModifyWriteIndex(OSI_UINT32 len)
{
m_write_p +=len;
//m_write_p = m_write_p%OSI_1MB;
return m_write_p;
}
circular_buffer* getcircular_bufferObj(OSI_INT32 index)
{
return &circularbuffer[index-1];

}

#ifndef _CIRCULAR_BUFFER_
#define _CIRCULAR_BUFFER_
#include "libOSI.h"
#include "libDSI.h"


#ifdef cplusplus
extern "C"
{
#endif
/*定义最大的共享缓存数为129*/
#define MAX_CIRCULAR_BUFFER 129


class circular_buffer
{
public:
circular_buffer();
~circular_buffer();


OSI_VOID Initcircularbuffer();

OSI_VOID clear();


OSI_UINT32 available();


OSI_UINT32 used();


OSI_UINT32 put_data(char* buffer, OSI_UINT32 len);


OSI_UINT32 get_data(char* buffer, OSI_UINT32 len); 


OSI_BOOL m_beUsed;


protected:
OSI_UINT32 _max(OSI_UINT32 a, OSI_UINT32 b);


OSI_UINT32 _min(OSI_UINT32 a, OSI_UINT32 b);


  public:  


    OSI_INT32 m_buffer_size;  


   char* m_circle_buffer;  


   OSI_UINT32 m_write_p;  


   OSI_UINT32 m_read_p;


OSI_UINT32 m_readIndex;


OSI_UINT32 m_writeIndex;


OSI_UINT32 m_baseaddr;


OSI_UINT32 m_bufsize;


OSI_UINT32 m_pagenum;


OSI_UINT32 m_bar;


OSI_UINT32 m_channum;


};


DECLARE circular_buffer* getcircular_bufferObj(OSI_INT32 index);
DECLARE OSI_VOID startAllcircular_buffer(OSI_VOID);
#ifdef cplusplus
}
#endif


#endif

这个是我自己编写的循环缓存类的实现，已经过测试是好的。