tResult ROI::SendRoi(const tRect &roi, cOutputPin &outputPin)
{
if (!outputPin.IsConnected())
{
RETURN_NOERROR;
}
cObjectPtr<IMediaSample> mediaSample;
RETURN_IF_FAILED(AllocMediaSample((tVoid **) &mediaSample));
cObjectPtr<IMediaSerializer> pSerializer;
tRectDescriptionSignal->GetMediaSampleSerializer(&pSerializer);
tInt nSize = pSerializer->GetDeserializedSize();
RETURN_IF_FAILED(mediaSample->AllocBuffer(nSize));
{
__adtf_sample_write_lock_mediadescription(tRectDescriptionSignal, mediaSample, pCoder);
pCoder->Set("tX", (tVoid *) &roi.tX);
pCoder->Set("tY", (tVoid *) &roi.tY);
pCoder->Set("tWidth", (tVoid *) &roi.tWidth);
pCoder->Set("tHeight", (tVoid *) &roi.tHeight);
}
//transmit media sample over output pin
mediaSample->SetTime(_clock->GetStreamTime());
RETURN_IF_FAILED(outputPin.Transmit(mediaSample));
RETURN_NOERROR;
}
tResult StateControllerNew::SendValue(cOutputPin &pin, stateCar state, tInt16 maneuver)
{
if (!pin.IsConnected())
{
RETURN_NOERROR;
}
cObjectPtr<IMediaSample> mediaSample;
RETURN_IF_FAILED(AllocMediaSample((tVoid **) &mediaSample));
cObjectPtr<IMediaSerializer> driverSerializer;
driveStructDescription->GetMediaSampleSerializer(&driverSerializer);
tInt nSize = driverSerializer->GetDeserializedSize();
RETURN_IF_FAILED(mediaSample->AllocBuffer(nSize));
tInt8 carState = tInt8(state);
{
__adtf_sample_write_lock_mediadescription(driveStructDescription, mediaSample, pCoder);
pCoder->Set("i8StateID", (tVoid *) &carState);
pCoder->Set("i16ManeuverEntry", (tVoid *) &maneuver);
}
mediaSample->SetTime(_clock->GetStreamTime());
RETURN_IF_FAILED(pin.Transmit(mediaSample));
RETURN_NOERROR;
}
tResult YawToSteer::TransmitSignalValue(cOutputPin *outputPin, tFloat32 value)
{
__synchronized_obj(iosync);
tUInt32 timeStamp = 0;
cObjectPtr<IMediaSerializer> pSerializer;
descriptionSignalValue->GetMediaSampleSerializer(&pSerializer);
tInt nSize = pSerializer->GetDeserializedSize();
cObjectPtr<IMediaSample> newMediaSample;
AllocMediaSample((tVoid **) &newMediaSample);
newMediaSample->AllocBuffer(nSize);
{
__adtf_sample_write_lock_mediadescription(descriptionSignalValue, newMediaSample, pCoderOutput);
if (!m_bIDsSignalSet)
{
pCoderOutput->GetID("f32Value", m_szIDSignalF32Value);
pCoderOutput->GetID("ui32ArduinoTimestamp", m_szIDSignalArduinoTimestamp);
m_bIDsSignalSet = tTrue;
}
// set values in new media sample
pCoderOutput->Set(m_szIDSignalF32Value, (tVoid *) &(value));
pCoderOutput->Set(m_szIDSignalArduinoTimestamp, (tVoid *) &timeStamp);
}
newMediaSample->SetTime(_clock->GetTime());
outputPin->Transmit(newMediaSample);
RETURN_NOERROR;
}
tResult cJuryTransmitter::sendJuryStruct(juryActions actionID, tInt16 maneuverEntry)
{
cObjectPtr<IMediaSample> pMediaSample;
RETURN_IF_FAILED(AllocMediaSample((tVoid**)&pMediaSample));
cObjectPtr<IMediaSerializer> pSerializer;
m_pCoderDescJuryStruct->GetMediaSampleSerializer(&pSerializer);
tInt nSize = pSerializer->GetDeserializedSize();
RETURN_IF_FAILED(pMediaSample->AllocBuffer(nSize));
{ // focus for sample write lock
__adtf_sample_write_lock_mediadescription(m_pCoderDescJuryStruct,pMediaSample,pCoder);
pCoder->Set("i8ActionID", (tVoid*)&actionID);
pCoder->Set("i16ManeuverEntry", (tVoid*)&maneuverEntry);
}
RETURN_IF_FAILED(pMediaSample->SetTime(_clock->GetStreamTime()));
RETURN_IF_FAILED(m_JuryStructOutputPin.Transmit(pMediaSample));
if(m_bDebugModeEnabled) LOG_INFO(cString::Format("Jury Module: Send: Action %d, Maneuver %d", actionID, maneuverEntry));
RETURN_NOERROR;
}
tResult cJuryModule::sendEmergencyStop()
{
if(m_bDebugModeEnabled) LOG_INFO("Jury Module: Emergency_Stop requested");
cObjectPtr<IMediaSample> pMediaSample;
RETURN_IF_FAILED(AllocMediaSample((tVoid**)&pMediaSample));
cObjectPtr<IMediaSerializer> pSerializer;
m_pDescNotAus->GetMediaSampleSerializer(&pSerializer);
tInt nSize = pSerializer->GetDeserializedSize();
RETURN_IF_FAILED(pMediaSample->AllocBuffer(nSize));
tBool boolValue = true;
{ // focus for sample write lock
__adtf_sample_write_lock_mediadescription(m_pDescNotAus,pMediaSample,pCoder);
// get the IDs for the items in the media sample
if(!m_bIDNotAusSet)
{
pCoder->GetID("bEmergencyStop", m_szIDNotAusbEmergencyStop);
m_bIDNotAusSet = tTrue;
}
pCoder->Set(m_szIDNotAusbEmergencyStop, (tVoid*)&boolValue);
}
pMediaSample->SetTime(_clock->GetStreamTime());
m_NotAusOutputPin.Transmit(pMediaSample);
RETURN_NOERROR;
}
tResult StateControllerNew::SendEnum(cOutputPin &pin, tInt value)
{
if (!pin.IsConnected())
{
RETURN_NOERROR;
}
cObjectPtr<IMediaSample> mediaSample;
RETURN_IF_FAILED(AllocMediaSample((tVoid **) &mediaSample));
cObjectPtr<IMediaSerializer> pSerializer;
enumDescription->GetMediaSampleSerializer(&pSerializer);
tInt nSize = pSerializer->GetDeserializedSize();
RETURN_IF_FAILED(mediaSample->AllocBuffer(nSize));
{
__adtf_sample_write_lock_mediadescription(enumDescription, mediaSample, pCoder);
pCoder->Set("tEnumValue", (tVoid *) &value);
}
mediaSample->SetTime(_clock->GetStreamTime());
RETURN_IF_FAILED(pin.Transmit(mediaSample));
RETURN_NOERROR;
}
void cBoolValueGenerator::OnTransmitValueTrue()
{
cObjectPtr<IMediaSample> pMediaSample;
AllocMediaSample((tVoid**)&pMediaSample);
//allocate memory with the size given by the descriptor
cObjectPtr<IMediaSerializer> pSerializer;
m_pDescriptionBool->GetMediaSampleSerializer(&pSerializer);
pMediaSample->AllocBuffer(pSerializer->GetDeserializedSize());
tBool bValue = tTrue;
tUInt32 ui32TimeStamp = 0;
//write date to the media sample with the coder of the descriptor
{
__adtf_sample_write_lock_mediadescription(m_pDescriptionBool, pMediaSample, pCoderOutput);
// set the id if not already done
if(!m_bIDsBoolValueOutput)
{
pCoderOutput->GetID("bValue", m_szIDBoolValueOutput);
pCoderOutput->GetID("ui32ArduinoTimestamp", m_szIDArduinoTimestampOutput);
m_bIDsBoolValueOutput = tTrue;
}
// set value from sample
pCoderOutput->Set(m_szIDBoolValueOutput, (tVoid*)&bValue);
pCoderOutput->Set(m_szIDArduinoTimestampOutput, (tVoid*)&(ui32TimeStamp));
}
pMediaSample->SetTime(_clock->GetStreamTime());
//transmit media sample over output pin
m_oBoolValuePin.Transmit(pMediaSample);
}
void testPullOutFilter::OnTransmitIntValue(tInt32 pullOutType)
{
LOG_INFO(cString::Format("TPOF: Start pullOutType1 %i", pullOutType) );
cObjectPtr<IMediaSample> pMediaSample;
AllocMediaSample((tVoid**)&pMediaSample);
//allocate memory with the size given by the descriptor
cObjectPtr<IMediaSerializer> pSerializer;
m_pStartInput->GetMediaSampleSerializer(&pSerializer);
pMediaSample->AllocBuffer(pSerializer->GetDeserializedSize());
{
__adtf_sample_write_lock_mediadescription(m_pStartInput, pMediaSample, pCoder);
if (!m_bIDsStartSet) {
pCoder->GetID("intValue", m_szIDManeuvreStartInput);
m_bIDsStartSet = tTrue;
}
// set value from sample
pCoder->Set(m_szIDManeuvreStartInput, (tVoid*)&pullOutType);
}
LOG_INFO(cString::Format("TPOF: Start pullOutType2 %i", pullOutType) );
//transmit media sample over output pin
m_oStartPullOut.Transmit(pMediaSample);
LOG_INFO(cString::Format("TPOF: Start pullOutType3 %i", pullOutType) );
}
//#############################################################################
tResult cMovementAnalyzer::Transmit(tFloat32 fValue, IMediaSample *pMediaSample, tUInt32 ui32TimeStamp, IPin *pSource)
{
//create new media sample
cObjectPtr<IMediaSample> pNewMediaSample;
AllocMediaSample((tVoid **) &pNewMediaSample);
//allocate memory with the size given by the descriptor
cObjectPtr<IMediaSerializer> pSerializer;
m_pDescriptionSignal->GetMediaSampleSerializer(&pSerializer);
tInt nSize = pSerializer->GetDeserializedSize();
pNewMediaSample->AllocBuffer(nSize);
{ // focus for sample write lock
//write date to the media sample with the coder of the descriptor
__adtf_sample_write_lock_mediadescription(m_pDescriptionSignal, pNewMediaSample, pCoderOutput);
// get the IDs for the items in the media sample
if (!m_bIDsSignalSet)
{
pCoderOutput->GetID("f32Value", m_szIDSignalF32Value);
pCoderOutput->GetID("ui32ArduinoTimestamp", m_szIDSignalArduinoTimestamp);
m_bIDsSignalSet = tTrue;
}
// set values in new media sample
pCoderOutput->Set(m_szIDSignalF32Value, (tVoid *) &(fValue));
pCoderOutput->Set(m_szIDSignalArduinoTimestamp, (tVoid *) &ui32TimeStamp);
}
//transmit media sample over output pin
pNewMediaSample->SetTime(pMediaSample->GetTime());
if (pSource == &this->m_oInputSpeed)
{
m_oOutputCalcSpeed.Transmit(pNewMediaSample);
}
if (pSource == &this->m_oInputAccX)
{
m_oOutputCalcAccX.Transmit(pNewMediaSample);
}
if (pSource == &this->m_oInputAccY)
{
m_oOutputCalcAccY.Transmit(pNewMediaSample);
}
if (pSource == &this->m_oInputDistance)
{
m_oOutputCalcDistance.Transmit(pNewMediaSample);
}
RETURN_NOERROR;
}
tResult cDriverModule::OnSendState(stateCar stateID, tInt16 i16ManeuverEntry)
{
cObjectPtr<IMediaSample> pMediaSample;
RETURN_IF_FAILED(AllocMediaSample((tVoid**)&pMediaSample));
cObjectPtr<IMediaSerializer> pSerializer;
m_pDescDriverStruct->GetMediaSampleSerializer(&pSerializer);
tInt nSize = pSerializer->GetDeserializedSize();
tInt8 value = tInt8(stateID);
RETURN_IF_FAILED(pMediaSample->AllocBuffer(nSize));
{ // focus for sample write lock
__adtf_sample_write_lock_mediadescription(m_pDescDriverStruct,pMediaSample,pCoder);
// get the IDs for the items in the media sample
if(!m_bIDsDriverStructSet)
{
pCoder->GetID("i8StateID", m_szIDDriverStructI8StateID);
pCoder->GetID("i16ManeuverEntry", m_szIDDriverStructI16ManeuverEntry);
m_bIDsDriverStructSet = tTrue;
}
pCoder->Set(m_szIDDriverStructI8StateID, (tVoid*)&value);
pCoder->Set(m_szIDDriverStructI16ManeuverEntry, (tVoid*)&i16ManeuverEntry);
}
pMediaSample->SetTime(_clock->GetStreamTime());
m_DriverStructOutputPin.Transmit(pMediaSample);
if(m_bDebugModeEnabled)
{
switch (stateID)
{
case stateCar_READY:
LOG_INFO(cString::Format("Driver Module: Send state: READY, Maneuver ID %d",i16ManeuverEntry));
break;
case stateCar_RUNNING:
LOG_INFO(cString::Format("Driver Module: Send state: RUNNING, Maneuver ID %d",i16ManeuverEntry));
break;
case stateCar_COMPLETE:
LOG_INFO(cString::Format("Driver Module: Send state: COMPLETE, Maneuver ID %d",i16ManeuverEntry));
break;
case stateCar_ERROR:
LOG_INFO(cString::Format("Driver Module: Send state: ERROR, Maneuver ID %d",i16ManeuverEntry));
break;
case stateCar_STARTUP:
break;
}
}
RETURN_NOERROR;
}
void FunctionDriver::SendValue(IMediaSample *mediaSample, cOutputPin &outputPin, tFloat32 value)
{
cObjectPtr<IMediaSerializer> pSerializer;
descriptionSignal->GetMediaSampleSerializer(&pSerializer);
tInt nSize = pSerializer->GetDeserializedSize();
cObjectPtr<IMediaSample> newMediaSample;
AllocMediaSample((tVoid **) &newMediaSample);
newMediaSample->AllocBuffer(nSize);
{
__adtf_sample_write_lock_mediadescription(descriptionSignal, newMediaSample, outputCoder);
outputCoder->Set("f32Value", (tVoid *) &(value));
}
newMediaSample->SetTime(mediaSample->GetTime());
outputPin.Transmit(newMediaSample);
}
// -------------------------------------------------------------------------------------------------
tResult SensorPackageFilter::transmitSensorPackage(tTimeStamp time) {
// -------------------------------------------------------------------------------------------------
cObjectPtr<IMediaSample> media_sample;
RETURN_IF_FAILED(AllocMediaSample((tVoid**)&media_sample));
cObjectPtr<IMediaSerializer> serializer;
sensor_package_description_->GetMediaSampleSerializer(&serializer);
tInt size = serializer->GetDeserializedSize();
RETURN_IF_FAILED(media_sample->AllocBuffer(size));
float value_ir_l_fc = getMeanSensorValue(ir_l_fc_);
float value_ir_l_fl = getMeanSensorValue(ir_l_fl_);
float value_ir_l_fr = getMeanSensorValue(ir_l_fr_);
float value_ir_s_fc = getMeanSensorValue(ir_s_fc_);
float value_ir_s_fl = getMeanSensorValue(ir_s_fl_);
float value_ir_s_fr = getMeanSensorValue(ir_s_fr_);
float value_ir_s_l = getMeanSensorValue(ir_s_l_);
float value_ir_s_r = getMeanSensorValue(ir_s_r_);
float value_ir_s_rc = getMeanSensorValue(ir_s_rc_);
float value_us_f_l = getMeanSensorValue(us_f_l_);
float value_us_f_r = getMeanSensorValue(us_f_r_);
float value_us_r_l = getMeanSensorValue(us_r_l_);
float value_us_r_r = getMeanSensorValue(us_r_r_);
{
__adtf_sample_write_lock_mediadescription(sensor_package_description_, media_sample, coder);
coder->Set("ir_l_fc", (tVoid*) &value_ir_l_fc);
coder->Set("ir_l_fl", (tVoid*) &value_ir_l_fl);
coder->Set("ir_l_fr", (tVoid*) &value_ir_l_fr);
coder->Set("ir_s_fc", (tVoid*) &value_ir_s_fc);
coder->Set("ir_s_fl", (tVoid*) &value_ir_s_fl);
coder->Set("ir_s_fr", (tVoid*) &value_ir_s_fr);
coder->Set("ir_s_l", (tVoid*) &value_ir_s_l);
coder->Set("ir_s_r", (tVoid*) &value_ir_s_r);
coder->Set("ir_s_rc", (tVoid*) &value_ir_s_rc);
coder->Set("us_f_l", (tVoid*) &value_us_f_l);
coder->Set("us_f_r", (tVoid*) &value_us_f_r);
coder->Set("us_r_l", (tVoid*) &value_us_r_l);
coder->Set("us_r_r", (tVoid*) &value_us_r_r);
}
sensor_package_output_.Transmit(media_sample);
RETURN_NOERROR;
}
// -------------------------------------------------------------------------------------------------
tResult EmergencyFilter::transmitBool(cOutputPin & pin, bool value) {
// -------------------------------------------------------------------------------------------------
cObjectPtr<IMediaSample> media_sample;
RETURN_IF_FAILED(AllocMediaSample((tVoid**)&media_sample));
cObjectPtr<IMediaSerializer> serializer;
bool_data_description_->GetMediaSampleSerializer(&serializer);
tInt size = serializer->GetDeserializedSize();
RETURN_IF_FAILED(media_sample->AllocBuffer(size));
tUInt32 timeStamp = 0;
{
__adtf_sample_write_lock_mediadescription(bool_data_description_, media_sample, coder);
coder->Set("bValue", (tVoid*) &value);
coder->Set("ui32ArduinoTimestamp", (tVoid*) &timeStamp);
}
pin.Transmit(media_sample);
RETURN_NOERROR;
}
// -------------------------------------------------------------------------------------------------
tResult LaneFilter::transmitHeadLight(bool value) {
// -------------------------------------------------------------------------------------------------
cObjectPtr<IMediaSample> pMediaSample;
AllocMediaSample((tVoid**)&pMediaSample);
//allocate memory with the size given by the descriptor
cObjectPtr<IMediaSerializer> pSerializer;
light_data_description_->GetMediaSampleSerializer(&pSerializer);
tInt nSize = pSerializer->GetDeserializedSize();
pMediaSample->AllocBuffer(nSize);
tUInt32 time_stamp = 0;
{
__adtf_sample_write_lock_mediadescription(light_data_description_, pMediaSample, coder);
coder->Set("bValue", (tVoid*)&value);
coder->Set("ui32ArduinoTimestamp", (tVoid*)&time_stamp);
}
//transmit media sample over output pin
pMediaSample->SetTime(_clock->GetStreamTime());
light_output_.Transmit(pMediaSample);
RETURN_NOERROR;
}
void cBoolValueGenerator::OnTransmitValueTrue()
{
cObjectPtr<IMediaSample> pMediaSample;
AllocMediaSample((tVoid**)&pMediaSample);
//allocate memory with the size given by the descriptor
cObjectPtr<IMediaSerializer> pSerializer;
m_pCoderDescBool->GetMediaSampleSerializer(&pSerializer);
pMediaSample->AllocBuffer(pSerializer->GetDeserializedSize());
tBool value = tTrue;
//write date to the media sample with the coder of the descriptor
{
__adtf_sample_write_lock_mediadescription(m_pCoderDescBool, pMediaSample, pCoderOutput);
pCoderOutput->Set("bValue",(tVoid*)&(value));
pCoderOutput->Set("ui32ArduinoTimestamp", 0);
}
pMediaSample->SetTime(_clock->GetStreamTime());
//transmit media sample over output pin
m_oBoolValuePin.Transmit(pMediaSample);
}
tResult cUSSSensorBundle::TransmitData(tTimeStamp inputTimeStamp, tFloat32 front_left,tFloat32 front_right, tFloat32 rear_left, tFloat32 rear_right, tUInt32 timestampValue)
{
//create new media sample
cObjectPtr<IMediaSample> pMediaSampleFrontLeft;
cObjectPtr<IMediaSample> pMediaSampleFrontRight;
cObjectPtr<IMediaSample> pMediaSampleRearLeft;
cObjectPtr<IMediaSample> pMediaSampleRearRight;
AllocMediaSample((tVoid**)&pMediaSampleFrontLeft);
AllocMediaSample((tVoid**)&pMediaSampleFrontRight);
AllocMediaSample((tVoid**)&pMediaSampleRearLeft);
AllocMediaSample((tVoid**)&pMediaSampleRearRight);
//allocate memory with the size given by the descriptor
cObjectPtr<IMediaSerializer> pSerializer;
m_pCoderDescSignalOutput->GetMediaSampleSerializer(&pSerializer);
tInt nSize = pSerializer->GetDeserializedSize();
pMediaSampleFrontLeft->AllocBuffer(nSize);
pMediaSampleFrontRight->AllocBuffer(nSize);
pMediaSampleRearLeft->AllocBuffer(nSize);
pMediaSampleRearRight->AllocBuffer(nSize);
{ // focus for sample write lock
//write date to the media sample with the coder of the descriptor
__adtf_sample_write_lock_mediadescription(m_pCoderDescSignalOutput,pMediaSampleFrontLeft,pCoderOutput);
pCoderOutput->Set("f32Value", (tVoid*)&front_left);
pCoderOutput->Set("ui32ArduinoTimestamp", (tVoid*)×tampValue);
}
pMediaSampleFrontLeft->SetTime(inputTimeStamp);
//transmit media sample over output pin
m_outputPin_front_left.Transmit(pMediaSampleFrontLeft);
{ // focus for sample write lock
//write date to the media sample with the coder of the descriptor
__adtf_sample_write_lock_mediadescription(m_pCoderDescSignalOutput,pMediaSampleFrontRight,pCoderOutput);
pCoderOutput->Set("f32Value", (tVoid*)&front_right);
pCoderOutput->Set("ui32ArduinoTimestamp", (tVoid*)×tampValue);
}
pMediaSampleFrontRight->SetTime(inputTimeStamp);
//transmit media sample over output pin
m_outputPin_front_right.Transmit(pMediaSampleFrontRight);
{ // focus for sample write lock
//write date to the media sample with the coder of the descriptor
__adtf_sample_write_lock_mediadescription(m_pCoderDescSignalOutput,pMediaSampleRearLeft,pCoderOutput);
pCoderOutput->Set("f32Value", (tVoid*)&rear_left);
pCoderOutput->Set("ui32ArduinoTimestamp", (tVoid*)×tampValue);
}
pMediaSampleRearLeft->SetTime(inputTimeStamp);
//transmit media sample over output pin
m_outputPin_rear_left.Transmit(pMediaSampleRearLeft);
{ // focus for sample write lock
//write date to the media sample with the coder of the descriptor
__adtf_sample_write_lock_mediadescription(m_pCoderDescSignalOutput,pMediaSampleRearRight,pCoderOutput);
pCoderOutput->Set("f32Value", (tVoid*)&rear_right);
pCoderOutput->Set("ui32ArduinoTimestamp", (tVoid*)×tampValue);
}
pMediaSampleRearRight->SetTime(inputTimeStamp);
//transmit media sample over output pin
m_outputPin_rear_right.Transmit(pMediaSampleRearRight);
RETURN_NOERROR;
}
