c、c++实现环形数据缓存区（视频帧数据为例）

最新推荐文章于 2023-10-22 00:39:08 发布
最新推荐文章于 2023-10-22 00:39:08 发布
阅读量800 收藏 5
点赞数
文章标签： c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bb_iot/article/details/129387889
版权

c、c++环形缓冲区

缓存区初始化

/**
 * buffer_init
 * 环形缓存去初始化接口
 * BUFFER_SIZE 缓存区大小
 * 
*/
void buffer_init()
{
    AVPACKETQ_BUFFER_P *buffer_pool =(AVPACKETQ_BUFFER_P*) calloc(1, sizeof(AVPACKETQ_BUFFER_P));
    buffer_pool->recorder_buffer = (uint8_t *)malloc(BUFFER_SIZE);
    buffer_pool->avpacket_list = new AVPACKET_LIST();
    buffer_pool->r_flag = true;
    buffer_pool->deq_data = (uint8_t* )malloc(AVPAKCET_BUFFER_SIZE);
    buffer_pool->recorder_buffer_list = new std::queue<recorder_buffer_data>;
}

数据接收区

/**
 * record_buffer_set_data_thread_proc
 * 数据无延时进队列，防止函数做耗时操作导致数据丢失
 * 适用于数据不可丢，且传输速度快的场景
*/

static void* record_buffer_set_data_thread_proc(void *argv)
{ 
    AVPACKETQ_BUFFER_P *buffer_p = (AVPACKETQ_BUFFER_P*)argv;
    if(!buffer_p) 
    {
        fprintf(stderr, " avpacket buffer is NULL\n");
        return NULL;
    }
    if(!buffer_p->avpacketq || !buffer_p->recorder_buffer) 
    {
        fprintf(stderr, " avpacket or recorder buffer is NULL\n");
        return NULL;
    }
    avpacket_info_t avpacket_info;
    recorder_buffer_data buffer_data;
    std::queue<recorder_buffer_data> recorder_buffer_list;
    static int pFrameCount = 0;
    while(buffer_p->r_flag)
    {
        avpacket_info.data = buffer_p->deq_data;
        avpacket_info.data_len = AVPAKCET_BUFFER_SIZE;
        buffer_data.iframe = avpacket_info.iframe;
        buffer_data.data_len = avpacket_info.data_len;
        buffer_data.pts = avpacket_info.ts;
        buffer_data.sn = avpacket_info.sn;
        memcpy(buffer_data.data, avpacket_info.data, packet_size);
        buffer_p->data_list_mutex.lock();
        buffer_p->recorder_buffer_list->push(buffer_data);
        buffer_p->data_list_mutex.unlock();
    }
    
}

数据存入环形缓存区业务处理函数

