缓冲区c++实现

#pragma once

#include <mutex>
#include <condition_variable>
#include <list>
#include <limits>
#define AV_PKT_FLAG_KEY 0x0001

template<class T>
class ThrdList
{
    
    
	std::list<T> m_lst;
	std::mutex m_mutex;
	std::condition_variable m_cv;
	size_t m_max_num;
	bool m_is_close;
	bool m_is_full_wait;
public:
	ThrdList(): m_max_num(std::numeric_limits<int>::max()), m_is_close(false){
    
    }
	bool isFull() {
    
     return m_lst.size() >= m_max_num; }
	bool isEmpty() {
    
     return m_lst.empty(); }
	bool isClose() {
    
     return m_is_close; }
	void close() {
    
     m_is_close = true; m_cv.notify_all(); }
	void open() {
    
     m_is_close = false; m_cv.notify_all(); }
	int size() {
    
     return m_lst.size(); }
	void setSize(int size){
    
    m_max_num = size;}
	void setFullModel(bool isWait){
    
    m_is_full_wait = isWait;}
	bool enqueue(T& data)
	{
    
    
		std::unique_lock<std::mutex> lk(m_mutex);
		if(isFull() && m_is_full_wait)
		{
    
    
			m_lst.pop_front();
		}
		m_cv.wait(lk, [this] {
    
     return m_is_close || !isFull(); });
		if (m_is_close)
			return false;
		m_lst.push_back(data);
		lk.unlock();
		m_cv.notify_one();
		return true;
	}
	bool dequeue(T& data)
	{
    
    
		std::unique_lock<std::mutex> lk(m_mutex);
		m_cv.wait(lk, [this] {
    
     return m_is_close || !isEmpty(); });
		if (m_is_close)
			return false;
		data = m_lst.front();
		m_lst.pop_front();
		lk.unlock();
		m_cv.notify_one();
		return true;
	}
	bool peak(T& data)
	{
    
    
		if (!m_lst.empty())
		{
    
    
			data = m_lst.front();
			return true;
		}
		return false;
	}
	void acquireAllData(std::unique_lock<std::mutex>& lk, std::list<T>*& queue)
	{
    
    
		lk = std::unique_lock<std::mutex>(m_mutex);
		queue = &m_lst;
	}
	void releaseAllData(std::unique_lock<std::mutex>& lk)
	{
    
    
		lk.unlock();
		m_cv.notify_one();
	}
	std::list<T> getVideoDatabyTime(int timestamp,int frame_count)
	{
    
    
		std::unique_lock<std::mutex> lk(m_mutex);
		int start_alarm_time = timestamp - frame_count;
		// int end_alarm_time = start_alarm_time + frame_count*2;
        if(start_alarm_time < 0)
        {
    
    
            start_alarm_time = 0;
        }
		auto start_node =m_lst.begin();
		auto end_node = m_lst.begin();
		auto j = m_lst.begin();
		for(auto it = m_lst.begin();it !=m_lst.end(); it++)
		{
    
    
			if(it->m_timestamp == start_alarm_time)
			{
    
    
				if(it->m_packet_ptr && (it->m_packet_ptr->flags & AV_PKT_FLAG_KEY))
				{
    
    
					start_node = it;
				}
				else
				{
    
    
					for(j = it;;j--)
					{
    
    
						if(j->m_packet_ptr && (j->m_packet_ptr->flags & AV_PKT_FLAG_KEY))
						{
    
    
							start_node = j;
							start_alarm_time = j->m_timestamp;
							break;
						}
						if(j == m_lst.begin())
						{
    
    
							start_node = j;
							start_alarm_time = j->m_timestamp;
							break;
						}
					}
				}
				
			}

			if(it->m_timestamp == (start_alarm_time + frame_count*2))
			{
    
    
				end_node = it;
				break;
			}
		}
		//std::list<T> alarm_list(start_node,end_node);
		return {
    
    start_node,end_node};
	}
	void DeleteValue(int deletetime)
	{
    
    
		std::unique_lock<std::mutex> lk(m_mutex);
		auto delete_code = m_lst.begin();
		for(auto it = m_lst.begin();it != m_lst.end();it++)
		{
    
    
			if(it->m_timestamp == deletetime)
			{
    
    
				delete_code = it;
				break;
			}
		}
		m_lst.erase(m_lst.begin(),delete_code);
	}
};