#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);
}
};
缓冲区c++实现
最新推荐文章于 2024-03-30 08:44:17 发布