循环队列——实现ringbuffer为了多媒体数据缓存

最新推荐文章于 2024-05-12 11:22:34 发布
最新推荐文章于 2024-05-12 11:22:34 发布
阅读量1.6k 收藏 2
点赞数
分类专栏： code记录

http://blog.csdn.net/firehood_/article/details/6716357


版权声明：本文为博主原创文章，未经博主允许不得转载。

        在WINCE开发中很多时候需要用到循环队列来缓存数据，比如在串口通信中，可以将接收到的数据流先缓存到循环队列中，然后再从循环队列中取出数据做下一步的处理。这样可以有效的避免解析数据帧时繁琐的拼接处理。

        为了方便使用，封装了一个循环队列类，具体代码如下：

        头文件：

[cpp]  view plain  copy
  1. /******************************************************************** 
  2. filename:   CircularQueue.h 
  3. created:    2011-08-23 
  4. author:     firehood 
  5.  
  6. purpose:    实现循环队列 
  7.             队列可以缓存的数据大小 = 队列长度 -1 
  8.             插入数据时在队列满的情况下会自动覆盖队列头部数据 
  9. *********************************************************************/  
  10. #pragma once  
  11.   
  12. #define DEFAULT_QUEUE_MAX_SIZE  512  
  13. class CCircularQueue  
  14. {  
  15. public:  
  16.     // 无参构造函数,默认创建队列的大小为512字节  
  17.     CCircularQueue(void);  
  18.     // 带参构造函数,创建指定大小的队列  
  19.     CCircularQueue(int nQueueSize);  
  20.     ~CCircularQueue(void);  
  21. public:  
  22.     // 向队列尾部插入一个字节，队列满时会自动覆盖队列头部数据  
  23.     bool PushBack(unsigned char data);  
  24.   
  25.     // 从队列头部取出一个字节  
  26.     bool PopFront(unsigned char &data);  
  27.   
  28.     // 向队列尾部插入指定长度数据，队列满时会自动覆盖队列头部数据  
  29.     bool PushBack(unsigned char *pData, int size);  
  30.       
  31.     // 从队列头部取出指定长度数据  
  32.     // 返回值：>0 返回实际取出的数据长度； <=0 失败  
  33.     int PopFront(unsigned char *pData, int size);  
  34.       
  35.     // 重新调整队列大小  
  36.     bool Resize(int nQueueSize);  
  37.       
  38.     // 当前队列缓存的数据大小  
  39.     int Size();  
  40.     // 队列当前剩余空间大小  
  41.     int RemainSize();  
  42.     // 队列是否为空  
  43.     bool IsEmpty();  
  44.     // 队列是否满  
  45.     bool IsFull();  
  46.     // 打印数据(测试使用)  
  47.     void PrintData();  
  48. private:  
  49.     unsigned char *m_pQueueBase; // 队列基址  
  50.     int m_QueueSize;             // 队列大小  
  51.     int m_Head, m_Tail;          // 队列头尾指针  
  52.     CRITICAL_SECTION  m_csRW;    // 读写锁  
  53. };  

        源文件:

