commradio.cxx

Go to the documentation of this file.

/*
 * SPDX-FileComment: class to manage a comm radio instance
 * SPDX-FileCopyrightText: Copyright (C) 2014 Torsten Dreyer
 * SPDX-License-Identifier: GPL-2.0-or-later
 */
 
#include <config.h>
 
#include "commradio.hxx"
 
#include <assert.h>
 
#include <simgear/sg_inlines.h>
#include <simgear/props/propertyObject.hxx>
#include <simgear/misc/strutils.hxx>
 
#include <ATC/CommStation.hxx>
#include <ATC/MetarPropertiesATISInformationProvider.hxx>
#include <ATC/CurrentWeatherATISInformationProvider.hxx>
#include <Airports/airport.hxx>
#include <Main/fg_props.hxx>
#include <Navaids/navlist.hxx>
 
#include <Sound/soundmanager.hxx>
#include <simgear/sound/sample_group.hxx>
#include <Sound/VoiceSynthesizer.hxx>
 
#include "frequencyformatter.hxx"
 
namespace Instrumentation {
 
using simgear::PropertyObject;
using std::string;
 
class AtisSpeaker: public SGPropertyChangeListener, SoundSampleReadyListener {
public:
  AtisSpeaker();
  virtual ~AtisSpeaker();
  virtual void valueChanged(SGPropertyNode * node);
  virtual void SoundSampleReady(SGSharedPtr<SGSoundSample>);
 
  bool hasSpokenAtis()
  {
    return _spokenAtis.empty() == false;
  }
 
  SGSharedPtr<SGSoundSample> getSpokenAtis()
  {
    return _spokenAtis.pop();
  }
 
  void setStationId(const string & stationId)
  {
    _stationId = stationId;
  }
 
 
private:
  SynthesizeRequest _synthesizeRequest;
  SGLockedQueue<SGSharedPtr<SGSoundSample> > _spokenAtis;
  string _stationId;
};
 
AtisSpeaker::AtisSpeaker()
{
  _synthesizeRequest.listener = this;
  if (!fgHasNode("/sim/atis/speed"))    fgSetDouble("/sim/atis/speed", 1);
  if (!fgHasNode("/sim/atis/pitch"))    fgSetDouble("/sim/atis/pitch", 1);
  if (!fgHasNode("/sim/atis/enabled"))  fgSetBool("/sim/atis/enabled", true);
}
 
AtisSpeaker::~AtisSpeaker()
{
 
}
void AtisSpeaker::valueChanged(SGPropertyNode * node)
{
  using namespace simgear::strutils;
 
  if (!fgGetBool("/sim/sound/working", false))
    return;
 
  string newText = node->getStringValue();
  if (_synthesizeRequest.text == newText) return;
 
  _synthesizeRequest.text = newText;
 
  string voice = "cmu_us_arctic_slt";
 
  if (!_stationId.empty()) {
    // lets play a bit with the voice so not every airports atis sounds alike
    // but every atis of an airport has the same voice
 
    // create a simple hash from the last two letters of the airport's id
    unsigned char hash = 0;
    string::iterator i = _stationId.end() - 1;
    hash += *i;
 
    if( i != _stationId.begin() ) {
      --i;
      hash += *i;
    }
 
    _synthesizeRequest.speed = (hash % 16) / 16.0 * fgGetDouble("/sim/atis/speed", 1);
    _synthesizeRequest.pitch = (hash % 16) / 16.0 * fgGetDouble("/sim/atis/pitch", 1);
    
    if( starts_with( _stationId, "K" ) || starts_with( _stationId, "C" ) ||
            starts_with( _stationId, "P" ) ) {
        voice = FLITEVoiceSynthesizer::getVoicePath("cmu_us_arctic_slt");
    } else if ( starts_with( _stationId, "EG" ) ) {
        voice = FLITEVoiceSynthesizer::getVoicePath("cstr_uk_female");
    } else {
        // Pick a random voice from the available voices
        voice = FLITEVoiceSynthesizer::getVoicePath(
            static_cast<FLITEVoiceSynthesizer::voice_t>(hash % FLITEVoiceSynthesizer::VOICE_UNKNOWN) );
    }
  }
 
  auto smgr = globals->get_subsystem<FGSoundManager>();
  if (!smgr) {
      return;
  }
 
  SG_LOG(SG_INSTR, SG_DEBUG,"node->getPath()=" << node->getPath() << " AtisSpeaker voice is " << voice );
  FLITEVoiceSynthesizer * synthesizer = dynamic_cast<FLITEVoiceSynthesizer*>(smgr->getSynthesizer(voice));
 
  synthesizer->synthesize(_synthesizeRequest);
}
 
void AtisSpeaker::SoundSampleReady(SGSharedPtr<SGSoundSample> sample)
{
  // we are now in the synthesizers worker thread!
  _spokenAtis.push(sample);
}
 
SignalQualityComputer::~SignalQualityComputer()
{
}
 
class SimpleDistanceSquareSignalQualityComputer: public SignalQualityComputer {
public:
  SimpleDistanceSquareSignalQualityComputer()
      : _altitudeAgl_ft(fgGetNode("/position/altitude-agl-ft", true))
  {
  }
 