/**
 * record_buffer_get_data_thread_proc
 * 数据存入环形缓存区业务处理函数
 *
*/
static void* record_buffer_get_data_thread_proc(void *argv)   //数据进缓存区
{
    AVPACKETQ_BUFFER_P *buffer_p = (AVPACKETQ_BUFFER_P*)argv;
    if(!buffer_p) 
    {
        fprintf(stderr, " avpacket buffer is NULL\n");
        return NULL;
    }
    if(!buffer_p->avpacketq || !buffer_p->recorder_buffer) 
    {
        fprintf(stderr, " avpacket or recorder buffer is NULL\n");
        return NULL;
    }
    recorder_buffer_info_t buffer_info_t;
    unsigned long long Count_size = BUFFER_SIZE;
    while(buffer_p->r_flag)
    {
        if(buffer_p->recorder_buffer_list->empty())
        {
            usleep(100);
            continue;
        }
  
        recorder_buffer_data buffer_data_t;
        buffer_p->data_list_mutex.lock();
        buffer_data_t = buffer_p->recorder_buffer_list->front();
        buffer_p->data_list_mutex.unlock();
        buffer_info_t.iframe = buffer_data_t.iframe;
        buffer_info_t.data_len = buffer_data_t.data_len;
        buffer_info_t.pts = buffer_data_t.pts;
        buffer_info_t.sn = buffer_data_t.sn;

        if(buffer_p->avpacket_list->empty())   //判断数据缓冲区是否为空
        {
            memcpy(buffer_p->recorder_buffer, buffer_data_t.data, buffer_data_t.data_len);
            buffer_info_t.data = buffer_p->recorder_buffer ;
            buffer_p->avpacket_list->push_back(buffer_info_t);
            Count_size -=  buffer_data_t.data_len;

        }else 
        {
            recorder_buffer_info_t buffer_front = buffer_p->avpacket_list->at(1);
            if(buffer_front.data_len == -1) 
            {
                fprintf(stderr, " %s 头数据为空   %d   %d\n",buffer_p->avpacketq->name, buffer_p->avpacket_list->empty(), buffer_p->avpacket_list->size());
                buffer_p->avpacket_list->pop_front();
                continue;
            }
            recorder_buffer_info_t buffer_back = buffer_p->avpacket_list->at(buffer_p->avpacket_list->size());
            if(buffer_back.data_len == -1) 
            {
                fprintf(stderr, " %s 尾数据为空  size:%d\n",buffer_p->avpacketq->name, buffer_p->avpacket_list->size());
                buffer_p->avpacket_list->pop_back();
                continue;
            }

            // 顺序存储
            if(buffer_back.data - buffer_front.data >= 0)
            {

                if(BUFFER_SIZE - (buffer_back.data + buffer_back.data_len - buffer_p->recorder_buffer) >=  buffer_data_t.data_len) //无需覆盖
                {
                    memcpy(buffer_back.data + buffer_back.data_len, buffer_data_t.data, buffer_data_t.data_len);
                    buffer_info_t.data = buffer_back.data + buffer_back.data_len ;
                    buffer_p->avpacket_list->push_back(buffer_info_t);
                    Count_size -=  buffer_data_t.data_len;
                }
                else //存储满，重头来
                {
                    /*  
                        循环出队，直到I帧之前可以放入新的数据帧
                    */
                    while(buffer_p->r_flag)
                    {
                        recorder_buffer_info_t buffer_temp = buffer_p->avpacket_list->at(1);
                        if(buffer_temp.data_len == -1) 
                        {
                            fprintf(stderr, " [%s]1 buffer_temp data is Null %d   %d\n", buffer_p->avpacketq->name, buffer_p->avpacket_list->empty(), buffer_p->avpacket_list->size());
                            if(buffer_p->avpacket_list->empty())
                                break;
                            buffer_p->avpacket_list->pop_front();
                            continue;
                        }
                        if(buffer_temp.iframe)
                        {
                            //    fprintf(stderr, " channl:%s  data size :%d   pts:%llu   list size:%d  buffer_temp data:%p  buffer_back:%p  bufferpool:%p  Count_size:%llu\n", buffer_p->avpacketq->name, packet_size, avpacket_info.ts, buffer_p->avpacket_list->size(),  buffer_p->avpacket_list->at(1).data, buffer_p->avpacket_list->at(buffer_p->avpacket_list->size()).data + buffer_p->avpacket_list->at(buffer_p->avpacket_list->size()).data_len, buffer_p->recorder_buffer, Count_size);
                            if((buffer_temp.data - buffer_back.data < 0) &&  (buffer_temp.data - buffer_p->recorder_buffer >=  buffer_data_t.data_len))
                            {
                                memcpy(buffer_p->recorder_buffer,buffer_data_t.data, buffer_data_t.data_len);
                                buffer_info_t.data = buffer_p->recorder_buffer ;
                                buffer_p->avpacket_list->push_back(buffer_info_t);
                                Count_size -=  buffer_data_t.data_len;
                                break;
                            }
                  
                        }
                        buffer_p->avpacket_list->pop_front();
                        Count_size += buffer_temp.data_len;
                    }    
                }

            }else //覆盖存储
            {
                if(buffer_front.data - (buffer_back.data + buffer_back.data_len) >=  buffer_data_t.data_len)  //判断中间剩余空间是否足够本帧数据存储
                {
                    memcpy(buffer_back.data + buffer_back.data_len, buffer_data_t.data, buffer_data_t.data_len);
                    buffer_info_t.data = buffer_back.data + buffer_back.data_len;
                    buffer_p->avpacket_list->push_back(buffer_info_t);
                    Count_size -=  buffer_data_t.data_len;
                }else
                {
                    while(buffer_p->r_flag)
                    {
                        int sum_size = 0;
                        recorder_buffer_info_t buffer_temp = buffer_p->avpacket_list->at(1);

                        if(buffer_temp.data_len == -1) 
                        {
                            
                            fprintf(stderr, " [%s]2 buffer_temp data is Null %d   %d   next:%d\n", buffer_p->avpacketq->name, buffer_p->avpacket_list->empty(), buffer_p->avpacket_list->size(), buffer_p->avpacket_list->at(2).data_len);
                            if(buffer_p->avpacket_list->empty())
                                break;
                            buffer_p->avpacket_list->pop_front();
                            Count_size += buffer_temp.data_len;
                            continue;
                        }
                        /*  
                           找到缓冲数据区 顺序路径 最后一个数据 
                           判断是否是I帧
                             是：I帧之前是否够新的数据帧 
                             不是I帧或不够新的数据帧插入，出队

                        */
                        sum_size += buffer_temp.data_len;
                        if(buffer_temp.data - buffer_p->avpacket_list->at(2).data < 0)
                        {
                            if(buffer_temp.iframe)
                            {
                                if(buffer_temp.data - (buffer_back.data + buffer_back.data_len) >=  buffer_data_t.data_len)
                                {
                                    memcpy(buffer_back.data + buffer_back.data_len, buffer_data_t.data, buffer_data_t.data_len);
                                    buffer_info_t.data = buffer_back.data + buffer_back.data_len ;
                                    buffer_p->avpacket_list->push_back(buffer_info_t);
                                    Count_size -=  buffer_data_t.data_len;
                                    break;
                                }
                            }

                        }else
                        {
                            /*  
                                缓冲区 数据队尾直到最后 不够新的数据帧插入；即 重头存储
                                1、是否I帧
                                    I帧之前是否够新的数据帧 
                                    不是I帧或不够新的数据帧插入，出队
                                2、队尾数据直到最后 是否足够新的数据帧插入
                                    够，插入新的数据帧， 并出队直至I帧
                                    不够，出队直至I帧，判断I帧之前是否够新的数据插入

                            */
                            
                            if(buffer_temp.iframe)
                            {
                                if(buffer_temp.data - (buffer_back.data + buffer_back.data_len) >=  buffer_data_t.data_len)
                                {
                                    memcpy(buffer_back.data + buffer_back.data_len, buffer_data_t.data, buffer_data_t.data_len);
                                    buffer_info_t.data = buffer_back.data + buffer_back.data_len ;
                                    buffer_p->avpacket_list->push_back(buffer_info_t);
                                    Count_size -=  buffer_data_t.data_len;
                                    break;
                                }
                            }
                            if((BUFFER_SIZE - (buffer_back.data + buffer_back.data_len - buffer_p->recorder_buffer)) >=  buffer_data_t.data_len)
                            {
                                memcpy(buffer_back.data + buffer_back.data_len, buffer_data_t.data, buffer_data_t.data_len);
                                buffer_info_t.data = buffer_back.data + buffer_back.data_len ;
                                buffer_p->avpacket_list->push_back(buffer_info_t);
                                Count_size -=  buffer_data_t.data_len;
                                while(buffer_p->r_flag)
                                {
                                    buffer_p->avpacket_list->pop_front();
                                    buffer_temp = buffer_p->avpacket_list->at(1);
                                    Count_size += buffer_temp.data_len;
                                    if(buffer_temp.iframe)
                                    {
                                        break;
                                    }
                                }
                                break;  
                            }else
                            {
                                while(buffer_p->r_flag)
                                {
                                    buffer_p->avpacket_list->pop_front();
                                    buffer_temp = buffer_p->avpacket_list->at(1);
                                    if(buffer_temp.iframe)
                                    {
                                        if(buffer_temp.data - buffer_p->recorder_buffer >=  buffer_data_t.data_len)
                                        {
                                            memcpy(buffer_p->recorder_buffer, buffer_data_t.data, buffer_data_t.data_len);
                                            buffer_info_t.data = buffer_p->recorder_buffer ;
                                            buffer_p->avpacket_list->push_back(buffer_info_t);
                                            Count_size -=  buffer_data_t.data_len;
                                            break;
                                        }
                                        
                                    }
                                }
                                break;
                            }
                            
                        }
                        Count_size += buffer_temp.data_len;
                        buffer_p->avpacket_list->pop_front();
                        }  
                
                }
            }
        }
        buffer_p->data_list_mutex.lock();
        buffer_p->recorder_buffer_list->pop();
        buffer_p->data_list_mutex.unlock(); 
    }
   return NULL;
}