[cpp]  view plain  copy
  1. /******************************************************************** 
  2. filename:   CircularQueue.cpp 
  3. created:    2011-08-23 
  4. author:     firehood 
  5.  
  6. purpose:    实现循环队列 
  7.             队列可以缓存的数据大小 = 队列长度 -1 
  8.             插入数据时在队列满的情况下会自动覆盖队列头部数据 
  9. *********************************************************************/  
  10. #include "stdafx.h"  
  11. #include "CircularQueue.h"  
  12.   
  13. CCircularQueue::CCircularQueue(void):  
  14. m_pQueueBase(NULL),  
  15. m_Head(0),  
  16. m_Tail(0),  
  17. m_QueueSize(DEFAULT_QUEUE_MAX_SIZE)  
  18. {  
  19.     m_pQueueBase = new unsigned char[m_QueueSize];  
  20.     ASSERT(m_pQueueBase);  
  21.     memset(m_pQueueBase, 0, m_QueueSize);  
  22.     InitializeCriticalSection(&m_csRW);  
  23. }  
  24.   
  25. CCircularQueue::CCircularQueue(int nQueueSize):  
  26. m_pQueueBase(NULL),  
  27. m_Head(0),  
  28. m_Tail(0),  
  29. m_QueueSize(nQueueSize)  
  30. {  
  31.     m_pQueueBase = new unsigned char[m_QueueSize];  
  32.     ASSERT(m_pQueueBase);  
  33.     memset(m_pQueueBase, 0, m_QueueSize);  
  34.     InitializeCriticalSection(&m_csRW);  
  35. }  
  36.   
  37. CCircularQueue::~CCircularQueue(void)  
  38. {  
  39.     if(m_pQueueBase)  
  40.     {  
  41.         delete[] m_pQueueBase;  
  42.         m_pQueueBase = NULL;  
  43.     }  
  44.     DeleteCriticalSection (&m_csRW);  
  45. }  
  46.   
  47. // 向队列尾部插入一个字节，队列满时会自动覆盖队列头部数据  
  48. bool CCircularQueue::PushBack(unsigned char data)  
  49. {  
  50.     if(m_pQueueBase == NULL)  
  51.     {  
  52.         return false;  
  53.     }  
  54.     EnterCriticalSection(&m_csRW);  
  55.   
  56.     m_pQueueBase[m_Tail]= data;  
  57.     m_Tail =(m_Tail+1) % m_QueueSize;  
  58.     if(m_Tail == m_Head)  
  59.     {  
  60.         m_Head = m_Tail+1;  
  61.         printf("Warning:lost data, Queue is full..\n");  
  62.     }  
  63.   
  64.     LeaveCriticalSection(&m_csRW);  
  65.     return true;  
  66. }  
  67.   
  68. // 从队列头部取出一个字节  
  69. bool CCircularQueue::PopFront(unsigned char &data)  
  70. {  
  71.     if(m_pQueueBase == NULL)  
  72.     {  
  73.         return false;  
  74.     }  
  75.     if(IsEmpty())  
  76.     {  
  77.         return false;  
  78.     }  
  79.     EnterCriticalSection(&m_csRW);  
  80.   
  81.     data = m_pQueueBase[m_Head];  
  82.     m_Head=(m_Head+1) % m_QueueSize;  
  83.   
  84.     LeaveCriticalSection(&m_csRW);  
  85.     return true;  
  86. }  
  87.   
  88. // 向队列尾部插入指定长度数据，队列满时会自动覆盖队列头部数据  
  89. bool CCircularQueue::PushBack(unsigned char *pData, int size)  
  90. {  
  91.     if(m_pQueueBase == NULL || pData == NULL)  
  92.     {  
  93.         return false;  
  94.     }  
  95.     if(size >= m_QueueSize)  
  96.     {  
  97.         printf("PushBack failed: DataSize[%d] > MAX_QUEUE_SIZE[%d]\n" , size, (m_QueueSize-1));  
  98.         return false;  
  99.     }  
  100.     EnterCriticalSection(&m_csRW);  
  101.     int nRemianSize = RemainSize();  
  102.     int nTailToEndSize = m_QueueSize - m_Tail;  
  103.     if(size <= nTailToEndSize)  
  104.     {  
  105.         memcpy(m_pQueueBase+m_Tail, pData, size);  
  106.     }  
  107.     else  
  108.     {  
  109.         memcpy(m_pQueueBase+m_Tail, pData, nTailToEndSize);  
  110.         memcpy(m_pQueueBase,pData+nTailToEndSize, size-nTailToEndSize);  
  111.     }  
  112.     m_Tail = (m_Tail+size) % m_QueueSize;  
  113.     if(size >= nRemianSize)  
  114.     {  
  115.         printf("Warning:lost data, Queue is full..\n");  
  116.         m_Head = m_Tail+1;  
  117.     }  
  118.     LeaveCriticalSection(&m_csRW);  
  119.     return true;  
  120. }  
  121.   
  122. // 从队列头部取出指定长度数据  
  123. // 返回值：>0 返回实际取出的数据长度； <=0 失败  
  124. int CCircularQueue::PopFront(unsigned char *pData, int size)  
  125. {  
  126.     if(pData == NULL || m_pQueueBase == NULL)  
  127.         return -1;  
  128.       
  129.     EnterCriticalSection(&m_csRW);  
  130.     int nReadSize = (this->Size()>size) ? size : this->Size();  
  131.     int nHeadToEndSize = m_QueueSize - m_Head;  
  132.     if(nReadSize <= nHeadToEndSize)  
  133.     {  
  134.         memcpy(pData, m_pQueueBase+m_Head, nReadSize);  
  135.     }  
  136.     else  
  137.     {  
  138.         memcpy(pData,m_pQueueBase+m_Head, nHeadToEndSize);  
  139.         memcpy(pData+nHeadToEndSize,m_pQueueBase,nReadSize-nHeadToEndSize);  
  140.     }  
  141.     m_Head=(m_Head+nReadSize) % m_QueueSize;  
  142.     LeaveCriticalSection(&m_csRW);  
  143.     return nReadSize;  
  144. }  
  145.   
  146. // 当前队列缓存的数据大小  
  147. int CCircularQueue::Size()  
  148. {  
  149.     return (m_Tail-m_Head+m_QueueSize) % m_QueueSize;  
  150. }  
  151.   
  152. // 队列是否为空  
  153. bool CCircularQueue::IsEmpty()  
  154. {  
  155.     return (m_Head == m_Tail) ? true : false;  
  156. }  
  157.   
  158. // 队列是否满   
  159. bool CCircularQueue::IsFull()  
  160. {  
  161.     return (((m_Tail+1) % m_QueueSize) == m_Head) ? true : false;  
  162. }  
  163.   
  164. // 队列当前剩余空间大小  
  165. int CCircularQueue::RemainSize()  
  166. {  
  167.     return ((m_QueueSize-1)-Size());  
  168. }  
  169.   
  170. // 打印数据  
  171. void CCircularQueue::PrintData()  
  172. {  
  173.     int tempHead, tempTail;  
  174.     tempHead = m_Head;  
  175.     tempTail = m_Tail;  
  176.     printf("************************************************\n");  
  177.     printf("CirualarQueue Data:");  
  178.     while(tempHead != tempTail)  
  179.     {  
  180.         printf("0x%02x ", m_pQueueBase[tempHead]);  
  181.         tempHead=(tempHead+1) % m_QueueSize;  
  182.     }  
  183.     printf("\n");  
  184.     printf("************************************************\n");  
  185. }  
  186.   
  187. // 重新调整队列大小  
  188. bool CCircularQueue::Resize(int nQueueSize)  
  189. {  
  190.     unsigned char *pNewQueue = NULL;  
  191.     // 申请新的队列空间  
  192.     pNewQueue = new unsigned char[nQueueSize];  
  193.     if(pNewQueue == NULL) // 申请内存失败  
  194.         return false;  
  195.     // 将队列原有数据拷贝到新队列中  
  196.     int len = PopFront(pNewQueue,nQueueSize);  
  197.     // 释放原来队列空间  
  198.     if(m_pQueueBase)  
  199.     {  
  200.         delete[] m_pQueueBase;  
  201.         m_pQueueBase = NULL;  
  202.     }  
  203.     // 使用新的队列空间  
  204.     m_pQueueBase = pNewQueue;  
  205.     m_QueueSize = nQueueSize;  
  206.     m_Head = 0;  
  207.     m_Tail = len;  
  208.     return true;  
  209. }  
