include/gz/sim/components/LogicalAudio.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2020 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
#ifndef GZ_SIM_COMPONENTS_LOGICALAUDIO_HH_
#define GZ_SIM_COMPONENTS_LOGICALAUDIO_HH_
 
#include <chrono>
#include <cstdint>
#include <istream>
#include <ostream>
#include <ratio>
 
#include <gz/sim/components/Factory.hh>
#include <gz/sim/components/Component.hh>
#include <gz/sim/config.hh>
 
namespace gz
{
namespace sim
{
// Inline bracket to help doxygen filtering.
inline namespace GZ_SIM_VERSION_NAMESPACE {
namespace logical_audio
{
  enum class AttenuationFunction { LINEAR, UNDEFINED };
 
  enum class AttenuationShape { SPHERE, UNDEFINED };
 
  struct Source
  {
    unsigned int id;
 
    logical_audio::AttenuationFunction attFunc;
 
    logical_audio::AttenuationShape attShape;
 
    double innerRadius;
 
    double falloffDistance;
 
    double emissionVolume;
 
    public: bool operator==(const Source &_source) const
    {
      return this->id == _source.id;
    }
 
    public: bool operator!=(const Source &_source) const
    {
      return !(*this == _source);
    }
  };
 
  struct SourcePlayInfo
  {
    SourcePlayInfo() : startTime()
    {
    }
 
    bool playing{false};
 
    std::chrono::seconds playDuration;
 
    std::chrono::steady_clock::duration startTime;
 
    public: bool operator==(const SourcePlayInfo &_sourcePlayInfo) const
    {
      return (this->playing == _sourcePlayInfo.playing) &&
             (this->playDuration == _sourcePlayInfo.playDuration) &&
             (this->startTime == _sourcePlayInfo.startTime);
    }
 
    public: bool operator!=(const SourcePlayInfo &_sourcePlayInfo) const
    {
      return !(*this == _sourcePlayInfo);
    }
  };
 
  struct Microphone
  {
    unsigned int id;
 
    double volumeDetectionThreshold;
 
    public: bool operator==(const Microphone &_microphone) const
    {
      return this->id == _microphone.id;
    }
 
    public: bool operator!=(const Microphone &_microphone) const
    {
      return !(*this == _microphone);
    }
  };
}
 
namespace serializers
{
  inline std::ostream &operator<<(std::ostream &_out,
              const logical_audio::AttenuationFunction &_func)
  {
    auto temp = static_cast<unsigned int>(_func);
    _out << temp;
    return _out;
  }
 
  inline std::istream &operator>>(std::istream &_in,
              logical_audio::AttenuationFunction &_func)
  {
    unsigned int temp = 0u;
    if (_in >> temp)
      _func = static_cast<logical_audio::AttenuationFunction>(temp);
    return _in;
  }
 
  inline std::ostream &operator<<(std::ostream &_out,
              const logical_audio::AttenuationShape &_shape)
  {
    auto temp = static_cast<unsigned int>(_shape);
    _out << temp;
    return _out;
  }
 
  inline std::istream &operator>>(std::istream &_in,
              logical_audio::AttenuationShape &_shape)
  {
    unsigned int temp = 0u;
    if (_in >> temp)
       _shape = static_cast<logical_audio::AttenuationShape>(temp);
    return _in;
  }
 
  inline std::ostream &operator<<(std::ostream &_out,
      const std::chrono::steady_clock::duration &_dur)
  {
    _out << std::chrono::duration_cast<std::chrono::nanoseconds>(
        _dur).count();
    return _out;
  }
 
  inline std::istream &operator>>(std::istream &_in,
      std::chrono::steady_clock::duration &_dur)
  {
    int64_t time;
    _in >> time;
    _dur = std::chrono::duration<int64_t, std::nano>(time);
    return _in;
  }
 
  class LogicalAudioSourceSerializer
  {
    public: static std::ostream &Serialize(std::ostream &_out,
                const logical_audio::Source &_source)
    {
      _out << _source.id << " " << _source.attFunc << " " << _source.attShape
        << " " << _source.innerRadius << " " << _source.falloffDistance
        << " " << _source.emissionVolume;
      return _out;
    }
 
    public: static std::istream &Deserialize(std::istream &_in,
                logical_audio::Source &_source)
    {
      _in >> _source.id >> _source.attFunc >> _source.attShape
        >> _source.innerRadius >> _source.falloffDistance
        >> _source.emissionVolume;
      return _in;
    }
  };
 
  class LogicalAudioSourcePlayInfoSerializer
  {
    public: static std::ostream &Serialize(std::ostream &_out,
                const logical_audio::SourcePlayInfo &_playInfo)
    {
      _out << _playInfo.playing << " " << _playInfo.playDuration.count() << " "
        << _playInfo.startTime;
      return _out;
    }
 
    public: static std::istream &Deserialize(std::istream &_in,
                logical_audio::SourcePlayInfo &_playInfo)
    {
      uint64_t count;
      _in >> _playInfo.playing >> count >> _playInfo.startTime;
      _playInfo.playDuration = std::chrono::seconds(count);
      return _in;
    }
  };
 
  class LogicalMicrophoneSerializer
  {
    public: static std::ostream &Serialize(std::ostream &_out,
                const logical_audio::Microphone &_mic)
    {
      _out << _mic.id << " " << _mic.volumeDetectionThreshold;
      return _out;
    }
 
    public: static std::istream &Deserialize(std::istream &_in,
                logical_audio::Microphone &_mic)
    {
      _in >> _mic.id >> _mic.volumeDetectionThreshold;
      return _in;
    }
  };
}
 
// using separate namespace blocks so all components appear in Doxygen
// (appears as if Doxygen can't parse multiple components in a single
// namespace block since GZ_SIM_REGISTER_COMPONENT doesn't have a
// trailing semicolon)
namespace components
{
  using LogicalAudioSource = Component<logical_audio::Source,
        class LogicalAudioSourceTag,
        serializers::LogicalAudioSourceSerializer>;
  GZ_SIM_REGISTER_COMPONENT("gz_sim_components.LogicalAudioSource",
      LogicalAudioSource)
}
 
namespace components
{
  using LogicalAudioSourcePlayInfo = Component<logical_audio::SourcePlayInfo,
        class LogicalAudioSourcePlayInfoTag,
        serializers::LogicalAudioSourcePlayInfoSerializer>;
  GZ_SIM_REGISTER_COMPONENT(
      "gz_sim_components.LogicalAudioSourcePlayInfo",
      LogicalAudioSourcePlayInfo)
}
 
namespace components
{
  using LogicalMicrophone = Component<logical_audio::Microphone,
        class LogicalMicrophoneTag,
        serializers::LogicalMicrophoneSerializer>;
  GZ_SIM_REGISTER_COMPONENT("gz_sim_components.LogicalMicrophone",
      LogicalMicrophone)
}
}
}
}
 
#endif