完整代码

1、avpack_list.cpp

#include <iostream>
#include "avpack_list.h"
// //链表节点结构体 
// typedef struct stData
// {
//     recorder_buffer_info_t data;
//     struct stData *pNext;
// }stData;


// static AVPACKET_LIST *avpacket_list;
AVPACKET_LIST::AVPACKET_LIST()
{
    buffer_null.data = NULL;
    buffer_null.data_len = -1;
	buffer_null.sn = 0;
	buffer_null.pts = 0;
    this->head = new Node;    //给头结点指针实例化一个结点
	this->head->data = buffer_null;   //头结点数据，头结点一般不存放数据
	this->head->next = this->head;  //头结点指针指向自己
	this->counter = 0;        //未插入数据前，元素个数为0

}

AVPACKET_LIST::~AVPACKET_LIST()
{
    if (this->counter == 0)
	{
		delete head;
	}
	else
	{
		Node* temp = this->head->next;
		Node* temp2 = NULL;
 
 
		while (temp != this->head)
		{
			temp2 = temp->next;
			delete temp;
			temp = temp2;
		}
		delete temp;
	}
}
//判断链表是否为空，为空返回1，不为空返回0
bool AVPACKET_LIST::empty()
{
    std::lock_guard<std::mutex> lock(list_mtx);
	if (this->head->next == this->head || this->head == NULL)//(头结点不算做链表中的元素，因此在此若只有头结点也算空链表)
	{
		return true;
	}
	else
	{
		return false;
	}
}
//返回链表元素个数
int AVPACKET_LIST::size()
{
    std::lock_guard<std::mutex> lock(list_mtx);
	return this->counter;
}
//打印遍历整个链表
void AVPACKET_LIST::traverse()
{
    std::lock_guard<std::mutex> lock(list_mtx);
	Node* temp = this->head->next;//创建一个结点指针遍历每个结点
	while (temp != this->head)
	{
		// cout << temp->data << " ";
		temp = temp->next;
	}
	// cout << endl;
}
//清空链表
void AVPACKET_LIST::clear()
{
    std::lock_guard<std::mutex> lock(list_mtx);
	if (this->counter == 0)
	{
		return;
	}
	Node* temp = this->head->next;
	Node* temp2 = NULL;
 
	while (temp != this->head)
	{
		temp2 = temp->next;
		delete temp;
		temp = temp2;
	}
	this->head->next = head;
	this->counter = 0;
}
//头插
void AVPACKET_LIST::push_front(recorder_buffer_info_t newelem)
{
    std::lock_guard<std::mutex> lock(list_mtx);
	if (this->head == NULL)
	{
		return;
	}
	Node* newnode = new Node;
	newnode->data = newelem;
	newnode->next = this->head->next;
	this->head->next = newnode;
	this->counter = this->counter + 1;//元素个数加一
}
//尾插
void AVPACKET_LIST::push_back(recorder_buffer_info_t newelem)
{
    std::lock_guard<std::mutex> lock(list_mtx);
	if (this->head == NULL)
	{
		return;
	}
	Node* newnode = new Node;
	Node* temp = head;
	newnode->data = newelem;
	newnode->next = this->head;
	for (int i = 0; i < this->counter; i++)
	{
		temp = temp->next;
	}
	temp->next = newnode;
	this->counter = this->counter + 1;//元素个数加一
}
//头删
void AVPACKET_LIST::pop_front()
{
    std::lock_guard<std::mutex> lock(list_mtx);
	if (this->head == NULL || this->counter == 0)
	{
		return;
	}
	Node* temp;
	temp = this->head->next;
	this->head->next = temp->next;
	delete temp;
	this->counter = this->counter - 1;//元素个数减一
}
//尾删
void AVPACKET_LIST::pop_back()
{
    std::lock_guard<std::mutex> lock(list_mtx);
	if (this->head == NULL || this->counter == 0)
	{
		return;
	}
	Node* temp = this->head;
	Node* temp2;
	for (int i = 1; i < this->counter; i++)
	{
		temp = temp->next;
	}
	temp2 = temp->next;
	temp->next = this->head;
	delete temp2;
	this->counter = this->counter - 1;//元素个数减一
}
//任意位置插入
void AVPACKET_LIST::insert(int pos, recorder_buffer_info_t newelem)
{
    std::lock_guard<std::mutex> lock(list_mtx);
	if (this->head == NULL || pos > this->counter)
	{
		return;
	}
	Node* newnode = new Node;
	Node* temp = head;
	newnode->data = newelem;
	for (int i = 1; i < pos; i++)
	{
		temp = temp->next;
 
	}
	newnode->next = temp->next;
	temp->next = newnode;
	this->counter = this->counter + 1;//元素个数加一
}
//任意位置删除
void AVPACKET_LIST::erase(int pos)
{
    std::lock_guard<std::mutex> lock(list_mtx);
	if (this->head == NULL || pos > this->counter)
	{
		return;
	}
	Node* temp = this->head;
	Node* temp2;
	for (int i = 1; i < pos; i++)
	{
		temp = temp->next;
	}
	temp2 = temp->next;
	temp->next = temp2->next;
	delete temp2;
	this->counter = this->counter - 1;//元素个数减一
}
//返回索引位置数据
recorder_buffer_info_t AVPACKET_LIST::at(int pos)
{
    std::lock_guard<std::mutex> lock(list_mtx);
	if (this->head == NULL || pos > this->counter)
	{
		return buffer_null;
	}
	Node* temp = head;
	for (int i = 0; i < pos; i++)
	{
		temp = temp->next;
	}
	return temp->data;
}
//重载[]，返回索引位置数据
recorder_buffer_info_t AVPACKET_LIST::operator[](int pos)
{
    std::lock_guard<std::mutex> lock(list_mtx);
	if (this->head == NULL || pos > this->counter)
	{
		return buffer_null;
	}
	Node* temp = head;
	for (int i = 0; i < pos; i++)
	{
		temp = temp->next;
	}
	return temp->data;
}