  ~SimpleDistanceSquareSignalQualityComputer()
  {
  }
 
  double computeSignalQuality(double distance_nm) const
  {
    // Very simple line of sight propagation model. It's cheap but it does the trick for now.
    // assume transmitter and receiver antennas are at some elevation above ground
    // so we have at least a range of 5NM. Add the approx. distance to the horizon.
    double range_nm = 5.0 + 1.23 * ::sqrt(SGMiscd::max(.0, _altitudeAgl_ft));
    return distance_nm < range_nm ? 1.0 : (range_nm * range_nm / distance_nm / distance_nm);
  }
 
private:
  PropertyObject<double> _altitudeAgl_ft;
};
 
class OnExitHandler {
public:
  virtual void onExit() = 0;
  virtual ~OnExitHandler()
  {
  }
};
 
class OnExit {
public:
  OnExit(OnExitHandler * onExitHandler)
      : _onExitHandler(onExitHandler)
  {
  }
  ~OnExit()
  {
    _onExitHandler->onExit();
  }
private:
  OnExitHandler * _onExitHandler;
};
 
class OutputProperties: public OnExitHandler {
public:
 
  void bind(SGPropertyNode* rn)
  {
      _rootNode = rn;
 
      _PO_stationType = PropertyObject<string>(_rootNode->getNode("station-type", true));
      _PO_stationName = PropertyObject<string>(_rootNode->getNode("station-name", true));
      _PO_airportId = PropertyObject<string>(_rootNode->getNode("airport-id", true));
      _PO_signalQuality_norm = PropertyObject<double>(_rootNode->getNode("signal-quality-norm", true));
      _PO_slantDistance_m = PropertyObject<double>(_rootNode->getNode("slant-distance-m", true));
      _PO_trueBearingTo_deg = PropertyObject<double>(_rootNode->getNode("true-bearing-to-deg", true));
      _PO_trueBearingFrom_deg = PropertyObject<double>(_rootNode->getNode("true-bearing-from-deg", true));
      _PO_trackDistance_m = PropertyObject<double>(_rootNode->getNode("track-distance-m", true));
      _PO_heightAboveStation_ft = PropertyObject<double>(_rootNode->getNode("height-above-station-ft", true));
  }
 
  virtual ~OutputProperties()
  {
  }
 
protected:
  SGPropertyNode_ptr _rootNode;
 
  std::string _stationType;
  std::string _stationName;
  std::string _airportId;
  double _signalQuality_norm = 0.0;
  double _slantDistance_m = 0.0;
  double _trueBearingTo_deg = 0.0;
  double _trueBearingFrom_deg = 0.0;
  double _trackDistance_m = 0.0;
  double _heightAboveStation_ft = 0.0;
 
private:
  PropertyObject<string> _PO_stationType;
  PropertyObject<string> _PO_stationName;
  PropertyObject<string> _PO_airportId;
  PropertyObject<double> _PO_signalQuality_norm;
  PropertyObject<double> _PO_slantDistance_m;
  PropertyObject<double> _PO_trueBearingTo_deg;
  PropertyObject<double> _PO_trueBearingFrom_deg;
  PropertyObject<double> _PO_trackDistance_m;
  PropertyObject<double> _PO_heightAboveStation_ft;
 