顶
0
踩
0
 
 


STN_LCD
关注
专栏目录
循环队列实现高速缓存的读写
06-17 2908
// 循环队列实现高速缓存的读写// 教材上有对循环队列的讲解，不过头指针，尾指针重合的时候不好理解// 这里仿造标准库中的begin(),end()节点，使得头指针，为指针永远不重合，相对好理解点// 实现了对简单类型的数据的输入输出缓存，不支持CString，std::string等复杂类型，因为用的memcpy拷贝的数据templateclass CInputOutput
一篇文章讲清楚循环队列——循环队列是什么？有什么应用场景？怎么实现？
qq_42186650的博客
08-21 5787
相比于链队列，循环队列有着内存固定，效率高等特点，因而广泛应用于计算机的各个层面。本文主要介绍循环队列的概念，列举一些循环队列的应用场景，以及给出用数组实现循环队列的代码。本文介绍了循环队列的定义、使用场景和实现方式。大家可能疑问，为什么上边举例的场景不用链队列实现？比如用链队列实现流水线缓存，IO缓存等。我觉得是这样的：链队列一般是用于队列大小不固定的场景，而且依赖于操作系统给它分配资源。而流水线缓存，IO缓存等过于底层的东西，是比操作系统还底层的东西，我们难以给他们动态调度资源。
RingBuffer 循环缓存 亲测可用
12-17
运用技术： C++ 11 ，thread ，atomic ，mutex ，condition_variable 。 程序特性： 1.每个实例支持读写双线程。 2.数据一致。 3.ringbuffer为空时，读取时候等待。直到有数据写入，再继续读取。 4.当写入数据的长度大于ringbuffer的可写入长度时，多余的数据将会丢弃。所以写入数据前，先判断ringbuffer的可写入长度。 另外程序包含示例。 支持windows平台的vs与linux平台的clion，语言级别实现，与平台无关。 附件是代码工程，已编译。
[嵌入式开发模块]环形缓冲区/循环队列 C语言实现
热门推荐
夏日白云的boke
06-22 1万+
忙着毕设，很久没有写文章了，终于答辩完了，得了个校优秀毕业设计。毕设做的是个智能接口模块，用一周时间入门了，MC9S12XEP100的开发，又用一周时间入门了uC/OS-II嵌入式操作系统，在做毕设的过程中学到了很多，现在把一些工具发上来分享。 这里分享一个自己用纯C实现的环形缓冲区。环形缓冲区有很多作用，比如嵌入式中的通信可以用环形缓冲区作为信道，一个线程往里放字节，一个线程取字节进行处理...
模仿Linux内核kfifo实现的循环缓存
weixin_33894640的博客
11-16 138
想实现个循环缓冲区（Circular Buffer），搜了些资料多数是基于循环队列的实现方式。使用一个变量存放缓冲区中的数据长度或者空出来一个空间来判断缓冲区是否满了。偶然间看到分析Linux内核的循环缓冲队列kfifo的实现，确实极其巧妙。kfifo主要有以下特点： 保证缓冲空间的大小为2的次幂，不是的向上取整为2的次幂。 使用无符号整数保存输入(in)和输出(out)的位置，在输入输出时不对...
简单的双线程数组循环队列缓冲区的实现
苏湘的专栏
02-10 2042
目的，随机生成一千万用户信息。UserInfoGenerator.h文件：#include #define USER_BUF_SIZE 200#define MAX_USER_NUM 10000000//号段信息typedef struct{ char SegNo[10]; char AreaNo[10]; char Addr[20]
RingBuffer 循环缓存 亲测可用 V2 修改一处
12-17
4.当写入数据的长度大于ringbuffer的可写入长度时，多余的数据将会丢弃。所以写入数据前，先判断ringbuffer的可写入长度。另外程序包含示例。 支持windows平台的vs与linux平台的clion，语言级别实现，与平台无关。 ...
高性能的异步处理框架Disruptor(一)——认识RingBuffer与Disruptor
不能说的秘密的博客
10-09 1174
Disruptor是什么 Disruptor 是一个高性能的异步处理框架。 可以认为是最快的消息框架(轻量的 JMS)，也可以认为是一个观察者模式的实现，或者事件监听模式的实现。它允许开发者使用多线程技术去创建基于任务的工作流。Disruptor 能用来并行创建任务，同时保证多个处理过程的有序性。Disruptor 的目标就是快，高效。 ArrayBlockingQueue也是一个非常优秀的有界队...
Ring Buffer的常规用法（循环缓存区）
Wildfire（野火）的博客
08-26 1万+
Ring Buffer的常规用法与高级用法（一） 在涉及到模块与模块间数据传输缓存处理、通信程序中，经常使用环形缓冲区（Ring Buffer）作为数据结构来存放通信中发送和接收的数据，下面我将从以下几个方面介绍的是环形缓冲区（Ring Buffer）的常规用法与高级用法。 目录 Ring Buffer的常规用法与高级用法（一） 目录 环形缓冲区（Ring Buffer）的实现原理 ...
循环队列实现
技术成就梦想，梦想成就未来。If you try hard enough, it can be.
08-06 194
1、使用背景 假设有N个数据采集线程负责采集数据，有1个入库线程负责往数据库写数据，由于采集线程和入库线程是异步的，所以中间需要一个缓存区来作为采集线程和入库线程之间通信的桥梁，所以引入了循环队列。 2、N:1型场景 假设有N个采集线程，1个入库线程，架构图如下： 注意： （1）由于采集线程入队时，操作的是队尾，有N个线程同时操作队尾，所以需要对这N个采集线程上锁（任何时刻只有一个采...
数据结构 队列操作 C语言实现
03-03
数据结构中队列的操作很重要，这是本人用C语言编写的程序绝对原创！不能说经典但很实用！！
C语言之循环队列与队列的链式存储结构
wjjontheway的专栏
01-19 1655
https://blog.csdn.net/qq_43210174/article/details/93420038 https://zhuanlan.zhihu.com/p/53882098 https://www.jianshu.com/p/86a3ebca0875 https://www.cnblogs.com/wychen5/p/10445264.html https://blog.csd...
ffmpeg的内部Video Buffer管理和传送机制
xietao_live_cn的专栏
04-16 5055
本文主要介绍ffmpeg解码器内部管理Video Buffer的原理和过程，ffmpeg的Videobuffer为内部管理，其流程大致为：注册处理函数->帧级释放->帧级申请->清空。
循环队列的实现
Hansen的博客
04-30 824
需求描述：实现一个固定长度的字符缓存管理结构，实现字符串的写入和读出。 1）队列加数据，向cb尾追加长为length的字符串，存在putting中； 当缓冲剩余空间remain<length时，追加长为remain的字符串，函数返回实际有效存放到缓冲中的字符串； 2）队列取数据，在cb中读取长度为length的字符串，存于getting中；当队列存放的字符数used<length时，只读取长为used的字符串，读取字符串后，队列中相应缓冲不再使用。
一种多媒体框架中的零buffer拷贝实现机制
tugouxp的专栏
08-13 823
BUFFER管理是多媒体框架设计实现中的核心任务，在常见的多媒体框架，比如FFMPEG，GST等中，BUFFER管理的代码实现都是复杂且代码量非常大的部分。从某种意义上说，多媒体应用的核心在于BUFFER管理，一个高效易用的BUFFER管理框架不但可以提供友好的开发模型，而且还可以最大限度的挖掘VPU的计算能力，提高多媒体应用的效率。为什么可以通过零拷贝来优化多媒体框架？
【嵌入式基础】环形缓冲区ring buffer
最新发布
qq_36056498的博客
05-12 2171
嵌入式基础：环形缓冲区ring buffer
C++实现的一个循环队列
xiaoheqin的专栏
07-25 1763
工作之余写的一个简单的循环队列模板类。为什么要用循环duilei
队列的循环存储C实现
weixin_34256074的博客
04-05 183
队列是一种先进先出（FIFO）的线性表，只允许在一端（队尾）进行插入操作，另一端（队首）进行删除操作。 队列的顺序存储结构是用一组连续的地址空间存放队列元素。在队尾进行插入元素使空间不断减少，而在队首进行删除操作使空间增多。顺序队列的弊端在于增加的空闲空间不能重新利用，而循环队列的首尾连接在一起，进行删除操作增加的空间能够重新利用。 下面是代码：#incl...
音视频同步系列文章之----一种基于RTP协议的客户端媒体流Buffer管理思想（1）
stone_kingnet的专栏
11-01 1994
    一、简单介绍一下RTP协议实时传送协议（Real-time Transport Protocol或简写RTP）是一个网络传输协议，它是由IETF的多媒体传输工作小组1996年在RFC 1889中公布的。国际电信联盟ITU-T也发布了自己的RTP文档，作为H.225.0，但是后来当IETF发布了关于它的稳定的标准RFC后就被取消了。它作为因特网标准在RFC 3550（该文档的旧版本是RF
