摘要:#如果ndef_RING_ BUFFER_ H__#定义__RING_缓冲器_ H__//------------------------------------------------------------------------------//外部函数//---------------------------------------------------
#ifndef __RING_BUFFER_H__
#define __RING_BUFFER_H__
//------------------------------------------------------------------------------
// External functions
//------------------------------------------------------------------------------
void BSP_Lock( void );
void BSP_Unlock( void );
typedef struct
{
unsigned char * buffer;
unsigned int capacity;
unsigned int pointer;
unsigned int count;
} ring_buffer_t;
ring_buffer_t *ring_buffer_create( unsigned int size );
void ring_buffer_delete( ring_buffer_t *ring_buffer );
void ring_buffer_init( ring_buffer_t *ring_buffer, unsigned char * buffer,
unsigned int capacity );
void ring_buffer_clear( ring_buffer_t *ring_buffer );
unsigned int ring_buffer_readable( ring_buffer_t *ring_buffer );
unsigned int ring_buffer_writable( ring_buffer_t *ring_buffer );
void ring_buffer_flush( ring_buffer_t *ring_buffer, unsigned int bytes );
unsigned int ring_buffer_read( ring_buffer_t *ring_buffer, unsigned char *data,
unsigned int length );
unsigned int ring_buffer_write( ring_buffer_t *ring_buffer,
const unsigned char *data, unsigned int length );
unsigned int ring_buffer_full( ring_buffer_t *ring_buffer );
unsigned int ring_buffer_empty( ring_buffer_t *ring_buffer );
#endif /* __RING_BUFFER_H__ */
#include "ring_buffer.h"
#include <stdlib.h>
#include <string.h>
unsigned int ring_buffer_readable( ring_buffer_t *ring_buffer )
{
return ring_buffer->count;
}
unsigned int ring_buffer_writable( ring_buffer_t *ring_buffer )
{
return ring_buffer->capacity - ring_buffer->count;
}
unsigned int ring_buffer_full( ring_buffer_t *ring_buffer )
{
return ring_buffer->count == ring_buffer->capacity;
}
unsigned int ring_buffer_empty( ring_buffer_t *ring_buffer )
{
return ring_buffer->count == 0;
}
unsigned int ring_buffer_read( ring_buffer_t *ring_buffer, unsigned char *data,
unsigned int length )
{
unsigned int buffer_readable = ring_buffer_readable( ring_buffer );
unsigned int bytes_read = length;
if ( bytes_read > buffer_readable )
bytes_read = buffer_readable;
if ( bytes_read == 0 )
return 0;
// -----------RRRRRRRRRRRR
if ( ring_buffer->pointer + bytes_read <= ring_buffer->capacity )
memcpy( data, ring_buffer->buffer + ring_buffer->pointer, bytes_read );
else // RRRRRR--------------RRRRR
{
unsigned int upper = ring_buffer->capacity - ring_buffer->pointer;
unsigned int lower = bytes_read - upper;
memcpy( data, ring_buffer->buffer + ring_buffer->pointer, upper );
memcpy( data + upper, ring_buffer->buffer, lower );
}
BSP_Lock( );
ring_buffer->pointer = ( ring_buffer->pointer + bytes_read )
% ring_buffer->capacity;
ring_buffer->count -= bytes_read;
BSP_Unlock( );
return bytes_read;
}
unsigned int ring_buffer_write( ring_buffer_t *ring_buffer,
const unsigned char *data, unsigned int length )
{
unsigned int bytes_written = length;
unsigned int buffer_writable = ring_buffer_writable( ring_buffer );
if ( bytes_written > buffer_writable )
bytes_written = buffer_writable;
if ( bytes_written == 0 )
return 0;
unsigned int write_position = ( ring_buffer->pointer + ring_buffer->count )
% ring_buffer->capacity;
// --------WWWWWWWW---
if ( write_position + bytes_written <= ring_buffer->capacity )
memcpy( ring_buffer->buffer + write_position, data, bytes_written );
else // WWWWWWW-------WWWW
{
unsigned int upper = ring_buffer->capacity - write_position;
unsigned int lower = bytes_written - upper;
memcpy( ring_buffer->buffer + write_position, data, upper );
memcpy( ring_buffer->buffer, data + upper, lower );
}
BSP_Lock( );
ring_buffer->count += bytes_written;
BSP_Unlock( );
return bytes_written;
}
void ring_buffer_flush( ring_buffer_t *ring_buffer, unsigned int length )
{
// we can't flush more bytes than there are
BSP_Lock( );
if ( length > (unsigned int) ring_buffer->count )
length = ring_buffer->count;
ring_buffer->count -= length;
ring_buffer->pointer = ( ring_buffer->pointer + length );
ring_buffer->pointer %= ring_buffer->capacity;
BSP_Unlock( );
}
void ring_buffer_clear( ring_buffer_t *ring_buffer )
{
BSP_Lock( );
ring_buffer->count = 0;
ring_buffer->pointer = 0;
BSP_Unlock( );
}
void ring_buffer_init( ring_buffer_t *ring_buffer, unsigned char * buffer,
unsigned int capacity )
{
ring_buffer->buffer = buffer;
ring_buffer->capacity = capacity;
ring_buffer_clear( ring_buffer );
}
ring_buffer_t * ring_buffer_create( unsigned int size )
{
void * p = malloc( sizeof(ring_buffer_t) + size );
ring_buffer_t *ring_buffer = (ring_buffer_t *) p;
if ( ring_buffer == NULL )
return NULL;
ring_buffer->capacity = size;
ring_buffer_clear( ring_buffer );
return ring_buffer;
}
void ring_buffer_delete( ring_buffer_t *ring_buffer )
{
free( ring_buffer );
}