inline BOOL StorFactory::Init()
{
/* Loop add the stor */
#if 0 //add camera for test
{
VidCameraList cameraList;
CameraParam Param;
Param.m_Conf.set_strip("192.168.1.1");
Param.m_Conf.set_strport("80");
Param.m_Conf.set_struser("admin");
Param.m_Conf.set_strpasswd("admin");
VidCamera *pAddCam = cameraList.add_cvidcamera();
*pAddCam = Param.m_Conf;
m_Conf.UpdateCameraListConf(cameraList);
}
#endif
VidCameraList cameraList;
m_Conf.GetCameraListConf(cameraList);
int cameraSize = cameraList.cvidcamera_size();
for (s32 i = 0; i < cameraList.cvidcamera_size(); i ++)
{
VidCamera cam = cameraList.cvidcamera(i);
CameraParam pParam(cam);
InitAddCamera(pParam, cam.strid());
}
return TRUE;
}
bool NFCAsyMysqlClusterModule::Updata(const NFGUID& self, const std::string& strRecordName, const std::string& strKey, const std::vector<std::string>& fieldVec, const std::vector<std::string>& valueVec, const MYSQL_RETURN_FUNCTOR& mFunReturnRsp, const std::string& strUseData)
{
NF_SHARE_PTR<SMysqlParam> pParam(NF_NEW SMysqlParam());
if (NULL == pParam)
{
return false;
}
pParam->strRecordName = strRecordName;
pParam->strKey = strKey;
pParam->fieldVec = fieldVec;
pParam->valueVec = valueVec;
pParam->nReqID = nCurReqID++;
pParam->eType = SMysqlParam::EMYSQLOPRTYPE_UPDATA;
pParam->mFunReturnRsp = mFunReturnRsp;
pParam->mstrUseData = strUseData;
pParam->self = self;
if (ApplyRequest(pParam) < 0)
{
return false;
}
return true;
}
void MainDialog::on_paramImage_released()
{
ParamDialog pParam(this);
if(pParam.exec() == QDialog::Accepted) {
}
ui->paramImage->setPixmap(QPixmap(SystemBase::path + QString("/../resource/main/param_up.jpg")));
}
void CXFA_FFTabOrderPageWidgetIterator::OrderContainer(
CXFA_LayoutItemIterator* sIterator,
CXFA_LayoutItem* pContainerItem,
CXFA_TabParam* pContainer,
bool& bCurrentItem,
bool& bContentArea,
bool bMarsterPage) {
CFX_ArrayTemplate<CXFA_TabParam*> tabParams;
CXFA_LayoutItem* pSearchItem = sIterator->MoveToNext();
while (pSearchItem) {
if (!pSearchItem->IsContentLayoutItem()) {
bContentArea = true;
pSearchItem = sIterator->MoveToNext();
continue;
}
if (bMarsterPage && bContentArea) {
break;
}
if (bMarsterPage || bContentArea) {
CXFA_FFWidget* hWidget = GetWidget(pSearchItem);
if (!hWidget) {
pSearchItem = sIterator->MoveToNext();
continue;
}
if (pContainerItem && (pSearchItem->GetParent() != pContainerItem)) {
bCurrentItem = true;
break;
}
CXFA_TabParam* pParam = new CXFA_TabParam;
pParam->m_pWidget = hWidget;
tabParams.Add(pParam);
if (IsLayoutElement(pSearchItem->GetFormNode()->GetElementType(), true)) {
OrderContainer(sIterator, pSearchItem, pParam, bCurrentItem,
bContentArea, bMarsterPage);
}
}
if (bCurrentItem) {
pSearchItem = sIterator->GetCurrent();
bCurrentItem = false;
} else {
pSearchItem = sIterator->MoveToNext();
}
}
int32_t iChildren = tabParams.GetSize();
if (iChildren > 1) {
FXSYS_qsort(tabParams.GetData(), iChildren, sizeof(void*),
XFA_TabOrderWidgetComparator);
}
for (int32_t iStart = 0; iStart < iChildren; iStart++) {
std::unique_ptr<CXFA_TabParam> pParam(tabParams[iStart]);
pContainer->m_Children.push_back(pParam->m_pWidget);
pContainer->m_Children.insert(pContainer->m_Children.end(),
pParam->m_Children.begin(),
pParam->m_Children.end());
}
tabParams.RemoveAll();
}
bool NFCAsyMysqlClusterModule::Keys(const NFGUID& self, const std::string& strRecordName, const std::string& strKeyName, const MYSQL_RETURN_VECVALUE_FUNCTOR& mFunReturnVecValueRsp, const std::string& strUseData)
{
NF_SHARE_PTR<SMysqlParam> pParam(NF_NEW SMysqlParam());
if (NULL == pParam)
{
return false;
}
pParam->strRecordName = strRecordName;
pParam->strKey = strKeyName;
pParam->nReqID = nCurReqID++;
pParam->eType = SMysqlParam::EMYSQLOPRTYPE_KEYS;
pParam->mFunReturnVecValueRsp = mFunReturnVecValueRsp;
pParam->mstrUseData = strUseData;
pParam->self = self;
if (ApplyRequest(pParam) < 0)
{
return false;
}
return true;
}
bool NFCAsyMysqlModule::Exists(const NFGUID& self, const std::string& strRecordName, const std::string& strKey, const MYSQL_RETURN_INT_FUNCTOR& mFunReturnIntRsp, const std::string& strUseData)
{
NF_SHARE_PTR<SMysqlParam> pParam(NF_NEW SMysqlParam());
if (NULL == pParam)
{
return false;
}
pParam->strRecordName = strRecordName;
pParam->strKey = strKey;
pParam->nReqID = nCurReqID++;
pParam->eType = SMysqlParam::EMYSQLOPRTYPE_EXISTS;
pParam->mFunReturnIntRsp = mFunReturnIntRsp;
pParam->mstrUseData = strUseData;
pParam->self = self;
if (ApplyRequest(pParam) < 0)
{
return false;
}
return true;
}
bool NFCAsyMysqlModule::Select(const NFGUID& self, const std::string& strRecordName, const std::string& strKey, const std::vector<std::string>& fieldVec, const MYSQL_RETURN_VECKEY_VECVALUE_FUNCTOR& mFunReturnVeckKeyValueRsp, const std::string& strUseData)
{
NF_SHARE_PTR<SMysqlParam> pParam(NF_NEW SMysqlParam());
if (NULL == pParam)
{
return false;
}
pParam->strRecordName = strRecordName;
pParam->strKey = strKey;
pParam->fieldVec = fieldVec;
pParam->nReqID = nCurReqID++;
pParam->eType = SMysqlParam::EMYSQLOPRTYPE_SELECT;
pParam->mFunReturnVeckKeyValueRsp = mFunReturnVeckKeyValueRsp;
pParam->mstrUseData = strUseData;
pParam->self = self;
if (ApplyRequest(pParam) < 0)
{
return false;
}
return true;
}
inline BOOL Factory::Init()
{
astring strPath;
if (m_SysPath.GetSystemPath(strPath) == FALSE)
{
return FALSE;
}
printf("Sys path %s\n", strPath.c_str());
#ifdef WIN32
#ifndef _WIN64
astring strPathConf = strPath + "vidstor\\config";
#else
astring strPathConf = strPath + "vidstor64\\config";
#endif
#else
astring strPathConf = strPath + "vidstor/config";
#endif
m_Conf.Open(strPathConf);
#ifndef _WIN64
astring strPathDb = strPath + "vidstor";
#else
astring strPathDb = strPath + "vidstor64";
#endif
m_pVdb = new VDB(strPathDb);
VidHDFSConf HdfsConf;
m_Conf.GetHdfsRecordConf(HdfsConf);
astring strNameNode = HdfsConf.strnamenode();
astring strPort = HdfsConf.strport();
astring strUser = HdfsConf.struser();
m_pVHdfsdb = new VHdfsDB(strNameNode, strPort, strUser);
#if 1 //add camera for test
{
VidCameraList cameraList;
CameraParam Param;
Param.m_Conf.set_strip("192.168.0.123");
Param.m_Conf.set_strport("80");
Param.m_Conf.set_struser("admin");
Param.m_Conf.set_strpasswd("12345");
VidCamera *pAddCam = cameraList.add_cvidcamera();
*pAddCam = Param.m_Conf;
m_Conf.UpdateCameraListConf(cameraList);
}
#endif
VidCameraList cameraList;
m_Conf.GetCameraListConf(cameraList);
int cameraSize = cameraList.cvidcamera_size();
for (s32 i = 0; i < cameraList.cvidcamera_size(); i ++)
{
VidCamera cam = cameraList.cvidcamera(i);
CameraParam pParam(cam);
InitAddCamera(pParam, cam.strid());
}
#if 0
VSCConfData sysData;
m_Conf.GetSysData(sysData);
for (s32 i = 1; i < CONF_MAP_MAX; i ++)
{
if (sysData.data.conf.CameraMap[i] != CONF_MAP_INVALID_MIN
&& sysData.data.conf.CameraMap[i] != 0)
{
VDC_DEBUG( "%s Init Camera %d\n",__FUNCTION__, i);
VSCCameraData Data;
m_Conf.GetCameraData(i, Data);
CameraParam mParam(Data);
LockCameraID(Data.data.conf.nId);
InitAddCamera(mParam, Data.data.conf.nId);
VDC_DEBUG( "%s Id %d\n",__FUNCTION__, Data.data.conf.nId);
}
}
#endif
InitLicense();
//m_pThread = new thread(Factory::Run, (void *)this);
//start();
m_HddTask = new FactoryHddTask(*this);
m_HddTask->start();
//if (sysData.data.conf.OAPIPort == 0)
{
//sysData.data.conf.OAPIPort = 9080;
}
//m_pHttpServer = new CmnHttpServer(sysData.data.conf.OAPIPort);
//m_pHttpServer->start();
/* Init export path */
astring strExportPath;
GetExportPath(strExportPath);
return TRUE;
}
list<ClsDataClientConfig> ClsDataClientConfigReader::getDataClientConfig(string strFileName) {
#ifdef DEBUG_CLSDATACLIENTCONFIGREADER
cout << "ClsDataClientConfigReader::getDataClientConfig()" << endl;
#endif
list<ClsDataClientConfig> lstConfigs;
#ifdef DEBUG_CLSDATACLIENTCONFIGREADER
cout << "reading settings from: " << strFileName << endl;
#endif
bool errorsOccured = false;
static bool gDoNamespaces = false;
if(!bXMLPlatformInitialized){
try {
XMLPlatformUtils::Initialize();
}
catch(const XMLException& toCatch) {
cerr << "Error during Xerces-c Initialization.\n"
<< " Exception message:"
<< toCatch.getMessage() << endl;
bXMLPlatformInitialized = false;
errorsOccured = true;
// return;
}
bXMLPlatformInitialized = true;
errorsOccured = false;
}
//--------------------
if (!errorsOccured) {
XercesDOMParser* parser = new XercesDOMParser();
parser->setValidationScheme(XercesDOMParser::Val_Never);
/*
XercesDOMParser::Val_Never;
XercesDOMParser::Val_Auto;
XercesDOMParser::Val_Always;
*/
parser->setDoNamespaces(gDoNamespaces);
ErrorHandler* errHandler = (ErrorHandler*) new HandlerBase();
parser->setErrorHandler(errHandler);
try {
parser->parse(strFileName.c_str());
int errorCount = parser->getErrorCount();
if (errorCount > 0){
errorsOccured = true;
}
} catch (const XMLException& e) {
cerr << "An error occured during parsing (XMLException)\n NMessage: " << XMLString::transcode(e.getMessage()) << endl;
ClsDataClientConfigReaderException clsDataClientConfigReaderException(XMLString::transcode(e.getMessage()));
errorsOccured = true;
throw clsDataClientConfigReaderException;
} catch (const DOMException& e) {
cerr << "An error occured during parsing (DOMException)\n DMessage: " << XMLString::transcode(e.msg) << endl;
ClsDataClientConfigReaderException clsDataClientConfigReaderException(XMLString::transcode(e.msg));
errorsOccured = true;
throw clsDataClientConfigReaderException;
} catch (const SAXException& e) {
cerr << "An error occured during parsing (SAXException)\n DMessage: " << XMLString::transcode(e.getMessage()) << endl;
ClsDataClientConfigReaderException clsDataClientConfigReaderException(XMLString::transcode(e.getMessage()));
errorsOccured = true;
throw clsDataClientConfigReaderException;
} catch (...) {
cerr << "An error occured during parsing\n " << endl;
errorsOccured = true;
ClsDataClientConfigReaderException clsDataClientConfigReaderException(ClsDataClientConfigReaderException::PARSE_ERROR);
throw clsDataClientConfigReaderException;
}
/* DOMNode* dnIqrConfig; */
DOMDocument *ddocConfig = parser->getDocument();
DOMNodeList* dnlstClients = ddocConfig->getElementsByTagName(XMLString::transcode(ConfigTagLibrary::DataClientTag()));
try{
if(dnlstClients->getLength()>0){
DOMNode* dnValue = NULL;
unsigned int ii = 0;
while( ii< dnlstClients->getLength()){
DOMNode* dnClient = dnlstClients->item(ii);
ii++;
string strType = getAttributeValue(dnClient, ConfigTagLibrary::TypeTag(), true);
string strID = getAttributeValue(dnClient, ConfigTagLibrary::IDTag(), false);
ClsDataClientConfig clsDataClientConfig(strID, strType);
DOMNodeList* dnlstClientChildren = dnClient->getChildNodes();
unsigned int i2 = 0;
while( i2< dnlstClientChildren->getLength()){
DOMNode* dnClientChild = dnlstClientChildren->item(i2);
if(dnClientChild->getNodeType() == 1){
string strName = XMLString::transcode(dnClientChild->getNodeName());
if(!strName.compare(ConfigTagLibrary::PositionTag())){
int iX = 0;
int iY = 0;
iX = iqrUtils::string2int(getAttributeValue(dnClientChild, ConfigTagLibrary::PositionXTag(), true));
iY = iqrUtils::string2int(getAttributeValue(dnClientChild, ConfigTagLibrary::PositionYTag(), true));
clsDataClientConfig.setPosition(iX, iY);
} else if(!strName.compare(ConfigTagLibrary::Geometry())){
int iWidth = 0;
int iHeight = 0;
iWidth = iqrUtils::string2int(getAttributeValue(dnClientChild, ConfigTagLibrary::GeometryWidthTag(), true));
iHeight = iqrUtils::string2int(getAttributeValue(dnClientChild, ConfigTagLibrary::GeometryHeightTag(), true));
clsDataClientConfig.setGeometry(iWidth, iHeight);
} else if(!strName.compare(ConfigTagLibrary::StateVariableDisplayTag())){
DOMNodeList* dnlstSVD = dnClientChild->getChildNodes();
unsigned int i3 = 0;
while( i3< dnlstSVD->getLength()){
DOMNode* dnSVD = dnlstSVD->item(i3);
if(dnSVD->getNodeType() == 1){
string strSVDID = getAttributeValue(dnSVD, ConfigTagLibrary::IDTag(), true);
//-- string strItemType = getAttributeValue(dnSVD, ConfigTagLibrary::TypeTag(), true);
string strItemID = getAttributeValue(dnSVD, ConfigTagLibrary::ItemIDTag(), true);
string strSelectedIndices = getAttributeValue(dnSVD, ConfigTagLibrary::SelectedIndicesTag(), true);
ClsStateVariableDisplayConfig clsStateVariableDisplayConfig(/*strItemType,*/ strSVDID, strItemID, strSelectedIndices);
DOMNodeList* dnlstSVDParams = dnSVD->getChildNodes();
unsigned int i4 = 0;
while( i4< dnlstSVDParams->getLength()){
DOMNode* dnSVDParam = dnlstSVDParams->item(i4);
if(dnSVDParam->getNodeType() == 1){
string strParamName = XMLString::transcode(dnSVDParam->getNodeName());
dnValue = dnSVDParam->getFirstChild();
string strParamValue = "";
if(dnValue!=NULL){
strParamValue = XMLString::transcode(dnValue->getNodeValue());
}
pair<string, string> pParam(strParamName, strParamValue);
clsStateVariableDisplayConfig.addParameter(pParam);
}
i4++;
}
clsDataClientConfig.addStateVariableDisplayConfig(clsStateVariableDisplayConfig);
}
i3++;
}
} else {
string strValue = "";
dnValue = dnClientChild->getFirstChild();
if(dnValue!=NULL){
strValue = XMLString::transcode(dnValue->getNodeValue());
}
pair<string, string> pParam(strName, strValue);
clsDataClientConfig.addParameter(pParam);
}
}
i2++;
}
lstConfigs.push_back(clsDataClientConfig);
}
}
} catch (...) {
ClsDataClientConfigReaderException clsDataClientConfigReaderException(ClsDataClientConfigReaderException::PARSE_ERROR);
throw clsDataClientConfigReaderException;
}
delete errHandler;
}
return lstConfigs;
};
mfxStatus CQuickSyncDecoder::CreateAllocator()
{
if (m_pFrameAllocator != NULL)
return MFX_ERR_NONE;
MSDK_TRACE("QsDecoder: CreateAllocator\n");
ASSERT(m_pVideoParams != NULL);
if (NULL == m_pVideoParams)
return MFX_ERR_NOT_INITIALIZED;
std::auto_ptr<mfxAllocatorParams> pParam(NULL);
mfxStatus sts = MFX_ERR_NONE;
// Setup allocator - HW acceleration
if (m_bUseD3DAlloc)
{
m_pVideoParams->IOPattern = MFX_IOPATTERN_OUT_VIDEO_MEMORY | MFX_IOPATTERN_IN_VIDEO_MEMORY;
int nAdapterID = GetMSDKAdapterNumber(*m_mfxVideoSession);
// D3D11 HW device
if (m_bUseD3D11Alloc)
{
#if MFX_D3D11_SUPPORT
// HW device must be initialized early - within session init.
// If a call to DecodeHeader was called before session->SetHandle, SetHandle would fail.
ASSERT(m_HwDevice);
MSDK_CHECK_POINTER(m_HwDevice, MFX_ERR_NULL_PTR);
D3D11AllocatorParams* p = new D3D11AllocatorParams;
p->pDevice = (ID3D11Device*)m_HwDevice->GetHandle(MFX_HANDLE_D3D11_DEVICE);
pParam.reset(p);
m_pFrameAllocator = new D3D11FrameAllocator();
#endif
}
// D3D9 HW device
else
{
// Having the D3D9 device manager from the renderer allows working in full screen exclusive mode
// This parameter can be NULL for other usages
m_HwDevice = new CD3D9Device(m_pRendererD3dDeviceManager);
if (MSDK_FAILED(sts = m_HwDevice->Init(nAdapterID)))
{
MSDK_TRACE("QsDecoder: D3D9 init have failed!\n");
MSDK_SAFE_DELETE(m_HwDevice);
return sts;
}
// Set the pointer to the HW device (or device manager) to the session
mfxHDL h = m_HwDevice->GetHandle(MFX_HANDLE_D3D9_DEVICE_MANAGER);
sts = m_mfxVideoSession->SetHandle(MFX_HANDLE_D3D9_DEVICE_MANAGER, h);
MSDK_CHECK_NOT_EQUAL(sts, MFX_ERR_NONE, sts);
D3DAllocatorParams* p = new D3DAllocatorParams;
p->pManager = (IDirect3DDeviceManager9*)h;
pParam.reset(p);
m_pFrameAllocator = new D3DFrameAllocator();
}
}
// Setup allocator - No HW acceleration
else
{
m_bUseD3DAlloc = false;
m_pVideoParams->IOPattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY | MFX_IOPATTERN_IN_SYSTEM_MEMORY;
m_pFrameAllocator = new SysMemFrameAllocator();
}
sts = m_pFrameAllocator->Init(pParam.get());
if (MSDK_SUCCEEDED(sts))
{
// Note - setting the session allocator can be done only once per session!
sts = m_mfxVideoSession->SetFrameAllocator(m_pFrameAllocator);
if (MSDK_FAILED(sts))
{
MSDK_TRACE("QsDecoder: Session SetFrameAllocator failed!\n");
}
}
else
// Allocator failed to initialize
{
MSDK_TRACE("QsDecoder: Allocator Init failed!\n");
MSDK_SAFE_DELETE(m_pFrameAllocator);
ASSERT(false);
}
return sts;
}