verilog实现乒乓buffer的数据缓存
07-16
乒乓缓存（Ping-Pong Buffer）是一种双缓冲区结构，用于在读写操作之间实现数据的缓存。在Verilog中，你可以通过使用两个存储器（如RAM）和一些控制逻辑来实现乒乓缓存。 下面是一个简单的Verilog代码示例，展示了如何实现乒乓缓存： ```verilog module PingPongBuffer ( input wire clk, // 时钟信号 input wire reset, // 复位信号 input wire write_en, // 写使能信号 input wire read_en, // 读使能信号 input wire data_in, // 写入数据 output wire data_out // 输出数据 ); reg [7:0] buffer1; // 存储器1，用于缓存数据 reg [7:0] buffer2; // 存储器2，用于缓存数据 reg select; // 选择信号，用于切换存储器 reg [7:0] output_data; // 输出数据 always @(posedge clk or posedge reset) begin if (reset) begin buffer1 <= 8'b0; // 复位缓存1 buffer2 <= 8'b0; // 复位缓存2 select <= 1'b0; // 设置初始选择为缓存1 output_data <= 8'b0; end else begin if (write_en) begin if (select) begin buffer2 <= data_in; // 写入数据到缓存2 end else begin buffer1 <= data_in; // 写入数据到缓存1 end end if (read_en) begin if (select) begin output_data <= buffer1; // 输出缓存1的数据 end else begin output_data <= buffer2; // 输出缓存2的数据 end end select <= ~select; // 切换存储器 end end assign data_out = output_data; // 输出数据 endmodule ``` 在这个示例中，我们使用了两个8位宽度的存储器（buffer1和buffer2）来实现乒乓缓存。在时钟上升沿触发的时候，根据写使能信号（write_en）和读使能信号（read_en），切换存储器并进行数据的读写操作。选择信号（select）用于切换当前使用的存储器。最后，输出数据（data_out）根据选择信号输出缓存中的数据。 请注意，这只是一个简单的示例，实际应用中可能需要更复杂的控制逻辑和数据宽度。此外，根据具体的需求，你可能还需要添加一些额外的功能，如错误检测、缓存满/空状态等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值