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; }