src/Network/fgcom.cxx

   1 // fgcom.cxx -- FGCom: Voice communication
   2 //
   3 // Written by Clement de l'Hamaide, started May 2013.
   4 //
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License as
   7 // published by the Free Software Foundation; either version 2 of the
   8 // License, or (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful, but
  11 // WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 // General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software
  17 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18
  19 #ifdef HAVE_CONFIG_H
  20 #  include <config.h>
  21 #endif
  22
  23 #include "fgcom.hxx"
  24
  25 // standard library includes
  26 #include <cstdio>
  27
  28 // simgear includes
  29 #include <simgear/compiler.h>
  30 #include <simgear/sg_inlines.h>
  31 #include <simgear/debug/logstream.hxx>
  32 #include <simgear/math/sg_geodesy.hxx>
  33 #include <simgear/timing/timestamp.hxx>
  34
  35 // flightgear includes
  36 #include <Main/fg_props.hxx>
  37 #include <Main/globals.hxx>
  38 #include <ATC/CommStation.hxx>
  39 #include <Airports/airport.hxx>
  40 #include <Navaids/navlist.hxx>
  41
  42 #include <3rdparty/iaxclient/lib/iaxclient.h>
  43
  44
  45 #define NUM_CALLS 4
  46 #define MAX_GND_RANGE 10.0
  47 #define MAX_TWR_RANGE 50.0
  48 #define MAX_RANGE 100.0
  49 #define MIN_RANGE  20.0
  50 #define MIN_GNDTWR_RANGE 0.0
  51 #define DEFAULT_SERVER "fgcom.flightgear.org"
  52 #define IAX_DELAY 300  // delay between calls in milliseconds
  53 #define TEST_FREQ 910.00
  54 #define NULL_ICAO "ZZZZ"
  55
  56 const int special_freq[] = { // Define some freq who need to be used with NULL_ICAO
  57         910000,
  58         911000,
  59         700000,
  60         123450,
  61         122750,
  62         121500,
  63         123500,
  64         121000,
  65         723340 };
  66
  67 static FGCom* static_instance = NULL;
  68
  69
  70
  71 static int iaxc_callback( iaxc_event e )
  72 {
  73   switch( e.type )
  74   {
  75     case IAXC_EVENT_TEXT:
  76       static_instance->iaxTextEvent(e.ev.text);
  77       break;
  78     default:
  79       return 0;
  80   }
  81   return 1;
  82 }
  83
  84
  85
  86 void FGCom::iaxTextEvent(struct iaxc_ev_text text)
  87 {
  88   if( (text.type == IAXC_TEXT_TYPE_STATUS ||
  89        text.type == IAXC_TEXT_TYPE_IAX) &&
  90        _showMessages_node->getBoolValue() )
  91   {
  92     _text_node->setStringValue(text.message);
  93   }
  94 }
  95
  96
  97
  98 FGCom::FGCom() :
  99     _register(true),
 100     _enabled(false),
 101     _initialized(false),
 102     _listener_active(0)
 103 {
 104 }
 105
 106
 107
 108 FGCom::~FGCom()
 109 {
 110 }
 111
 112
 113
 114 void FGCom::bind()
 115 {
 116   SGPropertyNode *node     = fgGetNode("/sim/fgcom", 0, true);
 117   _test_node               = node->getChild( "test", 0, true );
 118   _server_node             = node->getChild( "server", 0, true );
 119   _enabled_node            = node->getChild( "enabled", 0, true );
 120   _micBoost_node           = node->getChild( "mic-boost", 0, true );
 121   _micLevel_node           = node->getChild( "mic-level", 0, true );
 122   _speakerLevel_node       = node->getChild( "speaker-level", 0, true );
 123   _selectedInput_node      = node->getChild( "device-input", 0, true );
 124   _selectedOutput_node     = node->getChild( "device-output", 0, true );
 125   _showMessages_node       = node->getChild( "show-messages", 0, true );
 126
 127   SGPropertyNode *reg_node = node->getChild("register", 0, true);
 128   _register_node           = reg_node->getChild( "enabled", 0, true );
 129   _username_node           = reg_node->getChild( "username", 0, true );
 130   _password_node           = reg_node->getChild( "password", 0, true );
 131
 132   //_nav0_node               = fgGetNode("/instrumentation/nav[0]/frequencies/selected-mhz", true);
 133   //_nav1_node               = fgGetNode("/instrumentation/nav[1]/frequencies/selected-mhz", true);
 134   _comm0_node              = fgGetNode("/instrumentation/comm[0]/frequencies/selected-mhz", true);
 135   //_comm1_node              = fgGetNode("/instrumentation/comm[1]/frequencies/selected-mhz", true);
 136   _ptt0_node               = fgGetNode("/instrumentation/comm[0]/ptt", true); //FIXME: what about /instrumentation/comm[1]/ptt ?
 137   _callsign_node           = fgGetNode("/sim/multiplay/callsign", true);
 138   _text_node               = fgGetNode("/sim/messages/atc", true );
 139   _version_node            = fgGetNode("/sim/version/flightgear", true );
 140
 141   // Set default values if not provided
 142   if ( !_enabled_node->hasValue() )
 143       _enabled_node->setBoolValue(true);
 144
 145   if ( !_test_node->hasValue() )
 146       _test_node->setBoolValue(false);
 147
 148   if ( !_micBoost_node->hasValue() )
 149       _micBoost_node->setIntValue(1);
 150
 151   if ( !_server_node->hasValue() )
 152       _server_node->setStringValue(DEFAULT_SERVER);
 153
 154   if ( !_speakerLevel_node->hasValue() )
 155       _speakerLevel_node->setFloatValue(1.0);
 156
 157   if ( !_micLevel_node->hasValue() )
 158       _micLevel_node->setFloatValue(1.0);
 159
 160   if ( !_register_node->hasValue() )
 161       _register_node->setBoolValue(false);
 162
 163   if ( !_username_node->hasValue() )
 164       _username_node->setStringValue("guest");
 165
 166   if ( !_password_node->hasValue() )
 167       _password_node->setStringValue("guest");
 168
 169   if ( !_showMessages_node->hasValue() )
 170       _showMessages_node->setBoolValue(false);
 171
 172   _selectedOutput_node->addChangeListener(this);
 173   _selectedInput_node->addChangeListener(this);
 174   _speakerLevel_node->addChangeListener(this);
 175   _micBoost_node->addChangeListener(this);
 176   _micLevel_node->addChangeListener(this);
 177   _enabled_node->addChangeListener(this);
 178   _comm0_node->addChangeListener(this);
 179   //_comm1_node->addChangeListener(this);
 180   //_nav0_node->addChangeListener(this);
 181   //_nav1_node->addChangeListener(this);
 182   _ptt0_node->addChangeListener(this);
 183   _test_node->addChangeListener(this);
 184 }
 185
 186
 187
 188 void FGCom::unbind()
 189 {
 190 }
 191
 192
 193
 194 void FGCom::init()
 195 {
 196   _enabled          = _enabled_node->getBoolValue();
 197   _server           = _server_node->getStringValue();
 198   _register         = _register_node->getBoolValue();
 199   _username         = _username_node->getStringValue();
 200   _password         = _password_node->getStringValue();
 201
 202   _currentComm0     = _comm0_node->getDoubleValue();
 203   //_currentComm1     = _comm1_node->getDoubleValue();
 204   //_currentNav0      = _nav0_node->getDoubleValue();
 205   //_currentNav1      = _nav1_node->getDoubleValue();
 206
 207   _comm0Changed     = false;
 208   //_comm1Changed     = false;
 209   //_nav0Changed      = false;
 210   //_nav1Changed      = false;
 211
 212   _maxRange         = MAX_RANGE;
 213   _minRange         = MIN_RANGE;
 214 }
 215
 216
 217
 218 void FGCom::postinit()
 219 {
 220     if( !_enabled ) {
 221         return;
 222     }
 223
 224     //WARNING: this _must_ be executed after sound system is totally initialized !
 225     if( iaxc_initialize(NUM_CALLS) ) {
 226         SG_LOG(SG_IO, SG_ALERT, "FGCom: cannot initialize iaxclient");
 227         _enabled = false;
 228         return;
 229     }
 230
 231     assert( static_instance == NULL );
 232     static_instance = this;
 233     iaxc_set_event_callback( iaxc_callback );
 234
 235     // FIXME: To be implemented in IAX audio driver
 236     //iaxc_mic_boost_set( _micBoost_node->getIntValue() );
 237     std::string app = "FGFS-";
 238     app += _version_node->getStringValue();
 239
 240     iaxc_set_callerid( _callsign_node->getStringValue(), app.c_str() );
 241     iaxc_set_formats (IAXC_FORMAT_SPEEX, IAXC_FORMAT_SPEEX);
 242     iaxc_set_speex_settings(1, 5, 0, 1, 0, 3);
 243     iaxc_start_processing_thread ();
 244
 245     // Now IAXClient is initialized
 246     _initialized = true;
 247
 248     if ( _register ) {
 249       _regId = iaxc_register( const_cast<char*>(_username.c_str()),
 250                               const_cast<char*>(_password.c_str()),
 251                               const_cast<char*>(_server.c_str()) );
 252         if( _regId == -1 ) {
 253             SG_LOG(SG_IO, SG_ALERT, "FGCom: cannot register iaxclient");
 254             return;
 255         }
 256     }
 257
 258     /*
 259       Here we will create the list of available audio devices
 260       Each audio device has a name, an ID, and a list of capabilities
 261       If an audio device can output sound, available-output=true
 262       If an audio device can input sound, available-input=true
 263
 264       /sim/fgcom/selected-input (int)
 265       /sim/fgcom/selected-output (int)
 266
 267       /sim/fgcom/device[n]/id (int)
 268       /sim/fgcom/device[n]/name (string)
 269       /sim/fgcom/device[n]/available-input (bool)
 270       /sim/fgcom/device[n]/available-output (bool)
 271     */
 272
 273     //FIXME: OpenAL driver use an hard-coded device
 274     //       so all following is unused finally until someone
 275     //       implement "multi-device" support in IAX audio driver
 276     SGPropertyNode *node     = fgGetNode("/sim/fgcom", 0, true);
 277
 278     struct iaxc_audio_device *devs;
 279     int nDevs, input, output, ring;
 280
 281     iaxc_audio_devices_get(&devs,&nDevs, &input, &output, &ring);
 282
 283     for(int i=0; i<nDevs; i++ ) {
 284       SGPropertyNode *in_node = node->getChild("device", i, true);
 285
 286       // devID
 287       _deviceID_node[i] = in_node->getChild("id", 0, true);
 288       _deviceID_node[i]->setIntValue(devs[i].devID);
 289
 290       // name
 291       _deviceName_node[i] = in_node->getChild("name", 0, true);
 292       _deviceName_node[i]->setStringValue(devs[i].name);
 293
 294       // input capability
 295       _deviceInput_node[i] = in_node->getChild("available-input", 0, true);
 296       if( devs[i].capabilities & IAXC_AD_INPUT )
 297         _deviceInput_node[i]->setBoolValue(true);
 298       else
 299         _deviceInput_node[i]->setBoolValue(false);
 300
 301       // output capability
 302       _deviceOutput_node[i] = in_node->getChild("available-output", 0, true);
 303       if( devs[i].capabilities & IAXC_AD_OUTPUT )
 304         _deviceOutput_node[i]->setBoolValue(true);
 305       else
 306         _deviceOutput_node[i]->setBoolValue(false);
 307
 308       // use default device at start
 309       if( devs[i].capabilities & IAXC_AD_INPUT_DEFAULT )
 310         _selectedInput_node->setIntValue(devs[i].devID);
 311       if( devs[i].capabilities & IAXC_AD_OUTPUT_DEFAULT )
 312         _selectedOutput_node->setIntValue(devs[i].devID);
 313     }
 314
 315     // Mute the mic and set speaker at start
 316     iaxc_input_level_set( 0.0 );
 317     iaxc_output_level_set( _speakerLevel_node->getFloatValue() );
 318
 319     iaxc_millisleep(50);
 320
 321     // Do the first call at start
 322     const double freq = _comm0_node->getDoubleValue();
 323     _currentFreqKhz = 10 * static_cast<int>(freq * 100 + 0.25);
 324     std::string num = computePhoneNumber(freq, getAirportCode(freq));
 325     if( !num.empty() ) {
 326       _callComm0 = iaxc_call(num.c_str());
 327     }
 328     if( _callComm0 == -1 )
 329       SG_LOG( SG_IO, SG_DEBUG, "FGCom: cannot call " << num.c_str() );
 330 }
 331
 332
 333
 334 void FGCom::updateCall(bool& changed, int& callNo, double freqMHz)
 335 {
 336
 337     _currentFreqKhz = 10 * static_cast<int>(freqMHz * 100 + 0.25);
 338
 339     if (!changed) {
 340         if( !isInRange(freqMHz) ) {
 341             iaxc_dump_call_number(callNo);
 342             callNo = -1;
 343             return;
 344         } else {
 345             if(callNo != -1)
 346                 return;
 347         }
 348     }
 349
 350     changed = false; // FIXME, out-params are confusing
 351
 352     if( callNo != -1 ) {
 353         iaxc_dump_call_number( callNo );
 354         callNo = -1;
 355     }
 356
 357     if(_p.elapsedMSec() > IAX_DELAY) {
 358         std::string num = computePhoneNumber(freqMHz, getAirportCode(freqMHz));
 359         if( !isInRange(freqMHz) )
 360             return;
 361         if( !num.empty() ) {
 362             callNo = iaxc_call(num.c_str());
 363
 364             if( callNo == -1 )
 365                 SG_LOG( SG_IO, SG_DEBUG, "FGCom: cannot call " << num.c_str() );
 366         }
 367     } else {
 368         changed = true;
 369     }
 370 }
 371
 372
 373
 374 void FGCom::update(double dt)
 375 {
 376     if ( !_enabled || !_initialized ) {
 377         return;
 378     }
 379
 380     // For now we manage FGCom for only one freq because IAXClient
 381     // is not able to handle multiple calls at same time.
 382     updateCall(_comm0Changed, _callComm0, _comm0_node->getDoubleValue());
 383     // updateCall(_comm1Changed, _callComm1, _comm1_node->getDoubleValue());
 384     // updateCall(_nav0Changed, _callNav0, _nav0_node->getDoubleValue());
 385     // updateCall(_nav1Changed, _callNav1, _nav1_node->getDoubleValue());
 386 }
 387
 388
 389
 390 void FGCom::shutdown()
 391 {
 392     if( !_enabled ) {
 393         return;
 394     }
 395
 396   _initialized = false;
 397   _enabled = false;
 398
 399   iaxc_set_event_callback(NULL);
 400   iaxc_unregister(_regId);
 401   iaxc_stop_processing_thread();
 402   iaxc_shutdown();
 403
 404   assert( static_instance == this );
 405   static_instance = NULL;
 406 }
 407
 408
 409
 410 void FGCom::valueChanged(SGPropertyNode *prop)
 411 {
 412   if (prop == _enabled_node) {
 413       bool isEnabled = prop->getBoolValue();
 414       if (_enabled == isEnabled) {
 415           return;
 416       }
 417
 418     if( isEnabled ) {
 419       init();
 420       postinit();
 421     } else {
 422       shutdown();
 423     }
 424     return;
 425   }
 426
 427   if (prop == _ptt0_node && _enabled) {
 428     if( _ptt0_node->getBoolValue() ) {
 429       iaxc_output_level_set( 0.0 );
 430       iaxc_input_level_set( _micLevel_node->getFloatValue() ); //0.0 = min , 1.0 = max
 431     } else {
 432       iaxc_output_level_set( _speakerLevel_node->getFloatValue() );
 433       iaxc_input_level_set( 0.0 );
 434     }
 435   }
 436
 437   if (prop == _test_node) {
 438     testMode( prop->getBoolValue() );
 439     return;
 440   }
 441
 442   //FIXME: not implemented in IAX audio driver (audio_openal.c)
 443   if (prop == _micBoost_node && _initialized) {
 444     int micBoost = prop->getIntValue();
 445     SG_CLAMP_RANGE<int>( micBoost, 0, 1 );
 446     iaxc_mic_boost_set( micBoost ) ; // 0 = enabled , 1 = disabled
 447     return;
 448   }
 449
 450   //FIXME: not implemented in IAX audio driver (audio_openal.c)
 451   if ((prop == _selectedInput_node || prop == _selectedOutput_node) && _initialized) {
 452     int selectedInput = _selectedInput_node->getIntValue();
 453     int selectedOutput = _selectedOutput_node->getIntValue();
 454     iaxc_audio_devices_set(selectedInput, selectedOutput, 0);
 455     return;
 456   }
 457
 458   if (_listener_active)
 459     return;
 460
 461   _listener_active++;
 462
 463   if (prop == _speakerLevel_node && _enabled) {
 464     float speakerLevel = prop->getFloatValue();
 465     SG_CLAMP_RANGE<float>( speakerLevel, 0.0, 1.0 );
 466     _speakerLevel_node->setFloatValue(speakerLevel);
 467     //iaxc_output_level_set(speakerLevel);
 468   }
 469
 470   if (prop == _micLevel_node && _enabled) {
 471     float micLevel = prop->getFloatValue();
 472     SG_CLAMP_RANGE<float>( micLevel, 0.0, 1.0 );
 473     _micLevel_node->setFloatValue(micLevel);
 474     //iaxc_input_level_set(micLevel);
 475   }
 476
 477   if (prop == _comm0_node) {
 478     if( _currentComm0 != prop->getDoubleValue() ) {
 479       _currentComm0 = prop->getDoubleValue();
 480       _p.stamp();
 481       _comm0Changed = true;
 482     }
 483   }
 484 /*
 485   if (prop == _comm1_node) {
 486     if( _currentComm1 != prop->getDoubleValue() ) {
 487       _currentComm1 = prop->getDoubleValue();
 488       _p.stamp();
 489       _comm1Changed = true;
 490     }
 491   }
 492
 493   if (prop == _nav0_node) {
 494     if( _currentNav0 != prop->getDoubleValue() ) {
 495       _currentNav0 = prop->getDoubleValue();
 496       _nav0Changed = true;
 497     }
 498   }
 499
 500   if (prop == _nav1_node) {
 501     if( _currentNav1 != prop->getDoubleValue() ) {
 502       _currentNav1 = prop->getDoubleValue();
 503       _nav1Changed = true;
 504     }
 505   }
 506 */
 507
 508   _listener_active--;
 509 }
 510
 511
 512
 513 void FGCom::testMode(bool testMode)
 514 {
 515   if(testMode && _initialized) {
 516     _enabled = false;
 517     iaxc_dump_call_number(_callComm0);
 518     iaxc_input_level_set( _micLevel_node->getFloatValue() );
 519     iaxc_output_level_set( _speakerLevel_node->getFloatValue() );
 520     std::string num = computePhoneNumber(TEST_FREQ, NULL_ICAO);
 521     if( num.size() > 0 ) {
 522       iaxc_millisleep(IAX_DELAY);
 523       _callComm0 = iaxc_call(num.c_str());
 524     }
 525     if( _callComm0 == -1 )
 526       SG_LOG( SG_IO, SG_DEBUG, "FGCom: cannot call " << num.c_str() );
 527   } else {
 528     if( _initialized ) {
 529       iaxc_dump_call_number(_callComm0);
 530       iaxc_millisleep(IAX_DELAY);
 531       _callComm0 = -1;
 532       _enabled = true;
 533     }
 534   }
 535 }
 536
 537
 538
 539 /*
 540   \param freq The requested frequency e.g 120.825
 541   \return The ICAO code as string e.g LFMV
 542 */
 543
 544 std::string FGCom::getAirportCode(const double& freq)
 545 {
 546   SGGeod aircraftPos = globals->get_aircraft_position();
 547
 548   for(size_t i=0; i<sizeof(special_freq)/sizeof(special_freq[0]); i++) { // Check if it's a special freq
 549     if(special_freq[i] == _currentFreqKhz) {
 550       return NULL_ICAO;
 551     }
 552   }
 553
 554   flightgear::CommStation* apt = flightgear::CommStation::findByFreq(_currentFreqKhz, aircraftPos);
 555   if( !apt ) {
 556     return std::string();
 557   }
 558
 559   if( apt->type() == FGPositioned::FREQ_TOWER ) {
 560     _maxRange = MAX_TWR_RANGE;
 561     _minRange = MIN_GNDTWR_RANGE;
 562   } else if( apt->type() == FGPositioned::FREQ_GROUND ) {
 563     _maxRange = MAX_GND_RANGE;
 564     _minRange = MIN_GNDTWR_RANGE;
 565   } else {
 566     _maxRange = MAX_RANGE;
 567     _minRange = MIN_RANGE;
 568   }
 569
 570   _aptPos = apt->geod();
 571   return apt->airport()->ident();
 572 }
 573
 574
 575
 576 /*
 577   \param freq The requested frequency e.g 112.7
 578   \return The ICAO code as string e.g ITS
 579 */
 580 /*
 581 std::string FGCom::getVorCode(const double& freq) const
 582 {
 583   SGGeod aircraftPos = globals->get_aircraft_position();
 584   FGNavList::TypeFilter filter(FGPositioned::VOR);
 585
 586   FGNavRecord* vor = FGNavList::findByFreq( freq, aircraftPos, &filter);
 587   if( !vor ) {
 588     return std::string();
 589   }
 590
 591   return vor->get_ident();
 592 }
 593 */
 594
 595
 596 /*
 597   \param freq The requested frequency e.g 120.825
 598   \param iaco The associated ICAO code e.g LFMV
 599   \return The phone number as string i.e username:password@fgcom.flightgear.org/0176707786120825
 600 */
 601
 602 std::string FGCom::computePhoneNumber(const double& freq, const std::string& icao) const
 603 {
 604   if( icao.empty() )
 605     return std::string();
 606
 607   char phoneNumber[256];
 608   char exten[32];
 609   char tmp[5];
 610
 611   /*Convert ICAO to ASCII */
 612   sprintf( tmp, "%4s", icao.c_str() );
 613
 614   /*Built the phone number */
 615   sprintf( exten,
 616            "%02d%02d%02d%02d%02d%06d",
 617            01,
 618            tmp[0],
 619            tmp[1],
 620            tmp[2],
 621            tmp[3],
 622            (int) (freq * 1000 + 0.5) );
 623   exten[16] = '\0';
 624
 625   snprintf( phoneNumber,
 626             sizeof (phoneNumber),
 627             "%s:%s@%s/%s",
 628             _username.c_str(),
 629             _password.c_str(),
 630             _server.c_str(),
 631             exten);
 632
 633   return phoneNumber;
 634 }
 635
 636
 637
 638 /*
 639   \return A boolean value, 1=in range, 0=out of range
 640 */
 641
 642 bool FGCom::isInRange(const double &freq) const
 643 {
 644     for(size_t i=0; i<sizeof(special_freq)/sizeof(special_freq[0]); i++) { // Check if it's a special freq
 645       if( (special_freq[i]) == _currentFreqKhz ) {
 646         return 1;
 647       }
 648     }
 649
 650     SGGeod acftPos = globals->get_aircraft_position();
 651     double distNm = SGGeodesy::distanceNm(_aptPos, acftPos);
 652     double delta_elevation_ft = fabs(acftPos.getElevationFt() - _aptPos.getElevationFt());
 653     double rangeNm = 1.23 * sqrt(delta_elevation_ft);
 654
 655     if (rangeNm > _maxRange) rangeNm = _maxRange;
 656     if (rangeNm < _minRange) rangeNm = _minRange;
 657     if( distNm > rangeNm )   return 0;
 658     return 1;
 659 }
 660
 661