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 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::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 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 ObjectFilter::transmitObjects(std::vector<Object> const & objects, cOutputPin & output_pin) {
// -------------------------------------------------------------------------------------------------
cObjectPtr<IMediaSample> objects_sample;
RETURN_IF_FAILED(AllocMediaSample(&objects_sample));
RETURN_IF_FAILED(objects_sample->AllocBuffer(sizeof(tUInt32) + sizeof(Object) * objects.size()));
tUInt32* dest_buffer = NULL;
RETURN_IF_FAILED(objects_sample->WriteLock((tVoid**)&dest_buffer));
(*dest_buffer) = (tUInt32)objects.size();
dest_buffer++;
cMemoryBlock::MemCopy(dest_buffer, &(objects[0]), sizeof(Object) * objects.size());
RETURN_IF_FAILED(objects_sample->Unlock((tVoid*)dest_buffer));
output_pin.Transmit(objects_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::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 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 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;
}