2、avpack_list.h

#ifndef __AVPACK_LIST_H__
#define __AVPACK_LIST_H__
#include <mutex>

typedef struct recorder_buffer_info {
	uint8_t *data;  // 数据存储区
	int data_len;   // 数据长度
	int iframe;   // 贞的类别，是否为 I 贞， 1 表示当前包是 I 贞， 0 则不是
    unsigned long long pts; // 时间戳:单位 微妙
    unsigned long long sn; // 序列码
} recorder_buffer_info_t;


//创建结点类
class Node
{
public:
	recorder_buffer_info_t data; //结点中的数据域
	Node* next;    //结点中的指针域，结点类型的指针
};

class AVPACKET_LIST
{
    public:
        AVPACKET_LIST();
        ~AVPACKET_LIST();
        bool empty();//判断链表是否为空，为空返回1，不为空返回0
        int size();//返回链表元素个数
        void traverse();//打印遍历整个链表
        void clear();//清空链表
        void push_front(recorder_buffer_info_t);//头插
        void push_back(recorder_buffer_info_t);//尾插
        void pop_front();//头删
        void pop_back();//尾删
        void insert(int, recorder_buffer_info_t);//任意位置插入
        void erase(int);//删除任意位置元素
        recorder_buffer_info_t at(int);//返回索引位置数据
        recorder_buffer_info_t operator[](int);//重载[]，返回索引位置数据
    
