tResult cUserAttitudeFilter::TransmitAngles(tTimeStamp sampleTimeStamp, const tTimeStamp timeStampValue, const tFloat32 yaw, const tFloat32 pitch, const tFloat32 roll)
{	
	//create new media sample
    cObjectPtr<IMediaSample> pMediaSampleYaw;
    cObjectPtr<IMediaSample> pMediaSamplePitch;
    cObjectPtr<IMediaSample> pMediaSampleRoll;
    AllocMediaSample((tVoid**)&pMediaSampleYaw);
    AllocMediaSample((tVoid**)&pMediaSamplePitch);
    AllocMediaSample((tVoid**)&pMediaSampleRoll);

    //allocate memory with the size given by the descriptor
    cObjectPtr<IMediaSerializer> pSerializer;
    m_pCoderDescSignal->GetMediaSampleSerializer(&pSerializer);
    tInt nSize = pSerializer->GetDeserializedSize();
    pMediaSampleYaw->AllocBuffer(nSize);
    pMediaSamplePitch->AllocBuffer(nSize);
    pMediaSampleRoll->AllocBuffer(nSize);
    
    cObjectPtr<IMediaCoder> pCoderOutput;
       
    //write date to the media sample with the coder of the descriptor
    m_pCoderDescSignal->WriteLock(pMediaSampleYaw, &pCoderOutput);	
    pCoderOutput->Set("f32Value", (tVoid*)&(yaw));	
    pCoderOutput->Set("ui32ArduinoTimestamp", (tVoid*)&timeStampValue);    
    m_pCoderDescSignal->Unlock(pCoderOutput);
    //transmit media sample over output pin
    pMediaSampleYaw->SetTime(sampleTimeStamp);
    m_oOutputYaw.Transmit(pMediaSampleYaw);
    
    //write date to the media sample with the coder of the descriptor
    m_pCoderDescSignal->WriteLock(pMediaSamplePitch, &pCoderOutput);	
    pCoderOutput->Set("f32Value", (tVoid*)&(pitch));	
    pCoderOutput->Set("ui32ArduinoTimestamp", (tVoid*)&timeStampValue);    
    m_pCoderDescSignal->Unlock(pCoderOutput);
    //transmit media sample over output pin
    pMediaSamplePitch->SetTime(sampleTimeStamp);
    m_oOutputPitch.Transmit(pMediaSamplePitch);
    
    //write date to the media sample with the coder of the descriptor
    m_pCoderDescSignal->WriteLock(pMediaSampleRoll, &pCoderOutput);	
    pCoderOutput->Set("f32Value", (tVoid*)&(roll));	
    pCoderOutput->Set("ui32ArduinoTimestamp", (tVoid*)&timeStampValue);    
    m_pCoderDescSignal->Unlock(pCoderOutput);
    //transmit media sample over output pin
    pMediaSampleRoll->SetTime(sampleTimeStamp);
    m_oOutputRoll.Transmit(pMediaSampleRoll);

	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 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 cSimpleFusion::sendNewValue(tFloat32 flValue)
{
    //tFloat32 flValue= value;
    tUInt32 timeStamp = 0;

    //create new media sample
    cObjectPtr<IMediaSample> pMediaSample;
    AllocMediaSample((tVoid**)&pMediaSample);

    //allocate memory with the size given by the descriptor
    cObjectPtr<IMediaSerializer> pSerializer;
    m_pCoderDescSignalInput->GetMediaSampleSerializer(&pSerializer);
    tInt nSize = pSerializer->GetDeserializedSize();
    pMediaSample->AllocBuffer(nSize);

    //write date to the media sample with the coder of the descriptor
    cObjectPtr<IMediaCoder> pCoder;
    m_pCoderDescSignalInput->WriteLock(pMediaSample, &pCoder);

    pCoder->Set("f32Value", (tVoid*)&(flValue));
    pCoder->Set("ui32ArduinoTimestamp", (tVoid*)&timeStamp);
    m_pCoderDescSignalInput->Unlock(pCoder);

    //transmit media sample over output pin
    pMediaSample->SetTime(_clock->GetStreamTime());
    m_ir_fusion_out.Transmit(pMediaSample);

    // bitte noch drin lassen->brauch ich für die XML-Kalibrierung des Calibration Filter Extended
    //LOG_INFO(cString::Format("%f",flValue));

    RETURN_NOERROR;
}
예제 #5
0
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);
}
예제 #6
0
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;
}
예제 #7
0
void cQrPlayer::OutputSpeed(tFloat32 val)
{
	tUInt32 timeStamp = 0;
							
    //create new media sample
    cObjectPtr<IMediaSample> pMediaSample;
    AllocMediaSample((tVoid**)&pMediaSample);

    //allocate memory with the size given by the descriptor
    cObjectPtr<IMediaSerializer> pSerializer;
    m_pCoderDescSignalOutput->GetMediaSampleSerializer(&pSerializer);
    tInt nSize = pSerializer->GetDeserializedSize();
    pMediaSample->AllocBuffer(nSize);
       
    //write date to the media sample with the coder of the descriptor
    cObjectPtr<IMediaCoder> pCoder;
    m_pCoderDescSignalOutput->WriteLock(pMediaSample, &pCoder);	
		
	pCoder->Set("f32Value", (tVoid*)&val);	
    pCoder->Set("ui32ArduinoTimestamp", (tVoid*)&timeStamp);    
    m_pCoderDescSignalOutput->Unlock(pCoder);
    
    //transmit media sample over output pin
    pMediaSample->SetTime(_clock->GetStreamTime());
    m_oPinAccelerateSignal.Transmit(pMediaSample);
    if (m_bConsoleOutputEnabled) LOG_INFO(adtf_util::cString::Format("QrPlayer: OutputSpeed %f", val));
}
예제 #8
0
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 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 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;
}
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 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;
}
예제 #13
0
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;
}
// -------------------------------------------------------------------------------------------------
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;
}
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 ImageCutter::transmitVideoOutput(Mat &image, cVideoPin &pin)
{
	if (!pin.IsConnected())
	{
		RETURN_NOERROR;
	}
	
	// Create new IMediaSample
	cObjectPtr<IMediaSample> sample;

	if (IS_OK(AllocMediaSample(&sample)))
	{
		tTimeStamp time = _clock ? _clock->GetStreamTime() : cHighResTimer::GetTime();
		RETURN_IF_FAILED(sample->Update(time, image.data, this->videoOutputInfo.nSize, 0));
		RETURN_IF_FAILED(pin.Transmit(sample));
	}

	RETURN_NOERROR;
}
예제 #17
0
// -------------------------------------------------------------------------------------------------
tResult LaneFilter::transmitLanePoints(std::vector<Vector2> const & mapped_points) {
// -------------------------------------------------------------------------------------------------
  cObjectPtr<IMediaSample> lane_points_sample;
  RETURN_IF_FAILED(AllocMediaSample(&lane_points_sample));

  RETURN_IF_FAILED(lane_points_sample->AllocBuffer(sizeof(tUInt32) + sizeof(Vector2) * mapped_points.size()));

  tUInt32* dest_buffer = NULL;
  RETURN_IF_FAILED(lane_points_sample->WriteLock((tVoid**)&dest_buffer));
  
  (*dest_buffer) = (tUInt32)mapped_points.size();
  dest_buffer++;

  cMemoryBlock::MemCopy(dest_buffer, &(mapped_points[0]), sizeof(Vector2) * mapped_points.size());
  
  RETURN_IF_FAILED(lane_points_sample->Unlock((tVoid*)dest_buffer));
  
  lane_output_pin_.Transmit(lane_points_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 DriverFilter::sendDriverState(const DriverState &driverState, const tInt16 &maneuverId)
{
	cObjectPtr<IMediaSample> mediaSample;
	RETURN_IF_FAILED(AllocMediaSample((tVoid**) &mediaSample));
	RETURN_IF_FAILED(mediaSample->AllocBuffer(this->ddlSizeDriver));

	cObjectPtr<IMediaCoder> coder;
	RETURN_IF_FAILED(this->coderDescriptionDriver->WriteLock(mediaSample, &coder));
	
	coder->Set("i8StateID", (tVoid*) &driverState);
	coder->Set("i16ManeuverEntry", (tVoid*) &maneuverId);
	
	RETURN_IF_FAILED(this->coderDescriptionDriver->Unlock(coder));

	static tTimeStamp now;
	now = _clock ? _clock->GetStreamTime() : cHighResTimer::GetTime();

	RETURN_IF_FAILED(mediaSample->SetTime(now));
	RETURN_IF_FAILED(this->driverStatePin.Transmit(mediaSample));

	RETURN_NOERROR;
}
예제 #20
0
tResult pylonDetection::sendPylonInfo(float *distArray, float *angleArray)
{
    cObjectPtr<IMediaSample> pMediaSample;
    RETURN_IF_FAILED(AllocMediaSample((tVoid**)&pMediaSample));

    cObjectPtr<IMediaSerializer> pSerializer;
    m_pCoderDescPylonInfo->GetMediaSampleSerializer(&pSerializer);
    tInt nSize = pSerializer->GetDeserializedSize();

    RETURN_IF_FAILED(pMediaSample->AllocBuffer(nSize));
    tTimeStamp tmStreamTime = _clock ? _clock->GetStreamTime() : adtf_util::cHighResTimer::GetTime();
    cObjectPtr<IMediaCoder> pCoder;
    RETURN_IF_FAILED(m_pCoderDescPylonInfo->WriteLock(pMediaSample, &pCoder));
    pCoder->Set("f32Dist", (tVoid*) distArray);
    pCoder->Set("f32Angle", (tVoid*)angleArray);
    pCoder->Set("ui32ArduinoTimestamp", (tVoid*)&tmStreamTime);
    RETURN_IF_FAILED(m_pCoderDescPylonInfo->Unlock(pCoder));

    RETURN_IF_FAILED(pMediaSample->SetTime(tmStreamTime));
    RETURN_IF_FAILED(m_outputPin_PylonInfo.Transmit(pMediaSample));
    RETURN_NOERROR;
}
tResult DriverFilter::sendManeuver(cOutputPin &pin, const Maneuver &maneuver)
{
	cObjectPtr<IMediaSample> mediaSample;
	RETURN_IF_FAILED(AllocMediaSample((tVoid**) &mediaSample));
	RETURN_IF_FAILED(mediaSample->AllocBuffer(this->ddlSizeManeuver));

	cObjectPtr<IMediaCoder> coder;
	RETURN_IF_FAILED(this->coderDescriptionDriver->WriteLock(mediaSample, &coder));
	
	static tTimeStamp now;
	now = _clock ? _clock->GetStreamTime() : cHighResTimer::GetTime();

	coder->Set("ui16Angle", (tVoid*) &maneuver);
	coder->Set("ui32ArduinoTimestamp", (tVoid*) &now);
	
	RETURN_IF_FAILED(this->coderDescriptionDriver->Unlock(coder)); 

	RETURN_IF_FAILED_AND_LOG_ERROR_STR(mediaSample->SetTime(now), "cant set time to media sample");
	RETURN_IF_FAILED_AND_LOG_ERROR_STR(pin.Transmit(mediaSample), "cant transmit media sample");

	RETURN_NOERROR;
}
tResult DriverFilter::sendManeuver(cOutputPin &pin, const Maneuver &manuever, const tTimeStamp &timeStamp)
{							
    // create new media sample
    cObjectPtr<IMediaSample> mediaSample;
    RETURN_IF_FAILED_AND_LOG_ERROR_STR(AllocMediaSample((tVoid**) &mediaSample), "cant alloc");
	LOG_INFO(cString::Format("ddlSize: %d", this->ddlSizeManeuver));
    RETURN_IF_FAILED_AND_LOG_ERROR_STR(mediaSample->AllocBuffer(this->ddlSizeManeuver), "cant alloc buffer size");
       
    // write date to the media sample with the coder of the descriptor
    cObjectPtr<IMediaCoder> coder;
	RETURN_IF_FAILED_AND_LOG_ERROR_STR(this->coderDescriptionManeuver->WriteLock(mediaSample, &coder), "cant lock");
	
	coder->Set("ui16Angle", (tVoid*) &manuever);
    coder->Set("ui32ArduinoTimestamp", (tVoid*) &timeStamp);

	RETURN_IF_FAILED_AND_LOG_ERROR_STR(this->coderDescriptionManeuver->Unlock(coder), "cant unlock");
    
    // transmit media sample over output pin
    RETURN_IF_FAILED_AND_LOG_ERROR_STR(mediaSample->SetTime(timeStamp), "cant set time");
    RETURN_IF_FAILED_AND_LOG_ERROR_STR(pin.Transmit(mediaSample), "cant transmit");

	RETURN_NOERROR;
}
tResult CurveDetector::transmitVideoOutput(Mat &image, cVideoPin &pin)
{
    if (!pin.IsConnected())
    {
        RETURN_NOERROR;
    }

    if (image.type() != CV_8UC3)
    {
        cvtColor(image, image, CV_GRAY2RGB);
    }

    cObjectPtr<IMediaSample> sample;

    if (IS_OK(AllocMediaSample(&sample)))
    {
        tTimeStamp time = _clock ? _clock->GetStreamTime() : cHighResTimer::GetTime();
        RETURN_IF_FAILED(sample->Update(time, image.data, this->videoInputInfo.nSize, 0));
        RETURN_IF_FAILED(pin.Transmit(sample));
    }

    RETURN_NOERROR;
}
예제 #24
0
tResult Test::transmitF32Value(cOutputPin &pin, cObjectPtr<IMediaTypeDescription> &mediaType, const tFloat32 value)
{
	cObjectPtr<IMediaSample> mediaSample;
    RETURN_IF_FAILED(AllocMediaSample((tVoid**) &mediaSample));
	RETURN_IF_FAILED(mediaSample->AllocBuffer(this->ddlSizeUI16));
       
    // write date to the media sample with the coder of the descriptor
    cObjectPtr<IMediaCoder> coder;
	RETURN_IF_FAILED_AND_LOG_ERROR_STR(mediaType->WriteLock(mediaSample, &coder), "Set F32 Failed to lock f32");	
		
	static tTimeStamp now;
	now = _clock ? _clock->GetStreamTime() : cHighResTimer::GetTime();

	coder->Set("f32Value", (tVoid*) &value);
    coder->Set("ui32ArduinoTimestamp", (tVoid*) &now);
	
	RETURN_IF_FAILED_AND_LOG_ERROR_STR(mediaType->Unlock(coder), "Set F32 Failed to lock f32");
    
    // transmit media sample over output pin
    RETURN_IF_FAILED(mediaSample->SetTime(now));
    RETURN_IF_FAILED(pin.Transmit(mediaSample));
	RETURN_NOERROR;
}
/*
tResult Emergency::transmitValue(cOutputPin &pin, const tFloat32 &value)
{
    tUInt32 timeStamp = (tUInt32) (_clock ? _clock->GetStreamTime()/1000 : adtf_util::cHighResTimer::GetTime()/1000);

    // create new media sample
    cObjectPtr<IMediaSample> mediaSample;
    RETURN_IF_FAILED(AllocMediaSample((tVoid**) &mediaSample));

    // allocate memory with the size given by the descriptor
    cObjectPtr<IMediaSerializer> serializer;
    RETURN_IF_FAILED(this->coderDescriptionSignalInput->GetMediaSampleSerializer(&serializer));
    tInt size = serializer->GetDeserializedSize();
    RETURN_IF_FAILED(mediaSample->AllocBuffer(size));

    // write date to the media sample with the coder of the descriptor
    cObjectPtr<IMediaCoder> coder;
    RETURN_IF_FAILED(this->coderDescriptionSignalInput->WriteLock(mediaSample, &coder));
    RETURN_IF_FAILED(coder->Set("f32Value", (tVoid*) &value));
    RETURN_IF_FAILED(coder->Set("ui32ArduinoTimestamp", (tVoid*) &timeStamp));
    RETURN_IF_FAILED(this->coderDescriptionSignalInput->Unlock(coder));

    // transmit media sample over output pin
    RETURN_IF_FAILED(mediaSample->SetTime(_clock->GetStreamTime()));
    RETURN_IF_FAILED(pin.Transmit(mediaSample));
    RETURN_NOERROR;
}
*/
tResult Emergency::sendDecision(const Emergency_Decision &decision)
{
    tTimeStamp timeStamp = (_clock ? _clock->GetStreamTime() : adtf_util::cHighResTimer::GetTime());

    cObjectPtr<IMediaSample> mediaSample;
    RETURN_IF_FAILED(AllocMediaSample((tVoid**) &mediaSample));

    RETURN_IF_FAILED(mediaSample->AllocBuffer(m_size));

    cObjectPtr<IMediaCoder> coder;
    RETURN_IF_FAILED(this->coderDescriptionSignalOutput->WriteLock(mediaSample, &coder));

    RETURN_IF_FAILED(coder->Set("ui16Angle", (tVoid*) &decision));
    RETURN_IF_FAILED(coder->Set("ui32ArduinoTimestamp", (tVoid*) &timeStamp));

    RETURN_IF_FAILED(this->coderDescriptionSignalOutput->Unlock(coder));

    RETURN_IF_FAILED(mediaSample->SetTime(timeStamp));
    RETURN_IF_FAILED(this->decisionPin.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_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);
}
예제 #27
0
// -------------------------------------------------------------------------------------------------
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;
}
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*)&timestampValue);
    }    
    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*)&timestampValue);
    }    
    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*)&timestampValue);    
    }    
    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*)&timestampValue);
    }    
    pMediaSampleRearRight->SetTime(inputTimeStamp);    
    //transmit media sample over output pin
    m_outputPin_rear_right.Transmit(pMediaSampleRearRight);
    
    
    RETURN_NOERROR;
}