#include "PipeLine.h"
|
#include "MaterialBuffer.h"
|
#include "logger.h"
|
|
PipeMaterial::PipeMaterial() :
|
type(PMT__FIRST), buffer(nullptr), buffSize(0),
|
former(nullptr), deleter(nullptr), args(nullptr)
|
{
|
}
|
|
void PipeMaterial::exec_deleter(bool lastRet)
|
{
|
if (deleter != nullptr)
|
{
|
deleter(this, lastRet);
|
deleter = nullptr;
|
}
|
}
|
|
int PipeMaterial::breake(PipeMaterialBufferType selectPmType, int _selectMbfType,
|
pm_breaker_func breaker, void* args /*= nullptr*/) const
|
{
|
int called = 0;
|
const MB_Frame::MBFType selectMbfType = (MB_Frame::MBFType)_selectMbfType;
|
|
switch(type)
|
{
|
case PMT_NONE:
|
if (selectPmType == PMT_NONE)
|
{
|
called++;
|
breaker(this, args);
|
}
|
break;
|
case PMT_BYTES:
|
if (selectPmType == PMT_BYTES)
|
{
|
called++;
|
breaker(this, args);
|
}
|
break;
|
case PMT_PTR:
|
if (selectPmType == PMT_PTR)
|
{
|
called++;
|
breaker(this, args);
|
}
|
break;
|
case PMT_FRAME:
|
if (selectPmType == PMT_FRAME || selectPmType == PipeMaterial::PMT__FIRST || selectPmType == PipeMaterial::PMT__LAST)
|
{
|
MB_Frame* mbf = (MB_Frame*)buffer;
|
if (selectMbfType == mbf->type || selectMbfType == MB_Frame::MBFT__FIRST || selectMbfType == MB_Frame::MBFT__LAST)
|
{
|
called++;
|
breaker(this, args);
|
}
|
}
|
break;
|
case PMT_PM_LIST:
|
{
|
// break pm list into single pm(s)
|
|
PipeMaterial* pm = (PipeMaterial*)buffer;
|
for (size_t i = 0; i < buffSize; i++, pm++)
|
{
|
if (selectPmType == pm->type || selectPmType == PipeMaterial::PMT__FIRST || selectPmType == PipeMaterial::PMT__LAST)
|
{
|
if (pm->type == PipeMaterial::PMT_FRAME)
|
{
|
MB_Frame *mbf = (MB_Frame *) pm->buffer;
|
if (selectMbfType == mbf->type || selectMbfType == MB_Frame::MBFT__FIRST || selectMbfType == MB_Frame::MBFT__LAST)
|
{
|
called++;
|
if (!breaker(pm, args))
|
break;
|
}
|
}
|
else
|
{
|
called++;
|
if (!breaker(pm, args))
|
break;
|
}
|
}
|
}
|
}
|
break;
|
case PMT_FRAME_LIST:
|
{
|
// break mbf list into single pm(s)
|
|
if (selectPmType == PMT_FRAME_LIST || selectPmType == PMT_FRAME ||
|
selectPmType == PipeMaterial::PMT__FIRST || selectPmType == PipeMaterial::PMT__LAST)
|
{
|
MB_Frame* mbf = (MB_Frame*)buffer;
|
for (size_t i = 0; i < buffSize; i++, mbf++)
|
{
|
if (selectMbfType == mbf->type || selectMbfType == MB_Frame::MBFT__FIRST || selectMbfType == MB_Frame::MBFT__LAST)
|
{
|
PipeMaterial tmpPm;
|
tmpPm.type = PMT_FRAME;
|
tmpPm.buffer = mbf;
|
tmpPm.buffSize = 0;
|
tmpPm.former = former;
|
tmpPm.deleter = nullptr;
|
tmpPm.args = args;
|
|
called++;
|
if (!breaker(&tmpPm, args))
|
break;
|
}
|
}
|
}
|
}
|
break;
|
default:
|
break;
|
}
|
|
return called;
|
}
|
|
PipeLine::elem_create_func_map_t PipeLine::global_elem_create_func_map;
|
|
PipeLine::PipeLine() : params_map(), elem_create_func_map(), elems()
|
{
|
}
|
|
PipeLine::~PipeLine()
|
{
|
// pipe stop
|
|
for(elem_vec_t::iterator iter = elems.begin(); iter != elems.end(); ++iter)
|
{
|
PipeLineElem* elem = *iter;
|
if (elem != nullptr && elem->manager == this)
|
{
|
elem->finit();
|
delete *iter;
|
}
|
}
|
|
elems.clear();
|
}
|
|
bool PipeLine::register_elem_creator(const std::string& type, elem_create_func_t func)
|
{
|
if (type.empty() || func == nullptr)
|
return false;
|
|
elem_create_func_map_t::iterator iter = elem_create_func_map.find(type);
|
if (iter != elem_create_func_map.end())
|
return false;
|
|
elem_create_func_map.insert(std::make_pair(type, func));
|
return true;
|
}
|
|
//static
|
bool PipeLine::register_global_elem_creator(const std::string& type, elem_create_func_t func)
|
{
|
if (type.empty() || func == nullptr)
|
return false;
|
|
elem_create_func_map_t::iterator iter = global_elem_create_func_map.find(type);
|
if (iter != global_elem_create_func_map.end())
|
return false;
|
|
global_elem_create_func_map.insert(std::make_pair(type, func));
|
return true;
|
}
|
|
void PipeLine::push_elem(PipeLineElem* elem)
|
{
|
if(elem != nullptr)
|
{
|
elem->manager = this;
|
elems.push_back(elem);
|
}
|
}
|
|
void PipeLine::push_front_elem(PipeLineElem* elem)
|
{
|
if(elem != nullptr)
|
{
|
elem->manager = this;
|
elems.insert(elems.begin(), elem);
|
}
|
}
|
|
PipeLineElem* PipeLine::at(int idx)
|
{
|
return elems[idx];
|
}
|
|
bool PipeLine::remove_elem(PipeLineElem* elem)
|
{
|
if(elem != nullptr)
|
{
|
for(elem_vec_t::iterator iter = elems.begin(); iter != elems.end(); ++iter)
|
{
|
if (*iter == elem)
|
{
|
iter = elems.erase(iter);
|
return true;
|
}
|
}
|
}
|
|
return false;
|
}
|
|
void PipeLine::finit(elem_destory_func_t elem_destory_func)
|
{
|
while (!elems.empty())
|
{
|
PipeLineElem* elem = elems.back();
|
|
if (elem->manager == this)
|
{
|
elem->finit();
|
if (elem_destory_func != nullptr)
|
elem_destory_func(elem);
|
}
|
|
elems.pop_back();
|
}
|
|
elem_create_func_map.clear();
|
params_map.clear();
|
}
|
|
bool PipeLine::check_pipe_complete(PipeLineElem* lastRetElem) const
|
{
|
if (elems.empty())
|
return lastRetElem == nullptr;
|
else
|
return lastRetElem == *elems.rbegin();
|
}
|
|
PipeLineElem* PipeLine::push_elem(const std::string& type)
|
{
|
elem_create_func_map_t::iterator iter = elem_create_func_map.find(type);
|
if (iter == elem_create_func_map.end())
|
{
|
iter = global_elem_create_func_map.find(type);
|
if (iter == global_elem_create_func_map.end())
|
return nullptr;
|
}
|
|
elem_create_func_t func = iter->second;
|
if (func == nullptr)
|
return nullptr;
|
|
PipeLineElem* elem = func();
|
if (elem == nullptr)
|
return nullptr;
|
|
elem->manager = this;
|
push_elem(elem);
|
return elem;
|
}
|
|
PipeLineElem* PipeLine::pipe(PipeMaterial* pm /*= nullptr*/)
|
{
|
PipeLineElem* elem_begin = *elems.begin();
|
PipeLineElem* elem_last = *elems.rbegin();
|
|
if (elems.empty() || elem_begin == nullptr || elem_last == nullptr)
|
return nullptr;
|
|
uint8_t pmPlacement[sizeof(PipeMaterial)];
|
if (pm == nullptr)
|
pm = new (pmPlacement) PipeMaterial;
|
|
bool lastRet = true;
|
|
if (elems.size() == 1)
|
{
|
lastRet = elem_begin->gain(*pm);
|
pm->exec_deleter(lastRet);
|
return elem_begin;
|
}
|
else if (elems.size() == 2)
|
{
|
if (elem_begin->gain(*pm))
|
{
|
lastRet = elem_last->pay(*pm);
|
pm->exec_deleter(lastRet);
|
}
|
else
|
return elem_begin;
|
return elem_last;
|
}
|
else
|
{
|
if (!elem_begin->gain(*pm))
|
return elem_begin;
|
|
lastRet = true;
|
elem_vec_t::iterator iter = elems.begin();
|
++iter;
|
elem_begin = *iter;
|
while (elem_begin != elem_last)
|
{
|
if (lastRet && (lastRet = elem_begin->pay(*pm)) )
|
{
|
pm->exec_deleter(lastRet);
|
lastRet = elem_begin->gain(*pm);
|
}
|
else
|
return elem_begin;
|
|
++iter;
|
elem_begin = *iter;
|
}
|
|
if (lastRet)
|
elem_last->pay(*pm);
|
pm->exec_deleter(lastRet);
|
return elem_last;
|
}
|
|
return nullptr;
|
}
|
|
void PipeLine::set_param(const std::string& name, const std::string& value)
|
{
|
if (name.empty())
|
return;
|
|
params_map_t::iterator iter = params_map.find(name);
|
if (iter == params_map.end())
|
params_map.insert(std::make_pair(name, value));
|
else
|
iter->second = value;
|
}
|
|
std::string PipeLine::get_param(const std::string& name) const
|
{
|
params_map_t::const_iterator iter = params_map.find(name);
|
if (iter == params_map.end())
|
return "";
|
else
|
return iter->second;
|
}
|
|
#ifdef ENABLE_PIPELINE_ELEM_TIMING_DEBUGGER
|
#include <typeinfo>
|
#include <sys/time.h>
|
PipeLineElemTimingDebugger::PipeLineElemTimingDebugger(const PipeLineElem* _elem) :
|
elem(_elem), beginTime(0)
|
{
|
struct timeval _beginTime;
|
gettimeofday(&_beginTime, NULL);
|
beginTime = 1000000 * _beginTime.tv_sec + _beginTime.tv_usec;
|
}
|
|
PipeLineElemTimingDebugger::~PipeLineElemTimingDebugger()
|
{
|
struct timeval _endTime;
|
gettimeofday(&_endTime, NULL);
|
const uint64_t endTime = 1000000 * _endTime.tv_sec + _endTime.tv_usec;
|
|
LOGP(WARN, "elem=%s@%llu, dura=%llu(us)", typeid(elem).name(), uint64_t(elem), uint64_t(endTime - beginTime));
|
}
|
#else
|
PipeLineElemTimingDebugger::PipeLineElemTimingDebugger(const PipeLineElem* _elem) { }
|
PipeLineElemTimingDebugger::~PipeLineElemTimingDebugger() { }
|
#endif
|