        int counter;//链表元素个数
        Node* head;//创建头结点指针，结点类型指针，当前未赋值
    private:
        std::mutex list_mtx;
        recorder_buffer_info_t buffer_null;
        
};

#endif

3、业务

#include "avpack_list.h"

typedef struct _recorder_buffer_info {
	uint8_t data[1024*1024];  // 数据存储区
	int data_len;   // 数据长度
	int iframe;   // 贞的类别，是否为 I 贞， 1 表示当前包是 I 贞， 0 则不是
    unsigned long long pts; // 时间戳:单位 微妙
    unsigned long long sn; // 序列码
} recorder_buffer_data;

typedef struct _AVPACKETQ_BUFFER_P{

    bool r_flag = false;
    pthread_t pthread;
    pthread_t pthread_set_data;

    avpacketq_t *avpacketq;

    pthread_mutex_t mtx_lock;
    uint8_t *recorder_buffer;
    AVPACKET_LIST *avpacket_list;
    uint8_t * deq_data;
    std::mutex data_list_mutex;
    std::queue<recorder_buffer_data>* recorder_buffer_list ;
} AVPACKETQ_BUFFER_P;


/**
 * buffer_init
 * 环形缓存去初始化接口
 * BUFFER_SIZE 缓存区大小
 * 
*/
void buffer_init()
{
    AVPACKETQ_BUFFER_P *buffer_pool =(AVPACKETQ_BUFFER_P*) calloc(1, sizeof(AVPACKETQ_BUFFER_P));
    buffer_pool->recorder_buffer = (uint8_t *)malloc(BUFFER_SIZE);
    buffer_pool->avpacket_list = new AVPACKET_LIST();
    buffer_pool->r_flag = true;
    buffer_pool->deq_data = (uint8_t* )malloc(AVPAKCET_BUFFER_SIZE);
    buffer_pool->recorder_buffer_list = new std::queue<recorder_buffer_data>;
}

/**
 * record_buffer_set_data_thread_proc
 * 数据无延时进队列，防止函数做耗时操作导致数据丢失
 * 适用于数据不可丢，且传输速度快的场景
*/