  virtual void onExit()
  {
    _PO_stationType = _stationType;
    _PO_stationName = _stationName;
    _PO_airportId = _airportId;
    _PO_signalQuality_norm = _signalQuality_norm;
    _PO_slantDistance_m = _slantDistance_m;
    _PO_trueBearingTo_deg = _trueBearingTo_deg;
    _PO_trueBearingFrom_deg = _trueBearingFrom_deg;
    _PO_trackDistance_m = _trackDistance_m;
    _PO_heightAboveStation_ft = _heightAboveStation_ft;
  }
};
 
/* ------------- The CommRadio implementation ---------------------- */
 
class MetarBridge: public SGReferenced, public SGPropertyChangeListener {
public:
 
  void bind();
  void unbind();
  void requestMetarForId(std::string & id);
  void clearMetar();
  void setMetarPropertiesRoot(SGPropertyNode_ptr n)
  {
    _metarPropertiesNode = n;
  }
  void setAtisNode(SGPropertyNode * n)
  {
    _atisNode = n;
  }
 
protected:
  virtual void valueChanged(SGPropertyNode *);
 
private:
  std::string _requestedId;
  SGPropertyNode_ptr _realWxEnabledNode;
  SGPropertyNode_ptr _metarPropertiesNode;
    SGPropertyNode * _atisNode = nullptr;
  ATISEncoder _atisEncoder;
};
 
typedef SGSharedPtr<MetarBridge> MetarBridgeRef;
 
void MetarBridge::bind()
{
  _realWxEnabledNode = fgGetNode("/environment/realwx/enabled", true);
  _metarPropertiesNode->getNode("valid", true)->addChangeListener(this);
}
 
void MetarBridge::unbind()
{
  _metarPropertiesNode->getNode("valid", true)->removeChangeListener(this);
}
 
void MetarBridge::requestMetarForId(std::string & id)
{
  std::string uppercaseId = simgear::strutils::uppercase(id);
  if (_requestedId == uppercaseId) return;
  _requestedId = uppercaseId;
 
  if (_realWxEnabledNode->getBoolValue()) {
    //  trigger a METAR request for the associated metarproperties
    _metarPropertiesNode->getNode("station-id", true)->setStringValue(uppercaseId);
    _metarPropertiesNode->getNode("valid", true)->setBoolValue(false);
    _metarPropertiesNode->getNode("time-to-live", true)->setDoubleValue(0.0);
  } else {
    // use the present weather to generate the ATIS.
    if ( NULL != _atisNode && !_requestedId.empty()) {
      CurrentWeatherATISInformationProvider provider(_requestedId);
      _atisNode->setStringValue(_atisEncoder.encodeATIS(&provider));
    }
  }
}
 
void MetarBridge::clearMetar()
{
  string empty;
  requestMetarForId(empty);
}
 
void MetarBridge::valueChanged(SGPropertyNode * node)
{
  // check for raising edge of valid flag
  if ( NULL == node || !node->getBoolValue() || !_realWxEnabledNode->getBoolValue()) return;
 
  std::string responseId = simgear::strutils::uppercase(_metarPropertiesNode->getNode("station-id", true)->getStringValue());
 
  // unrequested metar!?
  if (responseId != _requestedId) return;
 
  if ( NULL != _atisNode) {
    MetarPropertiesATISInformationProvider provider(_metarPropertiesNode);
    _atisNode->setStringValue(_atisEncoder.encodeATIS(&provider));
  }
}
 
/* ------------- 8.3kHz Channel implementation ---------------------- */
 
class EightPointThreeFrequencyFormatter :
                public FrequencyFormatterBase,
                public SGPropertyChangeListener {
public:
        EightPointThreeFrequencyFormatter( SGPropertyNode_ptr root,
                        const char * channel,
                        const char * fmt,
                        const char * width,
                        const char * frq,
                        const char * cnum ) :
                _channel( root, channel ),
                _frequency( root, frq ),
                _channelSpacing( root, width ),
                _formattedChannel( root, fmt ),
                _channelNum( root, cnum )
        {
                // ensure properties exist.
                _channel.node(true);
                _frequency.node(true);
                _channelSpacing.node(true);
                _channelNum.node(true);
                _formattedChannel.node(true);
 
                _channel.node()->addChangeListener( this, true );
                _channelNum.node()->addChangeListener( this, true );
        }
 
        virtual ~EightPointThreeFrequencyFormatter()
        {
                  _channel.node()->removeChangeListener( this );
                  _channelNum.node()->removeChangeListener( this );
        }
 
private:
        EightPointThreeFrequencyFormatter( const EightPointThreeFrequencyFormatter & );
        EightPointThreeFrequencyFormatter & operator = ( const EightPointThreeFrequencyFormatter & );
 
        void valueChanged (SGPropertyNode * prop) {
                if( prop == _channel.node() )
                        setFrequency(prop->getDoubleValue());
                else if( prop == _channelNum.node() )
                        setChannel(prop->getIntValue());
        }
 
        void setChannel( int channel ) {
                channel %= 3040;
                if( channel < 0 ) channel += 3040;
                double f = 118.000 + 0.025*(channel/4) + 0.005*(channel%4);
                if( f != _channel )     _channel = f;
        }
 
        void setFrequency( double channel ) {
                // format as fixed decimal "nnn.nnn"
                std::ostringstream buf;
                buf << std::fixed
                    << std::setw(6)
                    << std::setfill('0')
                    << std::setprecision(3)
                    << _channel;
                _formattedChannel = buf.str();
 
                // sanitize range and round to nearest kHz.
                unsigned c = static_cast<int>(SGMiscd::round(SGMiscd::clip( channel, 118.0, 136.99 ) * 1000));
 
                if ( (c % 25)  == 0 ) {
                        // legacy 25kHz channels continue to be just that.
                        _channelSpacing = 25.0;
                        _frequency = c / 1000.0;
 
                        int channelNum = (c-118000)/25*4;
                        if( channelNum != _channelNum ) _channelNum = channelNum;
 
                        if( _frequency != channel ) {
                const double channelValue = c / 1000.0;
                _channel = channelValue;
            }
                } else {
                        _channelSpacing = 8.33;
 
                        // 25kHz base frequency: xxx.000, xxx.025, xxx.050, xxx.075
                        unsigned base25 = (c/25) * 25;
 
                        // add n*8.33 to the 25kHz frequency
                        unsigned subChannel = SGMisc<unsigned>::clip((c - base25)/5-1, 0, 2 );
 
                        _frequency = (base25 + 8.33 * subChannel)/1000.0;
 
                        int channelNum = (base25-118000)/25*4 + subChannel+1;
                        if( channelNum != _channelNum ) _channelNum = channelNum;
 
                        // set to correct channel on bogous input
                        double sanitizedChannel = (base25 + 5*(subChannel+1))/1000.0;
                        if( sanitizedChannel != channel ) {
                                _channel = sanitizedChannel; // triggers recursion
                        }
                }
        }
 
        double getFrequency() const {
                return _channel;
        }
 
 
    PropertyObject<double> _channel;
    PropertyObject<double> _frequency;
    PropertyObject<double> _channelSpacing;
    PropertyObject<string> _formattedChannel;
    PropertyObject<int>   _channelNum;
 
};
 
 
/* ------------- The CommRadio implementation ---------------------- */
 
class CommRadioImpl: public CommRadio,
                     OutputProperties
{
public:
    CommRadioImpl(SGPropertyNode_ptr node);
    virtual ~CommRadioImpl();
 
    // Subsystem API.
    void bind() override;
    void init() override;
    void unbind() override;
    void update(double dt) override;
 
private:
    bool _useEightPointThree = false;
    MetarBridgeRef _metarBridge;
    AtisSpeaker _atisSpeaker;
    SGSharedPtr<FrequencyFormatterBase> _useFrequencyFormatter;
    SGSharedPtr<FrequencyFormatterBase> _stbyFrequencyFormatter;
    const SignalQualityComputerRef _signalQualityComputer;
 
    double _stationTTL = 0.0;
    double _frequency = -1.0;
    flightgear::CommStationRef _commStationForFrequency;
 
    PropertyObject<double> _volume_norm;
    PropertyObject<bool> _pushToTalk;
    bool _fullDuplexConfig = false;
    PropertyObject<bool> _fullDuplex;
    PropertyObject<bool> _receivingFlag;
    PropertyObject<string> _atis;
    PropertyObject<bool> _addNoise;
    PropertyObject<double> _cutoffSignalQuality;
 
    SGPropertyNode_ptr          _atis_enabled_node;
    bool                        _atis_enabled_prev;
    SGSharedPtr<SGSoundSample>  _atis_sample;
 
    std::string _soundPrefix;
    void stopAudio();
    void updateAudio();
 
    SGSampleGroup* _sampleGroup = nullptr;
};
 
CommRadioImpl::CommRadioImpl(SGPropertyNode_ptr node) :
  _metarBridge(new MetarBridge),
  _signalQualityComputer(new SimpleDistanceSquareSignalQualityComputer),
  _atis_enabled_prev(false)
{
  // set a special value to indicate we don't require a power supply node
  // by default
  setDefaultPowerSupplyPath("NO_DEFAULT");
  readConfig(node, "comm");
  _soundPrefix = name() + "_" + std::to_string(number()) + "_";
  _useEightPointThree = node->getBoolValue("eight-point-three", false );
  _fullDuplexConfig = node->getBoolValue("full-duplex", _fullDuplexConfig);
}
 
CommRadioImpl::~CommRadioImpl()
{
}
 
void CommRadioImpl::bind()
{
  SGPropertyNode_ptr n = fgGetNode(nodePath(), true);
  OutputProperties::bind(n);
 
  _pushToTalk = PropertyObject<bool>(_rootNode->getNode("ptt", true));
  _fullDuplex = PropertyObject<bool>::create(_rootNode->getNode("full-duplex", true), _fullDuplexConfig);
  _receivingFlag = PropertyObject<bool>::create(_rootNode->getNode("receiving-flag", true), false);
  _volume_norm = PropertyObject<double>(_rootNode->getNode("volume", true));
  _atis = PropertyObject<string>(_rootNode->getNode("atis", true));
  if (!fgHasNode("/sim/atis/enabled")) fgSetBool("/sim/atis/enabled", true);
  _atis_enabled_node = fgGetNode("/sim/atis/enabled");
  _addNoise = PropertyObject<bool>(_rootNode->getNode("add-noise", true));
  _cutoffSignalQuality = PropertyObject<double>(_rootNode->getNode("cutoff-signal-quality", true));
 
  _metarBridge->setAtisNode(_atis.node());
  _atis.node()->addChangeListener(&_atisSpeaker);
 
  // link the metar node. /environment/metar[3] is comm1 and /environment[4] is comm2.
  // see FGDATA/Environment/environment.xml
  _metarBridge->setMetarPropertiesRoot(fgGetNode("/environment", true)->getNode("metar", number() + 3, true));
  _metarBridge->bind();
 
  if (_useEightPointThree) {
    _useFrequencyFormatter = new EightPointThreeFrequencyFormatter(
                                                                   _rootNode->getNode("frequencies", true),
                                                                   "selected-mhz",
                                                                   "selected-mhz-fmt",
                                                                   "selected-channel-width-khz",
                                                                   "selected-real-frequency-mhz",
                                                                   "selected-channel"
                                                                   );
    _stbyFrequencyFormatter = new EightPointThreeFrequencyFormatter(
                                                                    _rootNode->getNode("frequencies", true),
                                                                    "standby-mhz",
                                                                    "standby-mhz-fmt",
                                                                    "standby-channel-width-khz",
                                                                    "standby-real-frequency-mhz",
                                                                    "standby-channel"
                                                                    );
  } else {
    _useFrequencyFormatter = new FrequencyFormatter(
                                                    _rootNode->getNode("frequencies/selected-mhz", true),
                                                    _rootNode->getNode("frequencies/selected-mhz-fmt", true),
                                                    0.025, 118.0, 137.0);
 
    _stbyFrequencyFormatter = new FrequencyFormatter(
                                                     _rootNode->getNode("frequencies/standby-mhz", true),
                                                     _rootNode->getNode("frequencies/standby-mhz-fmt", true),
                                                     0.025, 118.0, 137.0);
 
 
  }
}
 
void CommRadioImpl::unbind()
{
  _atis.node()->removeChangeListener(&_atisSpeaker);
  
  stopAudio();
  
  _metarBridge->unbind();
  AbstractInstrument::unbind();
}
 
void CommRadioImpl::init()
{
  initServicePowerProperties(_rootNode);
 
  string s;
  // initialize squelch to a sane value if unset
  s = _cutoffSignalQuality.node()->getStringValue();
  if (s.empty()) _cutoffSignalQuality = 0.4;
 
  // initialize add-noize to true if unset
  s = _addNoise.node()->getStringValue();
  if (s.empty()) _addNoise = true;
  
  auto soundManager = globals->get_subsystem<SGSoundMgr>();
  if (soundManager) {
    _sampleGroup = soundManager->find("atc", true);
  }
}
 
void CommRadioImpl::update(double dt)
{
  if (dt < SGLimitsd::min()) return;
  _stationTTL -= dt;
 
  // Ensure all output properties get written on exit of this method
  OnExit onExit(this);
 
  SGGeod position;
  try {
    position = globals->get_aircraft_position();
  }
  catch (std::exception &) {
    return;
  }
 
  if (!isServiceableAndPowered()) {
    _metarBridge->clearMetar();
    _atis = "";
    _stationTTL = 0.0;
    stopAudio();
    _receivingFlag = false;
    return;
  }
 
  if (_frequency != _useFrequencyFormatter->getFrequency()) {
    _frequency = _useFrequencyFormatter->getFrequency();
    _stationTTL = 0.0;
  }
 
  if (_stationTTL <= 0.0) {
    _stationTTL = 30.0;
 
    int freqKhz = static_cast<int>(_frequency * 1000 + 0.5);
    // make sure the frequency is integral multiple of 25, if not using 8.333 kHz spacing
    if (!_useEightPointThree && freqKhz % 25) {
        freqKhz += 5;
    }
 
    _commStationForFrequency = flightgear::CommStation::findByFreq(freqKhz, position, NULL);
  }
 
  if (!_commStationForFrequency.valid()) {
    stopAudio();
    _receivingFlag = false;
    return;
  }
  
  _slantDistance_m = dist(_commStationForFrequency->cart(), SGVec3d::fromGeod(position));
 
  SGGeodesy::inverse(position, _commStationForFrequency->geod(), _trueBearingTo_deg, _trueBearingFrom_deg, _trackDistance_m);
 
  _heightAboveStation_ft = SGMiscd::max(0.0, position.getElevationFt() - _commStationForFrequency->airport()->elevation());
 
  _signalQuality_norm = _signalQualityComputer->computeSignalQuality(_slantDistance_m * SG_METER_TO_NM);
  _stationType = _commStationForFrequency->nameForType(_commStationForFrequency->type());
  _stationName = _commStationForFrequency->ident();
  _airportId = _commStationForFrequency->airport()->getId();
 
  _atisSpeaker.setStationId(_airportId);
 
  switch (_commStationForFrequency->type()) {
    case FGPositioned::FREQ_ATIS:
      case FGPositioned::FREQ_AWOS: {
      if (_signalQuality_norm > 0.01) {
        _metarBridge->requestMetarForId(_airportId);
        _receivingFlag = _fullDuplex || !_pushToTalk;
      } else {
        _metarBridge->clearMetar();
        _atis = "";
        _receivingFlag = false;
      }
    }
      break;
 
    default:
      _metarBridge->clearMetar();
      _atis = "";
      _receivingFlag = false;
      break;
  }
  
  updateAudio();
}
 
void CommRadioImpl::updateAudio()
{
  if (!_sampleGroup)
    return;
  
  const string noiseRef = _soundPrefix + "_noise";
  const string atisRef = _soundPrefix + "_atis";
 
  SGSoundSample* noiseSample = _sampleGroup->find(noiseRef);
  
  // create noise sample if necessary, and play forever
  if (_addNoise && !noiseSample) {
    SGSharedPtr<SGSoundSample> noise = new SGSoundSample("Sounds/radionoise.wav", globals->get_fg_root());
    _sampleGroup->add(noise, noiseRef);
    _sampleGroup->play_looped(noiseRef);
    noiseSample = noise;
  }
  
  bool atis_enabled = _atis_enabled_node->getBoolValue();
  int atis_delta = 0;
  if (atis_enabled && !_atis_enabled_prev) atis_delta = 1;
  if (!atis_enabled && _atis_enabled_prev) atis_delta = -1;
  
  if (_atisSpeaker.hasSpokenAtis()) {
    // the speaker has created a new atis sample
    // remove previous atis sample
    _sampleGroup->remove(atisRef);
    if (!atis_delta && atis_enabled) atis_delta = 1;
  }
  if (atis_delta == 1) {
    // Start play of atis text. We store the most recent sample in _atis_sample
    // so that we can resume if /sim/atis/enabled is changed from false to
    // true.
    SGSharedPtr<SGSoundSample> sample = _atisSpeaker.getSpokenAtis();
    if (sample) _atis_sample = sample;
    else sample = _atis_sample;
    if (sample) {
      SG_LOG(SG_INSTR, SG_DEBUG, "starting looped play of atis sample.");
      _sampleGroup->add(sample, atisRef);
      _sampleGroup->play_looped(atisRef);
    }
    else {
      SG_LOG(SG_INSTR, SG_DEBUG, "no atis sample available");
    }
  }
  if (atis_delta == -1) {
    // Stop play of atis text.
    _sampleGroup->remove(atisRef);
  }
  _atis_enabled_prev = atis_enabled;
  
  // adjust volumes
  const auto targetVolume = (_pushToTalk && !_fullDuplex) ? 0.0 : _volume_norm;
  const bool doSquelch = (_signalQuality_norm < _cutoffSignalQuality);
  double atisVolume = doSquelch ? 0.0 : targetVolume;
  if (_addNoise) {
    double noiseVol = (1.0 - _signalQuality_norm) * targetVolume;
    if (_cutoffSignalQuality < 0.01) {
      // ensure noise is still heard disabling squelch
      // see https://sourceforge.net/p/flightgear/codetickets/2846/
      noiseVol = targetVolume;
    }
 
    atisVolume = _signalQuality_norm * targetVolume;
    noiseSample->set_volume(doSquelch ? 0.0: noiseVol);
  }
  
  SGSoundSample* s = _sampleGroup->find(atisRef);
  if (s) {
    s->set_volume(atisVolume);
  }
}
  
void CommRadioImpl::stopAudio()
{
  if (_sampleGroup) {
    _sampleGroup->remove(_soundPrefix + "_noise");
    _sampleGroup->remove(_soundPrefix + "_atis");
  }
}
 
SGSubsystem * CommRadio::createInstance(SGPropertyNode_ptr rootNode)
{
  return new CommRadioImpl(rootNode);
}
 
 
// Register the subsystem.
#if 0
SGSubsystemMgr::InstancedRegistrant<CommRadio> registrantCommRadio(
    SGSubsystemMgr::FDM,
    {{"instrumentation", SGSubsystemMgr::Dependency::HARD}});
#endif
 
} // namespace Instrumentation