中级会员
 
- 积分
- 213
- 金钱
- 213
- 注册时间
- 2018-2-1
- 在线时间
- 40 小时
|
模仿kfifo实现的环形缓冲区
转载来源：模仿kfifo实现的环形缓冲区
GitHub仓库：https://github.com/XinLiGitHub/RingBuffer
PS：博文不再更新，后续更新会在GitHub仓库进行。
模仿kfifo实现的环形缓冲区。程序中涉及到环形缓冲区的概念，详细介绍见维基百科[Circular buffer](https://en.wikipedia.org/wiki/Circular_buffer)。
1，开发环境
1，操作系统：Windows 10 专业版
2，IDE：Visual Studio 2015 专业版
2，程序源码
RingBuffer.h文件
[mw_shl_code=c,true]/**
******************************************************************************
* @file RingBuffer.h
* @Author XinLi
* @version v1.0
* @date 15-January-2018
* @brief Header file for RingBuffer.c module.
******************************************************************************
* @attention
*
* <h2><center>Copyright © 2018 XinLi</center></h2>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
******************************************************************************
*/
#ifndef __RINGBUFFER_H
#define __RINGBUFFER_H
#ifdef __cplusplus
extern "C" {
#endif
/* Header includes -----------------------------------------------------------*/
#include <stdint.h>
#include <stdbool.h>
/* Macro definitions ---------------------------------------------------------*/
#define RING_BUFFER_MALLOC(size) malloc(size)
#define RING_BUFFER_FREE(block) free(block)
/* Type definitions ----------------------------------------------------------*/
typedef struct
{
uint8_t *buffer;
uint32_t size;
uint32_t in;
uint32_t out;
}RingBuffer;
/* Variable declarations -----------------------------------------------------*/
/* Variable definitions ------------------------------------------------------*/
/* Function declarations -----------------------------------------------------*/
RingBuffer *RingBuffer_Malloc(uint32_t size);
void RingBuffer_Free(RingBuffer *fifo);
uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len);
uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len);
/* Function definitions ------------------------------------------------------*/
/**
* @brief Removes the entire FIFO contents.
* @param [in] fifo: The fifo to be emptied.
* @return None.
*/
static inline void RingBuffer_Reset(RingBuffer *fifo)
{
fifo->in = fifo->out = 0;
}
/**
* @brief Returns the size of the FIFO in bytes.
* @param [in] fifo: The fifo to be used.
* @return The size of the FIFO.
*/
static inline uint32_t RingBuffer_Size(RingBuffer *fifo)
{
return fifo->size;
}
/**
* @brief Returns the number of used bytes in the FIFO.
* @param [in] fifo: The fifo to be used.
* @return The number of used bytes.
*/
static inline uint32_t RingBuffer_Len(RingBuffer *fifo)
{
return fifo->in - fifo->out;
}
/**
* @brief Returns the number of bytes available in the FIFO.
* @param [in] fifo: The fifo to be used.
* @return The number of bytes available.
*/
static inline uint32_t RingBuffer_Avail(RingBuffer *fifo)
{
return RingBuffer_Size(fifo) - RingBuffer_Len(fifo);
}
/**
* @brief Is the FIFO empty?
* @param [in] fifo: The fifo to be used.
* @retval true: Yes.
* @retval false: No.
*/
static inline bool RingBuffer_IsEmpty(RingBuffer *fifo)
{
return RingBuffer_Len(fifo) == 0;
}
/**
* @brief Is the FIFO full?
* @param [in] fifo: The fifo to be used.
* @retval true: Yes.
* @retval false: No.
*/
static inline bool RingBuffer_IsFull(RingBuffer *fifo)
{
return RingBuffer_Avail(fifo) == 0;
}
#ifdef __cplusplus
}
#endif
#endif /* __RINGBUFFER_H */
[/mw_shl_code]
RingBuffer.c文件
[mw_shl_code=c,true]/**
******************************************************************************
* @file RingBuffer.c
* @author XinLi
* @version v1.0
* @date 15-January-2018
* @brief Ring buffer module source file.
******************************************************************************
* @attention
*
* <h2><center>Copyright © 2018 XinLi</center></h2>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
******************************************************************************
*/
/* Header includes -----------------------------------------------------------*/
#include "RingBuffer.h"
#include <stdlib.h>
#include <string.h>
/* Macro definitions ---------------------------------------------------------*/
/* Type definitions ----------------------------------------------------------*/
/* Variable declarations -----------------------------------------------------*/
/* Variable definitions ------------------------------------------------------*/
/* Function declarations -----------------------------------------------------*/
static bool is_power_of_2(uint32_t x);
static uint32_t roundup_pow_of_two(uint32_t x);
/* Function definitions ------------------------------------------------------*/
/**
* @brief Allocates a new FIFO and its internal buffer.
* @param [in] size: The size of the internal buffer to be allocated.
* @note The size will be rounded-up to a power of 2.
* @return RingBuffer pointer.
*/
RingBuffer *RingBuffer_Malloc(uint32_t size)
{
RingBuffer *fifo = RING_BUFFER_MALLOC(sizeof(RingBuffer));
if(fifo != NULL)
{
if(is_power_of_2(size) != true)
{
if(size > 0x80000000UL)
{
RING_BUFFER_FREE(fifo);
fifo = NULL;
return fifo;
}
size = roundup_pow_of_two(size);
}
fifo->size = size;
fifo->in = 0;
fifo->out = 0;
fifo->buffer = RING_BUFFER_MALLOC(fifo->size);
if(fifo->buffer == NULL)
{
RING_BUFFER_FREE(fifo);
fifo = NULL;
return fifo;
}
}
return fifo;
}
/**
* @brief Frees the FIFO.
* @param [in] fifo: The fifo to be freed.
* @return None.
*/
void RingBuffer_Free(RingBuffer *fifo)
{
RING_BUFFER_FREE(fifo->buffer);
RING_BUFFER_FREE(fifo);
fifo = NULL;
}
/**
* @brief Puts some data into the FIFO.
* @param [in] fifo: The fifo to be used.
* @param [in] in: The data to be added.
* @param [in] len: The length of the data to be added.
* @return The number of bytes copied.
* @note This function copies at most @len bytes from the @in into
* the FIFO depending on the free space, and returns the number
* of bytes copied.
*/
uint32_t RingBuffer_In(RingBuffer *fifo, void *in, uint32_t len)
{
len = min(len, RingBuffer_Avail(fifo));
/* First put the data starting from fifo->in to buffer end. */
uint32_t l = min(len, fifo->size - (fifo->in & (fifo->size - 1)));
memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)), in, l);
/* Then put the rest (if any) at the beginning of the buffer. */
memcpy(fifo->buffer, (uint8_t *)in + l, len - l);
fifo->in += len;
return len;
}
/**
* @brief Gets some data from the FIFO.
* @param [in] fifo: The fifo to be used.
* @param [in] out: Where the data must be copied.
* @param [in] len: The size of the destination buffer.
* @return The number of copied bytes.
* @note This function copies at most @len bytes from the FIFO into
* the @out and returns the number of copied bytes.
*/
uint32_t RingBuffer_Out(RingBuffer *fifo, void *out, uint32_t len)
{
len = min(len, RingBuffer_Len(fifo));
/* First get the data from fifo->out until the end of the buffer. */
uint32_t l = min(len, fifo->size - (fifo->out & (fifo->size - 1)));
memcpy(out, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
/* Then get the rest (if any) from the beginning of the buffer. */
memcpy((uint8_t *)out + l, fifo->buffer, len - l);
fifo->out += len;
return len;
}
/**
* @brief Determine whether some value is a power of two.
* @param [in] x: The number to be confirmed.
* @retval true: Yes.
* @retval false: No.
* @note Where zero is not considered a power of two.
*/
static bool is_power_of_2(uint32_t x)
{
return (x != 0) && ((x & (x - 1)) == 0);
}
/**
* @brief Round the given value up to nearest power of two.
* @param [in] x: The number to be converted.
* @return The power of two.
*/
static uint32_t roundup_pow_of_two(uint32_t x)
{
uint32_t b = 0;
for(int i = 0; i < 32; i++)
{
b = 1UL << i;
if(x <= b)
{
break;
}
}
return b;
}
[/mw_shl_code]
|
|
/2 
|手机版|OpenEdv-开源电子网
( 粤ICP备12000418号-1 )
发表于 2018-3-7 19:32:37
楼主
