tResult Test::getWheelTicks(IMediaSample *mediaSample, tFloat32 &value)
{
RETURN_IF_FAILED(getF32Value(mediaSample, this->coderDescriptionWheelTicks, value));
RETURN_NOERROR;
}
tResult cMarkerDetectFilter::Init(tInitStage eStage, __exception)
{
RETURN_IF_FAILED(cFilter::Init(eStage, __exception_ptr));
if (eStage == StageFirst)
{
//create the video rgb input pin
RETURN_IF_FAILED(m_oPinInputVideo.Create("Video_RGB_input",IPin::PD_Input, static_cast<IPinEventSink*>(this)));
RETURN_IF_FAILED(RegisterPin(&m_oPinInputVideo));
//create the video rgb output pin
RETURN_IF_FAILED(m_oPinOutputVideo.Create("Video_RGB_output", IPin::PD_Output, static_cast<IPinEventSink*>(this)));
RETURN_IF_FAILED(RegisterPin(&m_oPinOutputVideo));
// create the description manager
cObjectPtr<IMediaDescriptionManager> pDescManager;
RETURN_IF_FAILED(_runtime->GetObject(OID_ADTF_MEDIA_DESCRIPTION_MANAGER,IID_ADTF_MEDIA_DESCRIPTION_MANAGER, (tVoid**)&pDescManager,__exception_ptr));
tChar const * strDescSignalLanacc_man = pDescManager->GetMediaDescription("tSignalValue");
RETURN_IF_POINTER_NULL(strDescSignalLanacc_man);
cObjectPtr<IMediaType> pTypeSignalmaneuver_lanacc = new cMediaType(0, 0, 0, "tSignalValue", strDescSignalLanacc_man, IMediaDescription::MDF_DDL_DEFAULT_VERSION);
RETURN_IF_FAILED(pTypeSignalmaneuver_lanacc->GetInterface(IID_ADTF_MEDIA_TYPE_DESCRIPTION, (tVoid**)&mediatype_Lan_Acc_Man));
RETURN_IF_FAILED(Lan_Acc_Man.Create("Lan_Acc_Man", pTypeSignalmaneuver_lanacc, static_cast<IPinEventSink*> (this)));
RETURN_IF_FAILED(RegisterPin(&Lan_Acc_Man));
tChar const * strDescSignalmaneuver_accspeed = pDescManager->GetMediaDescription("tSignalValue");
RETURN_IF_POINTER_NULL(strDescSignalmaneuver_accspeed);
cObjectPtr<IMediaType> pTypeSignalmaneuver_accspeed = new cMediaType(0, 0, 0, "tSignalValue", strDescSignalmaneuver_accspeed, IMediaDescription::MDF_DDL_DEFAULT_VERSION);
RETURN_IF_FAILED(pTypeSignalmaneuver_accspeed->GetInterface(IID_ADTF_MEDIA_TYPE_DESCRIPTION, (tVoid**)&mediatype_Lan_Acc_Speed));
RETURN_IF_FAILED(Lan_Acc_Speed.Create("Lane_Speed", pTypeSignalmaneuver_accspeed, static_cast<IPinEventSink*> (this)));
RETURN_IF_FAILED(RegisterPin(&Lan_Acc_Speed));
tChar const * strDescSignalmaneuver_idJury = pDescManager->GetMediaDescription("tSignalValue");
RETURN_IF_POINTER_NULL(strDescSignalmaneuver_idJury);
cObjectPtr<IMediaType> pTypeSignalmaneuver_idjury = new cMediaType(0, 0, 0, "tSignalValue", strDescSignalmaneuver_idJury, IMediaDescription::MDF_DDL_DEFAULT_VERSION);
RETURN_IF_FAILED(pTypeSignalmaneuver_idjury->GetInterface(IID_ADTF_MEDIA_TYPE_DESCRIPTION, (tVoid**)&mediatype_maneuverid_Jury));
RETURN_IF_FAILED(maneuverid_Jury.Create("maneuverid_Jury", pTypeSignalmaneuver_idjury, static_cast<IPinEventSink*> (this)));
RETURN_IF_FAILED(RegisterPin(&maneuverid_Jury));
tChar const * strDescSignalmaneuver_id = pDescManager->GetMediaDescription("tSignalValue");
RETURN_IF_POINTER_NULL(strDescSignalmaneuver_id);
cObjectPtr<IMediaType> pTypeSignalmaneuver_id = new cMediaType(0, 0, 0, "tSignalValue", strDescSignalmaneuver_id, IMediaDescription::MDF_DDL_DEFAULT_VERSION);
RETURN_IF_FAILED(pTypeSignalmaneuver_id->GetInterface(IID_ADTF_MEDIA_TYPE_DESCRIPTION, (tVoid**)&mediatype_maneuver_id));
RETURN_IF_FAILED(maneuver_id.Create("Maneuver_ID", pTypeSignalmaneuver_id, static_cast<IPinEventSink*> (this)));
RETURN_IF_FAILED(RegisterPin(&maneuver_id));
tChar const * strDescSignalmaneuver_finish = pDescManager->GetMediaDescription("tBoolSignalValue");
RETURN_IF_POINTER_NULL(strDescSignalmaneuver_finish);
cObjectPtr<IMediaType> pTypeSignalmaneuver_finish = new cMediaType(0, 0, 0, "tBoolSignalValue", strDescSignalmaneuver_finish, IMediaDescription::MDF_DDL_DEFAULT_VERSION);
RETURN_IF_FAILED(pTypeSignalmaneuver_finish->GetInterface(IID_ADTF_MEDIA_TYPE_DESCRIPTION, (tVoid**)&mediatype_maneuver_finish));
RETURN_IF_FAILED(maneuver_finish.Create("Maneuver_int_Finish", pTypeSignalmaneuver_finish, static_cast<IPinEventSink*> (this)));
RETURN_IF_FAILED(RegisterPin(&maneuver_finish));
// create the description for the road sign pin
tChar const * strDesc = pDescManager->GetMediaDescription("tRoadSign");
RETURN_IF_POINTER_NULL(strDesc);
cObjectPtr<IMediaType> pType = new cMediaType(0, 0, 0, "tRoadSign", strDesc, IMediaDescription::MDF_DDL_DEFAULT_VERSION);
// create the road sign OutputPin
RETURN_IF_FAILED(m_oPinRoadSign.Create("RoadSign", pType, this));
RETURN_IF_FAILED(RegisterPin(&m_oPinRoadSign));
// set the description for the road sign pin
RETURN_IF_FAILED(pType->GetInterface(IID_ADTF_MEDIA_TYPE_DESCRIPTION, (tVoid**)&m_pDescriptionRoadSign));
// create the description for the road sign pin
tChar const * strDescExt = pDescManager->GetMediaDescription("tRoadSignExt");
RETURN_IF_POINTER_NULL(strDescExt);
cObjectPtr<IMediaType> pTypeExt = new cMediaType(0, 0, 0, "tRoadSignExt", strDescExt, IMediaDescription::MDF_DDL_DEFAULT_VERSION);
// create the extended road sign OutputPin
RETURN_IF_FAILED(m_oPinRoadSignExt.Create("RoadSign_ext", pTypeExt, this));
RETURN_IF_FAILED(RegisterPin(&m_oPinRoadSignExt));
// set the description for the extended road sign pin
RETURN_IF_FAILED(pTypeExt->GetInterface(IID_ADTF_MEDIA_TYPE_DESCRIPTION, (tVoid**)&m_pDescriptionRoadSignExt));
}
else if (eStage == StageNormal)
{
// get the propeerties
ReadProperties(NULL);
m_iOutputMode = GetPropertyInt("Video Output Pin");
m_f32MarkerSize = static_cast<tFloat32>(GetPropertyFloat("Size of Markers"));
m_bDebugModeEnabled = GetPropertyBool("Debug Output to Console");
imshowflag = GetPropertyBool(MD_ENABLE_IMSHOW);
imshowflag_ver = GetPropertyBool(MD_ENABLE_IMSHOW_VER);
m_bCamaraParamsLoaded = tFalse;
//Get path of marker configuration file
cFilename fileConfig = GetPropertyStr("Dictionary File For Markers");
//create absolute path for marker configuration file
ADTF_GET_CONFIG_FILENAME(fileConfig);
fileConfig = fileConfig.CreateAbsolutePath(".");
//check if marker configuration file exits
if (fileConfig.IsEmpty() || !(cFileSystem::Exists(fileConfig)))
{
LOG_ERROR("Dictionary File for Markers not found");
RETURN_ERROR(ERR_INVALID_FILE);
}
else
{
//try to read the marker configuration file
if(m_Dictionary.fromFile(string(fileConfig))==false)
{
RETURN_ERROR(ERR_INVALID_FILE);
LOG_ERROR("Dictionary File for Markers could not be read");
}
if(m_Dictionary.size()==0)
{
RETURN_ERROR(ERR_INVALID_FILE);
LOG_ERROR("Dictionary File does not contain valid markers or could not be read sucessfully");
}
//set marker configuration file to highlyreliable markers class
if (!(HighlyReliableMarkers::loadDictionary(m_Dictionary)==tTrue))
{
//LOG_ERROR("Dictionary File could not be read for highly reliable markers");
}
}
//Get path of calibration file with camera paramters
cFilename fileCalibration = GetPropertyStr("Calibration File for used Camera"); ;
//Get path of calibration file with camera paramters
ADTF_GET_CONFIG_FILENAME(fileCalibration);
fileCalibration = fileCalibration.CreateAbsolutePath(".");
//check if calibration file with camera paramters exits
if (fileCalibration.IsEmpty() || !(cFileSystem::Exists(fileCalibration)))
{
LOG_ERROR("Calibration File for camera not found");
}
else
{
// read the calibration file with camera paramters exits and save to member variable
m_TheCameraParameters.readFromXMLFile(fileCalibration.GetPtr());
cv::FileStorage camera_data (fileCalibration.GetPtr(),cv::FileStorage::READ);
camera_data ["camera_matrix"] >> m_Intrinsics;
camera_data ["distortion_coefficients"] >> m_Distorsion;
m_bCamaraParamsLoaded = tTrue;
}
}
STDMETHODIMP CHeapStatParser::Parse(VARIANT *v, IVariantObject** ppVariantObject)
{
CHECK_E_POINTER(v);
if(v->vt != VT_BSTR)
return E_INVALIDARG;
CComPtr<IPluginManager> pPluginManager;
RETURN_IF_FAILED(HrGetPluginManager(&pPluginManager));
RETURN_IF_FAILED(pPluginManager->CoCreateInstance(CLSID_VariantObject, IID_IVariantObject, (LPVOID*)ppVariantObject));
CComPtr<IVariantObject> pVariantObject = *ppVariantObject;
HrAddColumn(pPluginManager, pVariantObject, ObjectModel::Metadata::Object::Id, L"MT", VT_BSTR, 100);
HrAddColumn(pPluginManager, pVariantObject, VAR_COUNT, L"Count", VT_I4, 100);
HrAddColumn(pPluginManager, pVariantObject, VAR_TOTALSIZE, L"TotalSize", VT_I8, 100);
HrAddColumn(pPluginManager, pVariantObject, VAR_CLASSNAME, L"ClassName");
CComPtr<IObjCollection> pObjectCollection;
RETURN_IF_FAILED(HrCoCreateInstance(CLSID_ObjectCollection, &pObjectCollection));
CComBSTR bstrResult = v->bstrVal;
CString strResult = bstrResult;
int nTokenPos = 0;
bool readyToParse = false;
int nObjects = 0;
while (nTokenPos >= 0)
{
CString strLine = strResult.Tokenize(L"\n", nTokenPos);
if(strLine.Find(L" MT") != -1)
{
readyToParse = true;
continue;
}
if(!readyToParse)
continue;
if(strLine.Find(L"Total ") != -1)
break;
static std::wregex regex(L"(\\S+) +(\\S+) +(\\S+) +(.+)");
std::wsmatch matches;
auto str = std::wstring(strLine);
if (!std::regex_search(str, matches, regex) || matches.size() != 5)
continue;
int index = 1;
auto strId = matches[index++].str();
auto count = boost::lexical_cast<int>(matches[index++].str());
auto totalSize = boost::lexical_cast<long long>(matches[index++].str());
auto strClassName = matches[index++].str();
if (strClassName.find(L"Free") != std::wstring::npos)
continue;
CComPtr<IVariantObject> pVariantObjectValue;
RETURN_IF_FAILED(pPluginManager->CoCreateInstance(CLSID_VariantObject, IID_IVariantObject, (LPVOID*)&pVariantObjectValue));
RETURN_IF_FAILED(pVariantObjectValue->SetVariantValue(ObjectModel::Metadata::Object::Id, &CComVar(strId.c_str())));
RETURN_IF_FAILED(pVariantObjectValue->SetVariantValue(VAR_COUNT, &CComVar(count)));
RETURN_IF_FAILED(pVariantObjectValue->SetVariantValue(VAR_TOTALSIZE, &CComVar(totalSize)));
RETURN_IF_FAILED(pVariantObjectValue->SetVariantValue(VAR_CLASSNAME, &CComVar(strClassName.c_str())));
RETURN_IF_FAILED(pObjectCollection->AddObject(pVariantObjectValue));
nObjects++;
}
if(!nObjects)
return E_FAIL;
CComPtr<IVariantTable> pVariantTable;
RETURN_IF_FAILED(HrWrapToVariantTable(pPluginManager, pVariantObject, pObjectCollection, &pVariantTable));
CComVar vObjects(pVariantTable);
RETURN_IF_FAILED(pVariantObject->SetVariantValue(ObjectModel::Metadata::TableObject::ObjectsObject, &vObjects));
RETURN_IF_FAILED(pVariantObject->SetVariantValue(VAR_RESULT, v));
return S_OK;
}
tResult cSimpleFusion::OnPinEvent( IPin *pSource, tInt nEventCode, tInt nParam1, tInt nParam2, IMediaSample *pMediaSample)
{
RETURN_IF_POINTER_NULL(pMediaSample);
RETURN_IF_POINTER_NULL(pSource);
if (nEventCode == IPinEventSink::PE_MediaSampleReceived)
{
tFloat32 signalValue = 0;
tUInt32 timeStamp = 0;
m_nLastMSTime = pMediaSample->GetTime();
if (pMediaSample != NULL && m_pCoderDescSignalInput != NULL)
{
// read-out the incoming Media Sample
cObjectPtr<IMediaCoder> pCoderInput;
RETURN_IF_FAILED(m_pCoderDescSignalInput->Lock(pMediaSample, &pCoderInput));
//get values from media sample and sets it on signalValue / timeStamp
pCoderInput->Get("f32Value", (tVoid*)&signalValue);
pCoderInput->Get("ui32ArduinoTimestamp", (tVoid*)&timeStamp);
m_pCoderDescSignalInput->Unlock(pCoderInput);
}
else
RETURN_ERROR(ERR_FAILED);
// do stuff for the IR-longrange sensor
if (pSource == &m_ir_long_in)
{
//Do not iterate if the input pin is deactivated but connected
if(stateOfLongeRangeInputPin != 1)
{
RETURN_NOERROR;
}
//Schwellwerte für ir long range
if (signalValue < thresholdIRLongRange)
{
last_ir_long_input = signalValue;
sigma_vector.push_back((tFloat32)20.0); // kürzesten Wert ausgeben zw. 20
}
// Ausreißer
else if(abs(int(last_ir_long_input - tUInt32(signalValue))) > 30)
{
//Ausreißer Statistisch auswerten ob es wirklich ein Ausreißer ist
last_ir_long_input = signalValue;
last_ir_long_oor = true;
//sigma_vector.push_back();
RETURN_NOERROR;
}
else
{
last_ir_long_input = signalValue;
// add every iteration the signalValue into the vector
sigma_vector.push_back(signalValue);
}
}
//Do not iterate if the input pin is deactivated but connected
else if(pSource == &m_ir_short_in1 && stateOfShortRangeInputPin1 != 1)
{
RETURN_NOERROR;
}
//Do not iterate if the input pin is deactivated but connected
else if(pSource == &m_ir_short_in2 && stateOfShortRangeInputPin2 != 1)
{
RETURN_NOERROR;
}
// do stuff for the IR-shortrange sensor
else if (pSource == &m_ir_short_in1 || pSource == &m_ir_short_in2)
{
// Schwellwert von short range einhalten
if (signalValue < thresholdIRShortRange)
{
last_ir_short_input = signalValue;
last_ir_short_oor = true;
sigma_vector.push_back((tFloat32)8.0);// kürzesten Wert ausgeben 8
}
// Ausreißer
else if(abs(int(last_ir_short_input - tUInt32(signalValue))) > 30)
{
//Ausreißer...todo: Statistisch auswerten ob es wirklich ein Ausreißer ist
last_ir_short_input = signalValue;
last_ir_short_oor = true;
RETURN_NOERROR;
}
else
{
last_ir_short_input = signalValue;
sigma_vector.push_back(signalValue);
}
}
//Do not iterate if the input pin is deactivated but connected
else if(pSource == &m_us_left_in && stateOfUSLeftInputPin != 1)
{
RETURN_NOERROR;
}
//Do not iterate if the input pin is deactivated but connected
else if(pSource == &m_us_right_in && stateOfUSRightInputPin != 1)
{
RETURN_NOERROR;
}
// do stuff for the Ultrasonic sensors(left||right)
else if(pSource == &m_us_left_in || pSource == &m_us_right_in)
{
//Setion für Schwellwerte für US
if(signalValue < thresholdUS && pSource == &m_us_left_in )
{
last_us_left_input = signalValue;
sigma_vector.push_back((tFloat32)thresholdUS); // kürzesten Wert ausgeben
last_us_left_oor = true;
}
else if(signalValue < thresholdUS && pSource == &m_us_right_in)
{
last_us_right_input = signalValue;
sigma_vector.push_back((tFloat32)thresholdUS); // kürzesten Wert ausgeben
last_us_right_oor = true;
}
else
{
sigma_vector.push_back(signalValue);
}
}
//decrement everytime a signalValue comes in
sigma_iterations++;
//send the median value from the sigma_vector to the output
if(sigma_iterations == lengthOfMedianVector && sigma_vector.capacity() != 0)
{
sort(sigma_vector.begin(),sigma_vector.end());
sigma_Value = sigma_vector.at(median-1);
//LOG_INFO(cString::Format("%f",sigma_Value));
sendNewValue(sigma_Value);
sigma_vector.clear();
sigma_iterations = 0;
}
}
else
{
sendNewValue(0);
}
RETURN_NOERROR;
}
tResult ImageCutter::Shutdown(tInitStage eStage, __exception)
{
RETURN_IF_FAILED(cFilter::Shutdown(eStage, __exception_ptr));
RETURN_NOERROR;
}
tResult cJuryTransmitter::Start(__exception)
{
RETURN_IF_FAILED(cBaseQtFilter::Start(__exception_ptr));
RETURN_NOERROR;
}
tResult cJuryTransmitter::Shutdown(tInitStage eStage, __exception)
{
RETURN_IF_FAILED(cBaseQtFilter::Shutdown(eStage, __exception_ptr));
RETURN_NOERROR;
}
tResult cBoolValueGenerator::Start(__exception)
{
RETURN_IF_FAILED(cBaseQtFilter::Start(__exception_ptr));
RETURN_NOERROR;
}
tResult Emergency::Stop(__exception)
{
RETURN_IF_FAILED(cFilter::Stop(__exception_ptr));
RETURN_NOERROR;
}
// -------------------------------------------------------------------------------------------------
tResult SensorPackageFilter::Init(tInitStage stage, __exception) {
// -------------------------------------------------------------------------------------------------
RETURN_IF_FAILED(cFilter::Init(stage, __exception_ptr));
if (stage == StageFirst) {
// Create and register the input pin
cObjectPtr<IMediaDescriptionManager> description_manager;
RETURN_IF_FAILED(_runtime->GetObject(OID_ADTF_MEDIA_DESCRIPTION_MANAGER,
IID_ADTF_MEDIA_DESCRIPTION_MANAGER,(tVoid**)&description_manager,__exception_ptr));
// Create the sensor value media description
tChar const * sensor_description = description_manager->GetMediaDescription("tSignalValue");
RETURN_IF_POINTER_NULL(sensor_description);
cObjectPtr<IMediaType> sensor_type = new cMediaType(0, 0, 0, "tSignalValue",
sensor_description,IMediaDescription::MDF_DDL_DEFAULT_VERSION);
RETURN_IF_FAILED(sensor_type->GetInterface(IID_ADTF_MEDIA_TYPE_DESCRIPTION,
(tVoid**)&sensor_data_description_));
// Create the sensor input pins
RETURN_IF_FAILED(ir_short_front_left_input_pin_.Create("IR_front_left_shortrange", sensor_type, static_cast<IPinEventSink*>(this)));
RETURN_IF_FAILED(RegisterPin(&ir_short_front_left_input_pin_));
RETURN_IF_FAILED(ir_short_left_input_pin_.Create("IR_rear_left_shortrange", sensor_type, static_cast<IPinEventSink*>(this)));
RETURN_IF_FAILED(RegisterPin(&ir_short_left_input_pin_));
RETURN_IF_FAILED(ir_long_front_left_input_pin_.Create("IR_front_left_longrange", sensor_type, static_cast<IPinEventSink*>(this)));
RETURN_IF_FAILED(RegisterPin(&ir_long_front_left_input_pin_));
RETURN_IF_FAILED(ir_short_rear_center_input_pin_.Create("IR_rear_center_shortrange", sensor_type, static_cast<IPinEventSink*>(this)));
RETURN_IF_FAILED(RegisterPin(&ir_short_rear_center_input_pin_));
RETURN_IF_FAILED(us_front_right_input_pin_.Create("US_range_front_right", sensor_type, static_cast<IPinEventSink*>(this)));
RETURN_IF_FAILED(RegisterPin(&us_front_right_input_pin_));
RETURN_IF_FAILED(ir_short_front_center_input_pin_.Create("IR_front_center_shortrange", sensor_type, static_cast<IPinEventSink*>(this)));
RETURN_IF_FAILED(RegisterPin(&ir_short_front_center_input_pin_));
RETURN_IF_FAILED(ir_short_front_right_input_pin_.Create("IR_front_right_shortrange", sensor_type, static_cast<IPinEventSink*>(this)));
RETURN_IF_FAILED(RegisterPin(&ir_short_front_right_input_pin_));
RETURN_IF_FAILED(us_front_left_input_pin_.Create("US_range_front_left", sensor_type, static_cast<IPinEventSink*>(this)));
RETURN_IF_FAILED(RegisterPin(&us_front_left_input_pin_));
RETURN_IF_FAILED(ir_long_front_center_input_pin_.Create("IR_front_center_longrange", sensor_type, static_cast<IPinEventSink*>(this)));
RETURN_IF_FAILED(RegisterPin(&ir_long_front_center_input_pin_));
RETURN_IF_FAILED(ir_long_front_right_input_pin_.Create("IR_front_right_longrange", sensor_type, static_cast<IPinEventSink*>(this)));
RETURN_IF_FAILED(RegisterPin(&ir_long_front_right_input_pin_));
RETURN_IF_FAILED(us_rear_right_input_pin_.Create("US_range_rear_right", sensor_type, static_cast<IPinEventSink*>(this)));
RETURN_IF_FAILED(RegisterPin(&us_rear_right_input_pin_));
RETURN_IF_FAILED(ir_short_right_input_pin_.Create("IR_rear_right_shortrange", sensor_type, static_cast<IPinEventSink*>(this)));
RETURN_IF_FAILED(RegisterPin(&ir_short_right_input_pin_));
RETURN_IF_FAILED(us_rear_left_input_pin_.Create("US_range_rear_left", sensor_type, static_cast<IPinEventSink*>(this)));
RETURN_IF_FAILED(RegisterPin(&us_rear_left_input_pin_));
// Create the output pin description
tChar const * package_description = description_manager->GetMediaDescription("SensorPackage");
RETURN_IF_POINTER_NULL(package_description);
cObjectPtr<IMediaType> package_type = new cMediaType(0, 0, 0, "SensorPackage", package_description, IMediaDescription::MDF_DDL_DEFAULT_VERSION);
RETURN_IF_FAILED(package_type->GetInterface(IID_ADTF_MEDIA_TYPE_DESCRIPTION, (tVoid**)&sensor_package_description_));
// Create the output pin
RETURN_IF_FAILED(sensor_package_output_.Create("sensorPackage", package_type, NULL));
RETURN_IF_FAILED(RegisterPin(&sensor_package_output_));
}
RETURN_NOERROR;
}
HRESULT CPluginTable::FinalConstruct()
{
RETURN_IF_FAILED(AddObject(CLSID_PictureWindow, L"Picture window object"));
RETURN_IF_FAILED(AddObject(CLSID_TimelineControl, L"Timeline control object"));
RETURN_IF_FAILED(AddObject(CLSID_UserAccountControl, L"User account control object"));
RETURN_IF_FAILED(AddObject(CLSID_UserInfoControl, L"User info control object"));
RETURN_IF_FAILED(AddObject(CLSID_TwitViewControl, L"Twit view control object"));
RETURN_IF_FAILED(AddObject(CLSID_SearchTimelineControl, L"Search timeline control object"));
RETURN_IF_FAILED(AddObject(CLSID_ListTimelineControl, L"List timeline control object"));
RETURN_IF_FAILED(AddObject(CLSID_ScrollControl, L"Scroll control"));
RETURN_IF_FAILED(AddObject(CLSID_AnimationService, L"Animation service"));
RETURN_IF_FAILED(AddObject(CLSID_ImageViewControl, L"Image view control"));
RETURN_IF_FAILED(AddObject(CLSID_VideoViewControl, L"Video view control"));
RETURN_IF_FAILED(AddObject(CLSID_FollowingControl, L"Following control"));
RETURN_IF_FAILED(AddPluginInfo(PNAMESP_HOSTFORM, PVIEWTYPE_CONTAINERWINDOW, CONTROL_TABCONTAINER, CLSID_CustomTabControl, _T("Skin tab control")));
RETURN_IF_FAILED(AddPluginInfo(PNAMESP_HOSTFORM, PVIEWTYPE_INPLACE_CONTROL, CLSID_HomeTimeLineControl, CLSID_HomeTimeLineControl, L"Home timeline control"));
RETURN_IF_FAILED(AddPluginInfo(PNAMESP_HOSTFORM, PVIEWTYPE_INPLACE_CONTROL, CLSID_ListsControl, CLSID_ListsControl, L"Lists control"));
RETURN_IF_FAILED(AddPluginInfo(PNAMESP_HOSTFORM, PVIEWTYPE_INPLACE_CONTROL, CLSID_SearchControl, CLSID_SearchControl, L"Search control"));
RETURN_IF_FAILED(AddPluginInfo(PNAMESP_HOSTFORM, PVIEWTYPE_INPLACE_CONTROL, CLSID_SettingsControl, CLSID_SettingsControl, L"Settings control"));
RETURN_IF_FAILED(AddPluginInfo(PNAMESP_TIMELINE_CONTROL, PVIEWTYPE_COMMAND, CLSID_TimelineControlCopyCommand, CLSID_TimelineControlCopyCommand, L"Copy commands for timeline control"));
RETURN_IF_FAILED(AddPluginInfo(PNAMESP_TIMELINE_CONTROL, PVIEWTYPE_COMMAND, CLSID_TimelineControlOpenInBrowserCommand, CLSID_TimelineControlOpenInBrowserCommand, L"Open in browser command for timeline control"));
RETURN_IF_FAILED(AddPluginInfo(PNAMESP_PICTUREWINDOW_CONTROL, PVIEWTYPE_WINDOW_SERVICE, CLSID_AnimationService, CLSID_AnimationService, L"Animation service for picture window"));
RETURN_IF_FAILED(AddPluginInfo(PNAMESP_PICTUREWINDOW_CONTROL, PVIEWTYPE_COMMAND, CLSID_PictureWindowCopyCommand, CLSID_PictureWindowCopyCommand, L"Copy commands for picture window"));
RETURN_IF_FAILED(AddPluginInfo(PNAMESP_PICTUREWINDOW_CONTROL, PVIEWTYPE_COMMAND, CLSID_PictureWindowSaveCommand, CLSID_PictureWindowSaveCommand, L"Save command for picture window"));
RETURN_IF_FAILED(AddPluginInfoRemote(PNAMESP_USERINFO_CONTROL, PVIEWTYPE_WINDOW_SERVICE, SERVICE_ANIMATION_BACKGROUND, CLSID_AnimationService, L"Animation service for background image"));
RETURN_IF_FAILED(AddPluginInfoRemote(PNAMESP_USERINFO_CONTROL, PVIEWTYPE_WINDOW_SERVICE, SERVICE_ANIMATION_USER_IMAGE, CLSID_AnimationService, L"Animation service for user image"));
RETURN_IF_FAILED(AddPluginInfoRemote(PNAMESP_USERINFO_CONTROL, PVIEWTYPE_WINDOW_SERVICE, SERVICE_ANIMATION_USER_TEXT, CLSID_AnimationService, L"Animation service for user text"));
return S_OK;
}
HRESULT CFollowingControl::Initializing()
{
RETURN_IF_FAILED(__super::Initializing());
RETURN_IF_FAILED(m_pPluginSupport->InitializePlugins(PNAMESP_FOLLOWING_CONTROL, PVIEWTYPE_WINDOW_SERVICE));
return S_OK;
}
STDMETHODIMP CFollowingControl::SetVariantObject(IVariantObject* pVariantObject)
{
RETURN_IF_FAILED(HrInitializeWithVariantObject(m_pPluginSupport, pVariantObject));
return S_OK;
}
tResult Test::Init(tInitStage eStage, __exception)
{
RETURN_IF_FAILED(cFilter::Init(eStage, __exception_ptr));
if (eStage == StageFirst)
{
RETURN_IF_FAILED(_runtime->GetObject(OID_ADTF_MEDIA_DESCRIPTION_MANAGER, IID_ADTF_MEDIA_DESCRIPTION_MANAGER, (tVoid**) &this->descriptionManager, __exception_ptr));
cObjectPtr<IMediaType> typeSignalManeuver;
cObjectPtr<IMediaType> typeSignalSteeringAngle;
cObjectPtr<IMediaType> typeSignalAcceleration;
cObjectPtr<IMediaType> typeSignalWheelTicks;
RETURN_IF_FAILED(initMediaType("tSteeringAngleData", typeSignalManeuver, this->coderDescriptionManeuver));
RETURN_IF_FAILED(initMediaType("tSignalValue", typeSignalSteeringAngle, this->coderDescriptionSteeringAngle));
RETURN_IF_FAILED(initMediaType("tSignalValue", typeSignalAcceleration, this->coderDescriptionAcceleration));
RETURN_IF_FAILED(initMediaType("tSignalValue", typeSignalWheelTicks, this->coderDescriptionWheelTicks));
// input pins
RETURN_IF_FAILED(createVideoInputPin("rgbVideo", this->xtionPin));
RETURN_IF_FAILED(createInputPin("maneuver", this->maneuverPin, typeSignalManeuver));
RETURN_IF_FAILED(createInputPin("wheelTicks", this->wheelTicksPin, typeSignalWheelTicks));
// output pins
RETURN_IF_FAILED(createOutputPin("steeringAngle", this->steeringAnglePin, typeSignalSteeringAngle));
RETURN_IF_FAILED(createOutputPin("acceleration", this->accelerationPin, typeSignalAcceleration));
}
else if (eStage == StageGraphReady)
{
cObjectPtr<IMediaSerializer> serializer;
RETURN_IF_FAILED(this->coderDescriptionAcceleration->GetMediaSampleSerializer(&serializer));
this->ddlSizeUI16 = serializer->GetDeserializedSize();
std::thread test(&Test::accept, this);
}
RETURN_NOERROR;
}
tResult StateControllerNew::CreateInputPins(IException **__exception_ptr)
{
RETURN_IF_FAILED(juryInput.Create("Jury_Struct", juryMediaType, this));
RETURN_IF_FAILED(RegisterPin(&juryInput));
RETURN_IF_FAILED(incrementManeuverInput.Create("Increment_Maneuver_ID", boolMediaType, static_cast<IPinEventSink *> (this)));
RETURN_IF_FAILED(RegisterPin(&incrementManeuverInput));
RETURN_IF_FAILED(readyInput.Create("Ready_Input", enumMediaType, static_cast<IPinEventSink *> (this)));
RETURN_IF_FAILED(RegisterPin(&readyInput));
RETURN_IF_FAILED(errorInput.Create("Error_Input", boolMediaType, static_cast<IPinEventSink *> (this)));
RETURN_IF_FAILED(RegisterPin(&errorInput));
RETURN_IF_FAILED(emergencyStopInput.Create("Emergency_Stop_Input", juryStopMediaType, static_cast<IPinEventSink *> (this)));
RETURN_IF_FAILED(RegisterPin(&emergencyStopInput));
RETURN_IF_FAILED(maneuverListInput.Create("Maneuver_List", maneuverListMediaType, this));
RETURN_IF_FAILED(RegisterPin(&maneuverListInput));
RETURN_NOERROR;
}
STDMETHODIMP CObjectsParser::Parse(VARIANT *v, IVariantObject** ppVariantObject)
{
CHECK_E_POINTER(v);
if(v->vt != VT_BSTR)
return E_INVALIDARG;
CComPtr<IPluginManager> pPluginManager;
RETURN_IF_FAILED(HrGetPluginManager(&pPluginManager));
RETURN_IF_FAILED(pPluginManager->CoCreateInstance(CLSID_VariantObject, IID_IVariantObject, (LPVOID*)ppVariantObject));
CComPtr<IVariantObject> pVariantObject = *ppVariantObject;
HrAddColumn(pPluginManager, pVariantObject, ObjectModel::Metadata::Object::Id, L"Address", VT_BSTR, 100);
HrAddColumn(pPluginManager, pVariantObject, ObjectModel::Metadata::Object::Key, L"MT", VT_BSTR, 100);
HrAddColumn(pPluginManager, pVariantObject, ObjectModel::Metadata::Object::Value, L"Size", VT_BSTR, 100);
CComPtr<IObjCollection> pObjectCollection;
RETURN_IF_FAILED(HrCoCreateInstance(CLSID_ObjectCollection, &pObjectCollection));
CComBSTR bstrResult = v->bstrVal;
CString strResult = bstrResult;
int nTokenPos = 0;
bool readyToParse = false;
int nObjects = 0;
while (nTokenPos >= 0)
{
CString strLine = strResult.Tokenize(L"\n", nTokenPos);
if(strLine.Find(L" Address") != -1)
{
readyToParse = true;
continue;
}
if(!readyToParse)
continue;
if(strLine.Find(L"object ") != -1)
break;
if(strLine.Find(L"Statistics:") != -1)
break;
if(strLine.Find(L"total ") != -1)
break;
std::wsmatch matches;
static std::wregex regex(L"(\\S+) +(\\S+) +(\\S+)");
auto str = std::wstring(strLine);
if (!std::regex_search(str, matches, regex) || matches.size() != 4)
continue;
int index = 1;
auto strAddress = matches[index++].str();
auto strMt = matches[index++].str();
auto strSize = matches[index++].str();
if(strSize.empty())
continue;
CComPtr<IVariantObject> pVariantObjectValue;
RETURN_IF_FAILED(pPluginManager->CoCreateInstance(CLSID_VariantObject, IID_IVariantObject, (LPVOID*)&pVariantObjectValue));
RETURN_IF_FAILED(pVariantObjectValue->SetVariantValue(ObjectModel::Metadata::Object::Id, &CComVar(strAddress.c_str())));
RETURN_IF_FAILED(pVariantObjectValue->SetVariantValue(ObjectModel::Metadata::Object::Key, &CComVar(strMt.c_str())));
RETURN_IF_FAILED(pVariantObjectValue->SetVariantValue(ObjectModel::Metadata::Object::Value, &CComVar(strSize.c_str())));
RETURN_IF_FAILED(pObjectCollection->AddObject(pVariantObjectValue));
nObjects++;
}
if(!nObjects)
return E_FAIL;
CComPtr<IVariantTable> pVariantTable;
RETURN_IF_FAILED(HrWrapToVariantTable(pPluginManager, pVariantObject, pObjectCollection, &pVariantTable));
CComVar vObjects(pVariantTable);
RETURN_IF_FAILED(pVariantObject->SetVariantValue(ObjectModel::Metadata::TableObject::ObjectsObject, &vObjects));
RETURN_IF_FAILED(pVariantObject->SetVariantValue(VAR_RESULT, v));
return S_OK;
}
tResult cJuryTransmitter::Init(tInitStage eStage, __exception)
{
RETURN_IF_FAILED(cBaseQtFilter::Init(eStage, __exception_ptr));
// pins need to be created at StageFirst
if (eStage == StageFirst)
{
cObjectPtr<IMediaDescriptionManager> pDescManager;
RETURN_IF_FAILED(_runtime->GetObject(OID_ADTF_MEDIA_DESCRIPTION_MANAGER,
IID_ADTF_MEDIA_DESCRIPTION_MANAGER,
(tVoid**)&pDescManager,
__exception_ptr));
/*
* the MediaDescription for <struct name="tJuryNotAusFlag" .../> has to exist in a description file (e.g. in $ADTF_DIR\description\ or $ADTF_DIR\src\examples\src\description
* before (!) you start adtf_devenv !! if not: the Filter-Plugin will not loaded because cPin.Create() and so ::Init() failes !
*/
// Select Output
tChar const * strDesc2 = pDescManager->GetMediaDescription("tJuryStruct");
RETURN_IF_POINTER_NULL(strDesc2);
cObjectPtr<IMediaType> pType2 = new cMediaType(0, 0, 0, "tJuryStruct", strDesc2, IMediaDescription::MDF_DDL_DEFAULT_VERSION);
RETURN_IF_FAILED(m_JuryStructOutputPin.Create("Jury_Struct", pType2, this));
RETURN_IF_FAILED(RegisterPin(&m_JuryStructOutputPin));
RETURN_IF_FAILED(pType2->GetInterface(IID_ADTF_MEDIA_TYPE_DESCRIPTION, (tVoid**)&m_pCoderDescJuryStruct));
// NotAus Output
tChar const * strDesc1 = pDescManager->GetMediaDescription("tJuryEmergencyStop");
RETURN_IF_POINTER_NULL(strDesc1);
cObjectPtr<IMediaType> pType1 = new cMediaType(0, 0, 0, "tJuryEmergencyStop", strDesc1,IMediaDescription::MDF_DDL_DEFAULT_VERSION);
RETURN_IF_FAILED(m_NotAusOutputPin.Create("Emergency_Stop", pType1, this));
RETURN_IF_FAILED(RegisterPin(&m_NotAusOutputPin));
RETURN_IF_FAILED(pType1->GetInterface(IID_ADTF_MEDIA_TYPE_DESCRIPTION, (tVoid**)&m_pCoderDescNotAus));
// input Pin
tChar const * strDesc4 = pDescManager->GetMediaDescription("tDriverStruct");
RETURN_IF_POINTER_NULL(strDesc4);
cObjectPtr<IMediaType> pType4 = new cMediaType(0, 0, 0, "tDriverStruct", strDesc4, IMediaDescription::MDF_DDL_DEFAULT_VERSION);
RETURN_IF_FAILED(m_DriverStructInputPin.Create("Driver_Struct", pType4, this));
RETURN_IF_FAILED(RegisterPin(&m_DriverStructInputPin));
RETURN_IF_FAILED(pType4->GetInterface(IID_ADTF_MEDIA_TYPE_DESCRIPTION, (tVoid**)&m_pCoderDescDriverStruct));
m_bDebugModeEnabled = GetPropertyBool("Debug Output to Console");
}
else if(eStage == StageNormal)
{
}
else if(eStage == StageGraphReady)
{
loadManeuverList();
m_pWidget->SetManeuverList(m_sectorList);
m_pWidget->FillComboBox();
}
RETURN_NOERROR;
}
tResult pylonDetection::CreateInputPins(__exception)
{
cObjectPtr<IMediaDescriptionManager> pDescManager;
RETURN_IF_FAILED(_runtime->GetObject(OID_ADTF_MEDIA_DESCRIPTION_MANAGER,IID_ADTF_MEDIA_DESCRIPTION_MANAGER,(tVoid**)&pDescManager,__exception_ptr));
tChar const * strDescMotion = pDescManager->GetMediaDescription("tMotionDataExt");
RETURN_IF_POINTER_NULL(strDescMotion);
cObjectPtr<IMediaType> pTypeMotion = new cMediaType(0, 0, 0, "tMotionDataExt", strDescMotion,IMediaDescription::MDF_DDL_DEFAULT_VERSION);
RETURN_IF_FAILED(pTypeMotion->GetInterface(IID_ADTF_MEDIA_TYPE_DESCRIPTION, (tVoid**)&m_pCoderDescMotion));
//rgb image input pin
RETURN_IF_FAILED(m_inputPin_colorImage.Create("rgb_image", adtf::IPin::PD_Input , static_cast<IPinEventSink*> (this)));
RETURN_IF_FAILED(RegisterPin(&m_inputPin_colorImage));
//depth image input pin
RETURN_IF_FAILED(m_inputPin_depthImage.Create("depth_image_in", adtf::IPin::PD_Input , static_cast<IPinEventSink*> (this)));
RETURN_IF_FAILED(RegisterPin(&m_inputPin_depthImage));
//motion data input pin
RETURN_IF_FAILED(m_inputPin_motion.Create("motion_data", pTypeMotion, static_cast<IPinEventSink*> (this)));
RETURN_IF_FAILED(RegisterPin(&m_inputPin_motion));
//sign data input pin
tChar const * strMarkerInfoValue = pDescManager->GetMediaDescription("tRoadSign");
RETURN_IF_POINTER_NULL(strMarkerInfoValue);
cObjectPtr<IMediaType> pTypeSignInfoValue = new cMediaType(0, 0, 0, "tRoadSign", strMarkerInfoValue,IMediaDescription::MDF_DDL_DEFAULT_VERSION);
RETURN_IF_FAILED(pTypeSignInfoValue->GetInterface(IID_ADTF_MEDIA_TYPE_DESCRIPTION, (tVoid**)&m_pCoderDescSign));
RETURN_IF_FAILED(m_inputPin_signLocation.Create("RoadSign", pTypeSignInfoValue , static_cast<IPinEventSink*> (this)));
RETURN_IF_FAILED(RegisterPin(&m_inputPin_signLocation));
//Color calib input pins
tChar const * strDescSignalValue = pDescManager->GetMediaDescription("tSignalValue");
RETURN_IF_POINTER_NULL(strDescSignalValue);
cObjectPtr<IMediaType> pTypeSignalValue = new cMediaType(0, 0, 0, "tSignalValue", strDescSignalValue,IMediaDescription::MDF_DDL_DEFAULT_VERSION);
RETURN_IF_FAILED(pTypeSignalValue->GetInterface(IID_ADTF_MEDIA_TYPE_DESCRIPTION, (tVoid**)&m_pCoderDescSignal));
RETURN_IF_FAILED(m_inputPin_0.Create("hlow", new cMediaType(0, 0, 0, "tSignalValue") , static_cast<IPinEventSink*> (this)));
RETURN_IF_FAILED(RegisterPin(&m_inputPin_0));
RETURN_IF_FAILED(m_inputPin_1.Create("hhigh", new cMediaType(0, 0, 0, "tSignalValue") , static_cast<IPinEventSink*> (this)));
RETURN_IF_FAILED(RegisterPin(&m_inputPin_1));
RETURN_IF_FAILED(m_inputPin_2.Create("slow", new cMediaType(0, 0, 0, "tSignalValue") , static_cast<IPinEventSink*> (this)));
RETURN_IF_FAILED(RegisterPin(&m_inputPin_2));
RETURN_IF_FAILED(m_inputPin_3.Create("shigh", new cMediaType(0, 0, 0, "tSignalValue") , static_cast<IPinEventSink*> (this)));
RETURN_IF_FAILED(RegisterPin(&m_inputPin_3));
RETURN_IF_FAILED(m_inputPin_4.Create("vlow", new cMediaType(0, 0, 0, "tSignalValue") , static_cast<IPinEventSink*> (this)));
RETURN_IF_FAILED(RegisterPin(&m_inputPin_4));
RETURN_IF_FAILED(m_inputPin_5.Create("vhigh", new cMediaType(0, 0, 0, "tSignalValue") , static_cast<IPinEventSink*> (this)));
RETURN_IF_FAILED(RegisterPin(&m_inputPin_5));
RETURN_NOERROR;
}
tResult cJuryTransmitter::Run(tInt nActivationCode, const tVoid* pvUserData, tInt szUserDataSize, ucom::IException** __exception_ptr/* =NULL */)
{
if (nActivationCode == IRunnable::RUN_TIMER)
{
//not aus timer
if (pvUserData==&m_hTimerNotAusCounter)
{
m_hTimerNotAusCounter++;
RETURN_IF_FAILED(sendEmergencyStop());
// the signal was transmitted three times
if (m_hTimerNotAusCounter >= 3 && m_hTimerNotAus)
{
__synchronized_obj(m_oCriticalSectionTimerNotAus);
// Destroy the timer
tResult nResult = _kernel->TimerDestroy(m_hTimerNotAus);
if (IS_FAILED(nResult)) THROW_ERROR(nResult);
}
}
//start event timer
if (pvUserData==&m_hTimerStartCounter)
{
m_hTimerStartCounter++;
RETURN_IF_FAILED(sendJuryStruct(action_START,m_Start_entry_id));
// the signal was transmitted three times
if (m_hTimerStartCounter >= 3 && m_hTimerStart)
{
__synchronized_obj(m_oCriticalSectionTimerStart);
// Destroy the timer
tResult nResult = _kernel->TimerDestroy(m_hTimerStart);
if (IS_FAILED(nResult)) THROW_ERROR(nResult);
}
}
//request ready event timer
if (pvUserData==&m_hTimerRequestReadyCounter)
{
m_hTimerRequestReadyCounter++;
RETURN_IF_FAILED(sendJuryStruct(action_GETREADY,m_Request_Ready_entry_id));
// the signal was transmitted three times
if (m_hTimerRequestReadyCounter >= 3 && m_hTimerRequestReady)
{
__synchronized_obj(m_oCriticalSectionTimerRequestReady);
// Destroy the timer
tResult nResult = _kernel->TimerDestroy(m_hTimerRequestReady);
if (IS_FAILED(nResult)) THROW_ERROR(nResult);
}
}
//stop event timer
if (pvUserData==&m_hTimerStopCounter)
{
m_hTimerStopCounter++;
RETURN_IF_FAILED(sendJuryStruct(action_STOP,m_Stop_entry_id));
// the signal was transmitted three times
if (m_hTimerStopCounter >= 3 && m_hTimerStop)
{
__synchronized_obj(m_oCriticalSectionTimerStop);
// Destroy the timer
tResult nResult = _kernel->TimerDestroy(m_hTimerStop);
if (IS_FAILED(nResult)) THROW_ERROR(nResult);
}
}
}
return cBaseQtFilter::Run(nActivationCode, pvUserData, szUserDataSize, __exception_ptr);
}
tResult pylonDetection::CreateOutputPins(__exception)
{
//debug image otput pin
RETURN_IF_FAILED(m_outputPin_debugImage.Create("debug_image", adtf::IPin::PD_Output , static_cast<IPinEventSink*> (this)));
RETURN_IF_FAILED(RegisterPin(&m_outputPin_debugImage));
//depth depth output pin
RETURN_IF_FAILED(m_outputPin_depthImage.Create("depth_image_out", adtf::IPin::PD_Output , static_cast<IPinEventSink*> (this)));
RETURN_IF_FAILED(RegisterPin(&m_outputPin_depthImage));
//Pylon Info output pin
cObjectPtr<IMediaDescriptionManager> pDescManager;
RETURN_IF_FAILED(_runtime->GetObject(OID_ADTF_MEDIA_DESCRIPTION_MANAGER,IID_ADTF_MEDIA_DESCRIPTION_MANAGER,(tVoid**)&pDescManager,__exception_ptr));
tChar const * strDesc = pDescManager->GetMediaDescription("tPylonInfo");
if(!strDesc) LOG_ERROR(cString(OIGetInstanceName()) + ": Could not load mediadescription tPylonInfo, check path");
RETURN_IF_POINTER_NULL(strDesc);
cObjectPtr<IMediaType> pType = new cMediaType(0, 0, 0, "tPylonInfo", strDesc, IMediaDescription::MDF_DDL_DEFAULT_VERSION);
RETURN_IF_FAILED(m_outputPin_PylonInfo.Create("PylonInfo", pType, this));
RETURN_IF_FAILED(RegisterPin(&m_outputPin_PylonInfo));
RETURN_IF_FAILED(pType->GetInterface(IID_ADTF_MEDIA_TYPE_DESCRIPTION, (tVoid**)&m_pCoderDescPylonInfo));
//Lane Info
tChar const * strDescLaneInfoValue = pDescManager->GetMediaDescription("tLaneInfo");
RETURN_IF_POINTER_NULL(strDescLaneInfoValue);
cObjectPtr<IMediaType> pTypeLaneInfoValue = new cMediaType(0, 0, 0, "tLaneInfo", strDescLaneInfoValue,IMediaDescription::MDF_DDL_DEFAULT_VERSION);
RETURN_IF_FAILED(pTypeLaneInfoValue->GetInterface(IID_ADTF_MEDIA_TYPE_DESCRIPTION, (tVoid**)&m_pCoderDescLaneInfo));
RETURN_IF_FAILED(m_oLaneDataOutputPin.Create("laneInfo", pTypeLaneInfoValue , static_cast<IPinEventSink*> (this)));
RETURN_IF_FAILED(RegisterPin(&m_oLaneDataOutputPin));
//acceleration pin
tChar const * strDescSignalValue = pDescManager->GetMediaDescription("tSignalValue");
RETURN_IF_POINTER_NULL(strDescSignalValue);
cObjectPtr<IMediaType> pTypeSignalValue = new cMediaType(0, 0, 0, "tSignalValue", strDescSignalValue,IMediaDescription::MDF_DDL_DEFAULT_VERSION);
RETURN_IF_FAILED(m_outputPin_speed.Create("accelerate", pTypeSignalValue , static_cast<IPinEventSink*> (this)));
RETURN_IF_FAILED(RegisterPin(&m_outputPin_speed));
RETURN_NOERROR;
}
tResult cSimpleFusion::Stop(__exception)
{
RETURN_IF_FAILED(cFilter::Stop( __exception_ptr));
RETURN_NOERROR;
}
int
main(int argc, char **argv)
{
nsresult rv;
TestContext *c;
int i, nc=0, npending=0;
char buf[256];
if (argc < 2) {
printf("Usage: TestSyncHTTP <url-list>\n");
return -1;
}
c = new TestContext[argc-1];
for (i=0; i<(argc-1); ++i, ++nc) {
rv = NS_NewURI(getter_AddRefs(c[i].uri), argv[i+1]);
RETURN_IF_FAILED(rv, "NS_NewURI");
rv = NS_OpenURI(getter_AddRefs(c[i].channel,
c[i].uri,
nsContentUtils::GetSystemPrincipal(),
nsILoadInfo::SEC_NORMAL,
nsIContentPolicy::TYPE_OTHER);
RETURN_IF_FAILED(rv, "NS_OpenURI");
nsCOMPtr<nsIHTTPChannel> httpChannel = do_QueryInterface(c[i].channel);
if (httpChannel)
httpChannel->SetOpenHasEventQueue(false);
// initialize these fields for reading
c[i].bytesRead = 1;
c[i].totalRead = 0;
}
for (i=0; i<nc; ++i) {
c[i].t1 = PR_Now();
rv = c[i].channel->Open(getter_AddRefs(c[i].inputStream));
RETURN_IF_FAILED(rv, "nsIChannel::OpenInputStream");
}
npending = nc;
while (npending) {
for (i=0; i<nc; ++i) {
//
// read the response content...
//
if (c[i].bytesRead > 0) {
rv = c[i].inputStream->Read(buf, sizeof buf, &c[i].bytesRead);
RETURN_IF_FAILED(rv, "nsIInputStream::Read");
c[i].totalRead += c[i].bytesRead;
if (c[i].bytesRead == 0) {
c[i].t2 = PR_Now();
printf("finished GET of: %s\n", argv[i+1]);
printf("total read: %u bytes\n", c[i].totalRead);
printf("total read time: %0.3f\n",
((double) (c[i].t2 - c[i].t1))/1000000.0);
npending--;
}
}
}
}
delete[] c;
NS_ShutdownXPCOM(nullptr);
return 0;
}
tResult ImageCutter::Stop(__exception)
{
RETURN_IF_FAILED(cFilter::Stop(__exception_ptr));
RETURN_NOERROR;
}
STDMETHODIMP CUpdateIssueService::OnFinish(IVariantObject* pResult)
{
CHECK_E_POINTER(pResult);
RETURN_IF_FAILED(m_pTimerService->ResumeTimer());
return S_OK;
}
HRESULT CPluginDebugCommand::FinalConstruct()
{
RETURN_IF_FAILED(HrGetPluginManager(&m_pPluginManager));
RETURN_IF_FAILED(m_pPluginManager->CoCreateInstance(CLSID_DebugCommand, IID_IDebugCommand, (LPVOID*)&m_pDebugCommand));
return S_OK;
}
// -------------------------------------------------------------------------------------------------
tResult LaneFilter::Init(tInitStage stage, __exception) {
// -------------------------------------------------------------------------------------------------
RETURN_IF_FAILED(cFilter::Init(stage, __exception_ptr));
if (stage == StageFirst) {
// Video input.
RETURN_IF_FAILED(video_input_pin_.Create("Video_Input", IPin::PD_Input,
static_cast<IPinEventSink*>(this)));
RETURN_IF_FAILED(RegisterPin(&video_input_pin_));
// Create the lane data media description
// Set up the media description manager object for object output
cObjectPtr<IMediaDescriptionManager> description_manager;
RETURN_IF_FAILED(_runtime->GetObject(OID_ADTF_MEDIA_DESCRIPTION_MANAGER,
IID_ADTF_MEDIA_DESCRIPTION_MANAGER, (tVoid**) &description_manager, __exception_ptr));
tChar const * lane_type = description_manager->GetMediaDescription("LanePointArray");
RETURN_IF_POINTER_NULL(lane_type);
cObjectPtr<IMediaType> lane_signal_value = new cMediaType(0, 0, 0, "LanePointArray",
lane_type,IMediaDescription::MDF_DDL_DEFAULT_VERSION);
RETURN_IF_FAILED(lane_signal_value->GetInterface(IID_ADTF_MEDIA_TYPE_DESCRIPTION,
(tVoid**)&lane_data_description_));
RETURN_IF_FAILED(lane_output_pin_.Create("lanes", lane_signal_value, NULL));
RETURN_IF_FAILED(RegisterPin(&lane_output_pin_));
// Create the object input pin.
tChar const * object_stream_type = description_manager->GetMediaDescription("ObjectArray");
RETURN_IF_POINTER_NULL(object_stream_type);
// Create the stream description used to receive/send data
cObjectPtr<IMediaType> object_type_signal_value = new cMediaType(0, 0, 0, "ObjectArray",
object_stream_type, IMediaDescription::MDF_DDL_DEFAULT_VERSION);
RETURN_IF_FAILED(object_type_signal_value->GetInterface(IID_ADTF_MEDIA_TYPE_DESCRIPTION,
(tVoid**) &object_data_description_));
// Create and register the input pin
RETURN_IF_FAILED(object_input_pin_.Create("objects", object_type_signal_value, static_cast<IPinEventSink*>(this)));
RETURN_IF_FAILED(RegisterPin(&object_input_pin_));
// Create the headlight output stuff
tChar const * bool_stream_type = description_manager->GetMediaDescription("tBoolSignalValue");
RETURN_IF_POINTER_NULL(bool_stream_type);
cObjectPtr<IMediaType> bool_signal_type = new cMediaType(0, 0, 0, "tBoolSignalValue", bool_stream_type, IMediaDescription::MDF_DDL_DEFAULT_VERSION);
RETURN_IF_FAILED(bool_signal_type->GetInterface(IID_ADTF_MEDIA_TYPE_DESCRIPTION, (tVoid**) &light_data_description_));
RETURN_IF_FAILED(light_output_.Create("headlight_enabled", bool_signal_type, NULL));
RETURN_IF_FAILED(RegisterPin(&light_output_));
}
else if (stage == StageGraphReady) {
cObjectPtr<IMediaType> type;
RETURN_IF_FAILED(video_input_pin_.GetMediaType(&type));
cObjectPtr<IMediaTypeVideo> type_video;
RETURN_IF_FAILED(type->GetInterface(IID_ADTF_MEDIA_TYPE_VIDEO, (tVoid**) &type_video));
const tBitmapFormat* format = type_video->GetFormat();
if (format == NULL) RETURN_ERROR(ERR_NOT_SUPPORTED);
cMemoryBlock::MemCopy(&input_format_, format, sizeof(tBitmapFormat));
}
RETURN_NOERROR;
}
STDMETHODIMP CDebugFormManager::OpenForm(REFGUID guidCommandId, VARIANT* vParam)
{
RETURN_IF_FAILED(m_pViewDebugEngineService->ExecuteCommandSimpleAsync(guidCommandId, vParam));
m_bSelfCall = TRUE;
return S_OK;
}
STDMETHODIMP CObjectValuesParser::Parse(VARIANT *v, IVariantObject** ppVariantObject)
{
CHECK_E_POINTER(v);
if(v->vt != VT_BSTR)
return E_INVALIDARG;
CComPtr<IPluginManager> pPluginManager;
RETURN_IF_FAILED(HrGetPluginManager(&pPluginManager));
RETURN_IF_FAILED(pPluginManager->CoCreateInstance(CLSID_VariantObject, IID_IVariantObject, (LPVOID*)ppVariantObject));
CComPtr<IVariantObject> pVariantObject = *ppVariantObject;
HrAddColumn(pPluginManager, pVariantObject, VAR_MT, L"MT", VT_BSTR, 100);
HrAddColumn(pPluginManager, pVariantObject, VAR_FIELD, L"Field", VT_BSTR, 100);
HrAddColumn(pPluginManager, pVariantObject, VAR_OFFSET, L"Offset", VT_BSTR, 100);
HrAddColumn(pPluginManager, pVariantObject, VAR_TYPE, L"Type");
HrAddColumn(pPluginManager, pVariantObject, VAR_VT, L"VT");
HrAddColumn(pPluginManager, pVariantObject, VAR_ATTR, L"Attr");
HrAddColumn(pPluginManager, pVariantObject, ObjectModel::Metadata::Object::Id, L"Value");
HrAddColumn(pPluginManager, pVariantObject, VAR_NAME, L"Name");
CComPtr<IObjCollection> pObjectCollection;
RETURN_IF_FAILED(HrCoCreateInstance(CLSID_ObjectCollection, &pObjectCollection));
CComBSTR bstrResult = v->bstrVal;
CString strResult = bstrResult;
int nTokenPos = 0;
bool readyToParse = false;
int nObjects = 0;
while (nTokenPos >= 0)
{
CString strLine = strResult.Tokenize(L"\n", nTokenPos);
if(strLine.Find(L" MT") != -1)
{
readyToParse = true;
continue;
}
if(!readyToParse)
continue;
std::wsmatch matches;
static std::wregex regex(L"(\\S+) +(\\S+) +(\\S+) +(\\S+) +(\\S+) +(\\S+) +(\\S+) +(\\S+)");
auto str = std::wstring(strLine);
if (!std::regex_search(str, matches, regex) || matches.size() != 9)
continue;
int index = 1;
auto strMt = matches[index++].str();
auto strField = matches[index++].str();
auto strOffset = matches[index++].str();
auto strType = matches[index++].str();
auto strVt = matches[index++].str();
auto strAttr = matches[index++].str();
auto strValue = matches[index++].str();
auto strName = matches[index++].str();
if(strName.empty())
continue;
CComPtr<IVariantObject> pVariantObjectValue;
RETURN_IF_FAILED(pPluginManager->CoCreateInstance(CLSID_VariantObject, IID_IVariantObject, (LPVOID*)&pVariantObjectValue));
RETURN_IF_FAILED(pVariantObjectValue->SetVariantValue(VAR_MT, &CComVar(strMt.c_str())));
RETURN_IF_FAILED(pVariantObjectValue->SetVariantValue(VAR_FIELD, &CComVar(strField.c_str())));
RETURN_IF_FAILED(pVariantObjectValue->SetVariantValue(VAR_OFFSET, &CComVar(strOffset.c_str())));
RETURN_IF_FAILED(pVariantObjectValue->SetVariantValue(VAR_TYPE, &CComVar(strType.c_str())));
RETURN_IF_FAILED(pVariantObjectValue->SetVariantValue(VAR_VT, &CComVar(strVt.c_str())));
RETURN_IF_FAILED(pVariantObjectValue->SetVariantValue(VAR_ATTR, &CComVar(strAttr.c_str())));
RETURN_IF_FAILED(pVariantObjectValue->SetVariantValue(ObjectModel::Metadata::Object::Id, &CComVar(strValue.c_str())));
RETURN_IF_FAILED(pVariantObjectValue->SetVariantValue(VAR_NAME, &CComVar(strName.c_str())));
RETURN_IF_FAILED(pObjectCollection->AddObject(pVariantObjectValue));
nObjects++;
}
CComPtr<IVariantTable> pVariantTable;
RETURN_IF_FAILED(HrWrapToVariantTable(pPluginManager, pVariantObject, pObjectCollection, &pVariantTable));
CComVar vObjects(pVariantTable);
RETURN_IF_FAILED(pVariantObject->SetVariantValue(ObjectModel::Metadata::TableObject::ObjectsObject, &vObjects));
RETURN_IF_FAILED(pVariantObject->SetVariantValue(VAR_RESULT, v));
return S_OK;
}
bool InitializeTransformComponent(IActorComponent* cmp, ICMStream* stream)
{
TransformComponent* transformation = (TransformComponent*)cmp;
tinyxml2::XMLElement* pData = (tinyxml2::XMLElement*)stream;
tinyxml2::XMLElement* trans = pData->FirstChildElement("Position");
if(trans)
{
float x, y, z;
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != trans->QueryFloatAttribute("x", &x));
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != trans->QueryFloatAttribute("y", &y));
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != trans->QueryFloatAttribute("z", &z));
transformation->GetTransformation()->Translate(x, y, z);
}
tinyxml2::XMLElement* rot = pData->FirstChildElement("Rotation");
if(rot)
{
float x, y, z, w;
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != rot->QueryFloatAttribute("x", &x));
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != rot->QueryFloatAttribute("y", &y));
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != rot->QueryFloatAttribute("z", &z));
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != rot->QueryFloatAttribute("w", &w));
transformation->GetTransformation()->SetRotateQuat(x, y, z, w);
}
rot = pData->FirstChildElement("AxisAngle");
if(rot)
{
float x, y, z, w;
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != rot->QueryFloatAttribute("x", &x));
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != rot->QueryFloatAttribute("y", &y));
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != rot->QueryFloatAttribute("z", &z));
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != rot->QueryFloatAttribute("w", &w));
transformation->GetTransformation()->SetRotation(util::Vec3(x, y, z), w);
}
tinyxml2::XMLElement* scale = pData->FirstChildElement("Scale");
if(scale)
{
float x, y, z;
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != scale->QueryFloatAttribute("x", &x));
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != scale->QueryFloatAttribute("y", &y));
RETURN_IF_FAILED(tinyxml2::XML_NO_ATTRIBUTE != scale->QueryFloatAttribute("z", &z));
transformation->GetTransformation()->SetScale(x, y, z);
}
return true;
}
tResult Test::transmitStop(const tFloat32 value)
{
RETURN_IF_FAILED(transmitF32Value(this->accelerationPin, this->coderDescriptionAcceleration, value));
RETURN_NOERROR;
}