static void* record_buffer_set_data_thread_proc(void *argv)
{ 
    AVPACKETQ_BUFFER_P *buffer_p = (AVPACKETQ_BUFFER_P*)argv;
    if(!buffer_p) 
    {
        fprintf(stderr, " avpacket buffer is NULL\n");
        return NULL;
    }
    if(!buffer_p->avpacketq || !buffer_p->recorder_buffer) 
    {
        fprintf(stderr, " avpacket or recorder buffer is NULL\n");
        return NULL;
    }
    avpacket_info_t avpacket_info;
    recorder_buffer_data buffer_data;
    std::queue<recorder_buffer_data> recorder_buffer_list;
    static int pFrameCount = 0;
    while(buffer_p->r_flag)
    {
        avpacket_info.data = buffer_p->deq_data;
        avpacket_info.data_len = AVPAKCET_BUFFER_SIZE;
        buffer_data.iframe = avpacket_info.iframe;
        buffer_data.data_len = avpacket_info.data_len;
        buffer_data.pts = avpacket_info.ts;
        buffer_data.sn = avpacket_info.sn;
        memcpy(buffer_data.data, avpacket_info.data, packet_size);
        buffer_p->data_list_mutex.lock();
        buffer_p->recorder_buffer_list->push(buffer_data);
        buffer_p->data_list_mutex.unlock();
    }
    
}
/**
 * record_buffer_get_data_thread_proc
 * 数据存入环形缓存区业务处理函数
 *
*/
static void* record_buffer_get_data_thread_proc(void *argv)   //数据进缓存区
{
    AVPACKETQ_BUFFER_P *buffer_p = (AVPACKETQ_BUFFER_P*)argv;
    if(!buffer_p) 
    {
        fprintf(stderr, " avpacket buffer is NULL\n");
        return NULL;
    }
    if(!buffer_p->avpacketq || !buffer_p->recorder_buffer) 
    {
        fprintf(stderr, " avpacket or recorder buffer is NULL\n");
        return NULL;
    }
    recorder_buffer_info_t buffer_info_t;
    unsigned long long Count_size = BUFFER_SIZE;
    while(buffer_p->r_flag)
    {
        if(buffer_p->recorder_buffer_list->empty())
        {
            usleep(100);
            continue;
        }
  
        recorder_buffer_data buffer_data_t;
        buffer_p->data_list_mutex.lock();
        buffer_data_t = buffer_p->recorder_buffer_list->front();
        buffer_p->data_list_mutex.unlock();
        buffer_info_t.iframe = buffer_data_t.iframe;
        buffer_info_t.data_len = buffer_data_t.data_len;
        buffer_info_t.pts = buffer_data_t.pts;
        buffer_info_t.sn = buffer_data_t.sn;

        if(buffer_p->avpacket_list->empty())   //判断数据缓冲区是否为空
        {
            memcpy(buffer_p->recorder_buffer, buffer_data_t.data, buffer_data_t.data_len);
            buffer_info_t.data = buffer_p->recorder_buffer ;
            buffer_p->avpacket_list->push_back(buffer_info_t);
            Count_size -=  buffer_data_t.data_len;

        }else 
        {
            recorder_buffer_info_t buffer_front = buffer_p->avpacket_list->at(1);
            if(buffer_front.data_len == -1) 
            {
                fprintf(stderr, " %s 头数据为空   %d   %d\n",buffer_p->avpacketq->name, buffer_p->avpacket_list->empty(), buffer_p->avpacket_list->size());
                buffer_p->avpacket_list->pop_front();
                continue;
            }
            recorder_buffer_info_t buffer_back = buffer_p->avpacket_list->at(buffer_p->avpacket_list->size());
            if(buffer_back.data_len == -1) 
            {
                fprintf(stderr, " %s 尾数据为空  size:%d\n",buffer_p->avpacketq->name, buffer_p->avpacket_list->size());
                buffer_p->avpacket_list->pop_back();
                continue;
            }

            // 顺序存储
            if(buffer_back.data - buffer_front.data >= 0)
            {

                if(BUFFER_SIZE - (buffer_back.data + buffer_back.data_len - buffer_p->recorder_buffer) >=  buffer_data_t.data_len) //无需覆盖
                {
                    memcpy(buffer_back.data + buffer_back.data_len, buffer_data_t.data, buffer_data_t.data_len);
                    buffer_info_t.data = buffer_back.data + buffer_back.data_len ;
                    buffer_p->avpacket_list->push_back(buffer_info_t);
                    Count_size -=  buffer_data_t.data_len;
                }
                else //存储满，重头来
                {
                    /*  
                        循环出队，直到I帧之前可以放入新的数据帧
                    */
                    while(buffer_p->r_flag)
                    {
                        recorder_buffer_info_t buffer_temp = buffer_p->avpacket_list->at(1);
                        if(buffer_temp.data_len == -1) 
                        {
                            fprintf(stderr, " [%s]1 buffer_temp data is Null %d   %d\n", buffer_p->avpacketq->name, buffer_p->avpacket_list->empty(), buffer_p->avpacket_list->size());
                            if(buffer_p->avpacket_list->empty())
                                break;
                            buffer_p->avpacket_list->pop_front();
                            continue;
                        }
                        if(buffer_temp.iframe)
                        {
                            //    fprintf(stderr, " channl:%s  data size :%d   pts:%llu   list size:%d  buffer_temp data:%p  buffer_back:%p  bufferpool:%p  Count_size:%llu\n", buffer_p->avpacketq->name, packet_size, avpacket_info.ts, buffer_p->avpacket_list->size(),  buffer_p->avpacket_list->at(1).data, buffer_p->avpacket_list->at(buffer_p->avpacket_list->size()).data + buffer_p->avpacket_list->at(buffer_p->avpacket_list->size()).data_len, buffer_p->recorder_buffer, Count_size);
                            if((buffer_temp.data - buffer_back.data < 0) &&  (buffer_temp.data - buffer_p->recorder_buffer >=  buffer_data_t.data_len))
                            {
                                memcpy(buffer_p->recorder_buffer,buffer_data_t.data, buffer_data_t.data_len);
                                buffer_info_t.data = buffer_p->recorder_buffer ;
                                buffer_p->avpacket_list->push_back(buffer_info_t);
                                Count_size -=  buffer_data_t.data_len;
                                break;
                            }
                  
                        }
                        buffer_p->avpacket_list->pop_front();
                        Count_size += buffer_temp.data_len;
                    }    
                }

            }else //覆盖存储
            {
                if(buffer_front.data - (buffer_back.data + buffer_back.data_len) >=  buffer_data_t.data_len)  //判断中间剩余空间是否足够本帧数据存储
                {
                    memcpy(buffer_back.data + buffer_back.data_len, buffer_data_t.data, buffer_data_t.data_len);
                    buffer_info_t.data = buffer_back.data + buffer_back.data_len;
                    buffer_p->avpacket_list->push_back(buffer_info_t);
                    Count_size -=  buffer_data_t.data_len;
                }else
                {
                    while(buffer_p->r_flag)
                    {
                        int sum_size = 0;
                        recorder_buffer_info_t buffer_temp = buffer_p->avpacket_list->at(1);

                        if(buffer_temp.data_len == -1) 
                        {
                            
                            fprintf(stderr, " [%s]2 buffer_temp data is Null %d   %d   next:%d\n", buffer_p->avpacketq->name, buffer_p->avpacket_list->empty(), buffer_p->avpacket_list->size(), buffer_p->avpacket_list->at(2).data_len);
                            if(buffer_p->avpacket_list->empty())
                                break;
                            buffer_p->avpacket_list->pop_front();
                            Count_size += buffer_temp.data_len;
                            continue;
                        }
                        /*  
                           找到缓冲数据区 顺序路径 最后一个数据 
                           判断是否是I帧
                             是：I帧之前是否够新的数据帧 
                             不是I帧或不够新的数据帧插入，出队

                        */
                        sum_size += buffer_temp.data_len;
                        if(buffer_temp.data - buffer_p->avpacket_list->at(2).data < 0)
                        {
                            if(buffer_temp.iframe)
                            {
                                if(buffer_temp.data - (buffer_back.data + buffer_back.data_len) >=  buffer_data_t.data_len)
                                {
                                    memcpy(buffer_back.data + buffer_back.data_len, buffer_data_t.data, buffer_data_t.data_len);
                                    buffer_info_t.data = buffer_back.data + buffer_back.data_len ;
                                    buffer_p->avpacket_list->push_back(buffer_info_t);
                                    Count_size -=  buffer_data_t.data_len;
                                    break;
                                }
                            }

                        }else
                        {
                            /*  
                                缓冲区 数据队尾直到最后 不够新的数据帧插入；即 重头存储
                                1、是否I帧
                                    I帧之前是否够新的数据帧 
                                    不是I帧或不够新的数据帧插入，出队
                                2、队尾数据直到最后 是否足够新的数据帧插入
                                    够，插入新的数据帧， 并出队直至I帧
                                    不够，出队直至I帧，判断I帧之前是否够新的数据插入

                            */
                            
                            if(buffer_temp.iframe)
                            {
                                if(buffer_temp.data - (buffer_back.data + buffer_back.data_len) >=  buffer_data_t.data_len)
                                {
                                    memcpy(buffer_back.data + buffer_back.data_len, buffer_data_t.data, buffer_data_t.data_len);
                                    buffer_info_t.data = buffer_back.data + buffer_back.data_len ;
                                    buffer_p->avpacket_list->push_back(buffer_info_t);
                                    Count_size -=  buffer_data_t.data_len;
                                    break;
                                }
                            }
                            if((BUFFER_SIZE - (buffer_back.data + buffer_back.data_len - buffer_p->recorder_buffer)) >=  buffer_data_t.data_len)
                            {
                                memcpy(buffer_back.data + buffer_back.data_len, buffer_data_t.data, buffer_data_t.data_len);
                                buffer_info_t.data = buffer_back.data + buffer_back.data_len ;
                                buffer_p->avpacket_list->push_back(buffer_info_t);
                                Count_size -=  buffer_data_t.data_len;
                                while(buffer_p->r_flag)
                                {
                                    buffer_p->avpacket_list->pop_front();
                                    buffer_temp = buffer_p->avpacket_list->at(1);
                                    Count_size += buffer_temp.data_len;
                                    if(buffer_temp.iframe)
                                    {
                                        break;
                                    }
                                }
                                break;  
                            }else
                            {
                                while(buffer_p->r_flag)
                                {
                                    buffer_p->avpacket_list->pop_front();
                                    buffer_temp = buffer_p->avpacket_list->at(1);
                                    if(buffer_temp.iframe)
                                    {
                                        if(buffer_temp.data - buffer_p->recorder_buffer >=  buffer_data_t.data_len)
                                        {
                                            memcpy(buffer_p->recorder_buffer, buffer_data_t.data, buffer_data_t.data_len);
                                            buffer_info_t.data = buffer_p->recorder_buffer ;
                                            buffer_p->avpacket_list->push_back(buffer_info_t);
                                            Count_size -=  buffer_data_t.data_len;
                                            break;
                                        }
                                        
                                    }
                                }
                                break;
                            }
                            
                        }
                        Count_size += buffer_temp.data_len;
                        buffer_p->avpacket_list->pop_front();
                        }  
                
                }
            }
        }
        buffer_p->data_list_mutex.lock();
        buffer_p->recorder_buffer_list->pop();
        buffer_p->data_list_mutex.unlock(); 
    }
   return NULL;
}
bb_iot
关注
360_C++_录像数据的缓存管理和读取处理.h部分 + 内存管理机制的cpp部分
HanLongXia的博客
08-27 97
录像数据的缓存管理和读取处理
环形缓冲区C语言实现
技术联盟
01-12 3180
////////////////////////////////////////////////////////////////////////////////// typedef unsigned char u8; typedef unsigned int u32; #define BUFFER_SIZE (1024*500) //缓冲区的长度,可以修改 static u32 vali...
C++环形缓冲区
Lao_tan的博客
06-27 3756
C++实现环形缓冲区
C++实现环形缓冲区
wisdomroc的博客
05-23 344
环形缓冲区
缓冲区设计--环形队列
热门推荐
海涛的专栏
08-07 2万+
在程序的两个模块间进行通讯的时候，缓冲区成为一个经常使用的机制。 如上图，写入模块将信息写入缓冲区中，读出模块将信息读出缓冲区。这样使得：将程序清晰地划分模块，建立良好的模块化架构，使得写入和读出成为高聚合，低耦合的模块。对于写入和读出的处理可能产生的快慢不均匀的情况进行平衡，使得整个处理的速度趋于平滑的均匀状态
一个c++环形队列缓冲区
11-30
环形缓冲区读写操作的分析与实现，以及在并发条件下如何控制竞争
一个封装好的C++环形缓冲区
11-30
用C++封装好的一个环形缓冲区代码，各位需要的可以拿去
C++环形缓冲区模板代码
11-30
一个C++缓冲区模板类,循环队列实现，循环法抛弃最先进缓冲区的数据
【C/C++ 软件开发模拟面试 集】RTSP和RTMP 相关知识点模拟面试
最新发布
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
10-22 296
【C/C++ 软件开发模拟面试 集】RTSP和RTMP 相关知识点模拟面试
C++后端开发知识点汇总
weixin_42947653的博客
11-15 2868
1.进程与线程的本质区别、以及各自的使用场景。 线程是进程的一部分，进程是程序的一部分。进程是分配资源的基本单位；线程是系统调度和分派的基本单位> 异同点： 进程是资源分配的基本单位，而线程是调度的基本单位。 进程与进程之间是独立的，一个进程的异常终止不会影响其它进程，而线程与线程之间大部分是共享的，一个线程的异常终止会影响其它线程，会使进程终止。 调度和切换：线程上下文切换比进程上下文切...
C++面试题个人汇总
qq_41046887的博客
11-16 517
有一些是自己总结的，有一些是借鉴前辈们的文章的，希望能给大家带来帮助。 目录 一、 基础 面向对象的特征 继承关系 虚继承与虚基类 使一个类不能继承的方法 多态 虚函数定义以及其作用 虚函数表 不能声明为虚函数的函数 构造函数、析构函数与抛出异常 纯虚函数 虚函数与纯虚函数的区别？ C++源文件从文本到可执行文件经历的过程 编译期间的错误、链接期间的错误 C++11新特性 智能指针 Static的用法 Const的用法 强制类型转换 模板 C++内存管理 堆与栈的区别 malloc底层原理 new的操作原
环形缓冲区
05-10
环形缓冲区 内部有内存维护机制，可应用于频繁的内存释放和申请，我应用在流媒体音视频上，代码简单易懂，适合新人学习，不足地方欢迎指教。谢谢
优先级队列对C ++使用环形缓冲区，固定长度-C/C++开发
05-27
优先级队列对c ++使用环形缓冲区，固定长度container :: RingQueue C ++的环形优先级队列。 具有类似STL的单头实现。 只需将其放入您的项目中即可。 不是线程安全的C ++ 11实现完全可移植自排序，例如std :: set基本用法整个队列的实现包含在一个标头ring_list.h中。 简单示例：#include“ ring_queue.h”容器:: RingQueue q; q.push（2）; q.push（1）; assert（q.front（）== 1）; q.pop（）; q.clear（）; 方法说明：push（const T＆value）插入一个元素
【DPDK】DPDK（数据层开发套件）简介--编辑中
小鱼菜鸟的博客
08-15 621
1. DPDK介绍 1) 简介 DPDK全称Intel Data Plane Development Kit，是intel提供的数据层开发套件工具集，是Intel 处理器架构下用户空间高效的数据包处理的库函数和驱动。通俗地说，就是包数据处理加速的软件库。 DPDK不同于Linux系统以通用性设计为目的，而是专注于高性能的处理网络应用中的数据包。具体...
C++ 环形缓冲区（队列）简单实现
thequitesunshine007的博客
10-25 2770
1. 说明 在实际工作中，如果数据流量过大，可以先把数据接收到数据缓冲区中，处理之后再取出。我们定义的包协议可以采用定长包，可以采用不定长度的包，环形缓冲区都能处理。 2. 使用场景 2.1 生产消费的场所 在 “生产者--消费者”模式中，往往会用到这种环形缓冲区的功能。 2.2 线程间高速通信的场所 3. 使用的局限性 主要适用于单向传输。不太适用于双向传输的情形。 4. 代码展示 CircleBuffer.h #pragma once # include <stdint.h&
环形缓冲区ringbuffer c++类模版实现
小段孩
12-23 2744
@ringbuffer 环形缓冲区ringbuffer c++类模版实现 使用方法： 1、将ringBuffer.h文件拷贝到开发工程中，添加相应的头文件 2、需要g++编译器（开发的项目工程需要支持），编译此类模版 3、支持int、char、bool等类型 #pragma once #include &amp;amp;amp;amp;amp;quot;stdlib.h&amp;amp;amp;amp;amp;quot; #include &amp;amp
C++ 环形缓冲区RingBuffer 简单实现
搬砖小能手
02-18 1万+
C++环形缓冲区RingBuffer的简单实现
2021-09-13嵌入式学习笔记--基于C++的环形缓冲区demo
jeason的博客
09-16 460
最近学习了韦东山老师的RTOS训练营相关的知识后想自己实现一下环形缓冲区，具体的实现如下： 注意： 缓冲区的大小要比实际的小一个！ 我也是查了半天才知道的！ 代码中对于未使用的空间写入了 -1 主要是方便查看，如果实际的应用中可以去掉 这一步 降低资源开销 // circleBuffer.h #ifndef _CIRCLE_BUFFER_H_ #define _CIRCLE_BUFFER_H_ #include <stdio.h> #include <cstdio> #in
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值