一个fifo工程简单模板

一个fifo工程简单模板

gen_fifo.h文件

#ifndef GEN_FIFO_H
#define GEN_FIFO_H

#ifdef __cplusplus
extern "C" {
#endif

typedef struct kfifo {
	unsigned int in;
	unsigned int out;
	unsigned int mask;
	unsigned int esize;
	unsigned char *buffer;
} gen_fifo_t;

/**
 * @brief  获取FIFO内当前元素个数（内联实现）
 * @param  fifo 指向FIFO结构体的指针
 * @return FIFO内有效元素个数
 */
static inline unsigned int gen_fifo_len(gen_fifo_t *fifo) {
	return fifo->in - fifo->out;
}

/**
 * @brief  获取FIFO内空闲元素个数（内联实现）
 * @param  fifo 指向FIFO结构体的指针
 * @return FIFO内空闲元素个数
 */
static inline unsigned int gen_fifo_unused(gen_fifo_t *fifo) {
	return ((fifo->mask + 1) / fifo->esize) - gen_fifo_len(fifo);
}

/**
 * @brief  判断FIFO是否为空（内联实现）
 * @param  fifo 指向FIFO结构体的指针
 * @return 1-空，0-非空
 */
static inline unsigned char gen_fifo_is_empty(gen_fifo_t *fifo) {
	return gen_fifo_len(fifo) == 0;
}

/**
 * @brief  判断FIFO是否为满（内联实现）
 * @param  fifo 指向FIFO结构体的指针
 * @return 1-满，0-非满
 */
static inline unsigned char gen_fifo_is_full(gen_fifo_t *fifo) {
	return gen_fifo_unused(fifo) == 0;
}


unsigned int gen_fifo_out(gen_fifo_t *fifo, void *buf, unsigned int len);
unsigned int gen_fifo_in(gen_fifo_t *fifo, const void *buf, unsigned int len);
void gen_fifo_init(gen_fifo_t *fifo, unsigned char *buffer, unsigned int size, unsigned int esize);

#ifdef __cplusplus
}
#endif

#endif /* GEN_FIFO_H */

gen_fifo.c文件

#include <stdint.h>
#include <string.h>
#include <stdio.h>
#include "gen_fifo.h"


/**
 * @brief  FIFO初始化函数
 * @param  fifo 指向FIFO结构体的指针
 * @param  buffer 指向静态缓冲区的指针
 * @param  size 缓冲区总字节数
 * @param  esize 单个元素大小
 */
void gen_fifo_init(gen_fifo_t *fifo, unsigned char *buffer,
                  unsigned int size, unsigned int esize)
{
	if (fifo == NULL || buffer == NULL || size == 0 || esize == 0)
		return;

	if ((size & (size - 1)) != 0 || (size % esize) != 0)
		return;

	fifo->buffer = buffer;
	fifo->esize = esize;
	fifo->in = 0;
	fifo->out = 0;
	fifo->mask = size - 1;
}



// 内部数据入队拷贝
static void gen_fifo_copy_in(gen_fifo_t *fifo, const void *src,
                             unsigned int len, unsigned int off)
{
	unsigned int size = fifo->mask + 1;
	unsigned int esize = fifo->esize;
	unsigned int l;

	off &= fifo->mask;
	if (esize != 1) {
		off *= esize;
		size *= esize;
		len *= esize;
	}

	l = len < (size - off) ? len : (size - off);
	memcpy(fifo->buffer + off, src, l);
	memcpy(fifo->buffer, (const unsigned char *)src + l, len - l);
}

/**
 * @brief  FIFO入队函数
 * @param  fifo 指向FIFO结构体的指针
 * @param  buf  指向待入队数据的缓冲区
 * @param  len  待入队元素个数
 * @return 实际入队元素个数
 */
unsigned int gen_fifo_in(gen_fifo_t *fifo, const void *buf, unsigned int len)
{
	unsigned int l;

	if (fifo == NULL || buf == NULL || len == 0)
		return 0;

	l = gen_fifo_unused(fifo);
	if (len > l)
		len = l;

	gen_fifo_copy_in(fifo, buf, len, fifo->in);
	fifo->in += len;
	return len;
}


// 内部数据出队拷贝
static void gen_fifo_copy_out(gen_fifo_t *fifo, void *dst,
                              unsigned int len, unsigned int off)
{
	unsigned int size = fifo->mask + 1;
	unsigned int esize = fifo->esize;
	unsigned int l;

	off &= fifo->mask;
	if (esize != 1) {
		off *= esize;
		size *= esize;
		len *= esize;
	}

	l = len < (size - off) ? len : (size - off);
	memcpy(dst, fifo->buffer + off, l);
	memcpy((unsigned char *)dst + l, fifo->buffer, len - l);
}


/**
 * @brief  FIFO出队函数
 * @param  fifo 指向FIFO结构体的指针
 * @param  buf  指向存放出队数据的缓冲区
 * @param  len  待出队元素个数
 * @return 实际出队元素个数
 */
unsigned int gen_fifo_out(gen_fifo_t *fifo, void *buf, unsigned int len)
{
	unsigned int l;

	if (fifo == NULL || buf == NULL || len == 0)
		return 0;

	l = gen_fifo_len(fifo);
	if (len > l)
		len = l;

	gen_fifo_copy_out(fifo, buf, len, fifo->out);
	fifo->out += len;
	return len;
}