@babblevoice/projectrtp 2.5.35 → 2.6.0

package/src/projectrtpchannel.cpp

@@ -128,13 +128,12 @@ projectrtpchannel::projectrtpchannel( unsigned short port ):
   outcodec(),
   incodec(),
   player( nullptr ),
-  newplaydef( nullptr ),
-  newplaylock( false ),
+  playerstash( nullptr ),
+  playerlock( false ),
   doecho( false ),
   tick( workercontext ),
   nexttick( std::chrono::high_resolution_clock::now() ),
-  newrecorders(),
-  newrecorderslock( false ),
+  recorderslock( false ),
   recorders(),
   rtpdtls( nullptr ),
   rtpdtlslock( false ),
@@ -144,6 +143,7 @@ projectrtpchannel::projectrtpchannel( unsigned short port ):
   remoteport( 0 ),
   queueddigits(),
   queuddigitslock( false ),
+  dtmfsendcount( 0 ),
   lastdtmfsn( 0 ),
   tickstarttime() {
 
@@ -418,16 +418,17 @@ void projectrtpchannel::doclose( void ) {
   if( !this->active ) return;
   this->active = false;
 
-  this->tick.cancel();
+  auto self = shared_from_this();
 
-  if( nullptr != this->player ) {
-    postdatabacktojsfromthread( shared_from_this(), "play", "end", "channelclosed" );
-  }
+  this->tick.cancel();
 
   {
-    SpinLockGuard guard( this->newplaylock );
+    SpinLockGuard guard( this->playerlock );
+    if( nullptr != this->player ) {
+      postdatabacktojsfromthread( self, "play", "end", "channelclosed" );
+    }
+
     this->player = nullptr;
-    this->newplaydef = nullptr;
   }
 
   /* close our session if we have one */
@@ -437,11 +438,15 @@ void projectrtpchannel::doclose( void ) {
   }
 
   /* close up any remaining recorders */
-  for( auto& rec: this->recorders ) {
-    postdatabacktojsfromthread( shared_from_this(), "record", rec->file, "finished.channelclosed" );
+  {
+    SpinLockGuard guard( this->recorderslock );
+    for( auto& rec: this->recorders ) {
+      postdatabacktojsfromthread( self, "record", rec->file, "finished.channelclosed" );
+    }
+
+    this->recorders.clear();
   }
 
-  this->recorders.clear();
   this->resolver.cancel();
 
   this->rtpsocket.close();
@@ -449,7 +454,7 @@ void projectrtpchannel::doclose( void ) {
 
   this->returnavailableport();
 
-  postdatabacktojsfromthread( shared_from_this(), "close", this->closereason );
+  postdatabacktojsfromthread( self, "close", this->closereason );
 }
 
 bool projectrtpchannel::checkidlerecv( void ) {
@@ -470,6 +475,13 @@ bool projectrtpchannel::checkidlerecv( void ) {
       this->doclose();
       return true;
     }
+  } else if( this->active ) {
+    /* active but not receiving ie on hold or similar - but there are limits! */
+    if( this->hardtickswithnortpcount > ( 50 * 60 * 60 * 2 ) ) { /* 2hr hard timeout */
+      this->closereason = "idle";
+      this->doclose();
+      return true;
+    }
   }
   return false;
 }
@@ -486,6 +498,8 @@ void projectrtpchannel::handletick( const boost::system::error_code& error ) {
   if( error == boost::asio::error::operation_aborted ) return;
   if( !this->active ) return;
 
+  auto self = shared_from_this();
+
   if( this->_requestclose ) {
     this->doclose();
     return;
@@ -510,11 +524,15 @@ void projectrtpchannel::handletick( const boost::system::error_code& error ) {
     return;
   }
 
-  this->checkfornewrecorders();
-
   this->incodec << codecx::next;
   this->outcodec << codecx::next;
 
+  soundsoup::pointer ourplayer = nullptr;
+  {
+    SpinLockGuard guard( this->playerlock );
+    ourplayer = this->player;
+  }
+
   rtppacket *src;
   do {
     {
@@ -543,36 +561,10 @@ void projectrtpchannel::handletick( const boost::system::error_code& error ) {
     this->incodec << *src;
   }
 
-  /* check for new players */
-  {
-    bool playerreplaced = false;
-    bool playernew = false;
-    {
-      SpinLockGuard guard( this->newplaylock );
-      if( nullptr != this->newplaydef ) {
-        this->doecho = false;
-
-        if( nullptr != this->player ) {
-          playerreplaced = true;
-        }
-
-        this->player = this->newplaydef;
-        this->newplaydef = nullptr;
-        playernew = true;
-      }
-    }
-
-    if( playerreplaced ) {
-      postdatabacktojsfromthread( shared_from_this(), "play", "end", "replaced" );
-    }
-    if( playernew ) {
-      postdatabacktojsfromthread( shared_from_this(), "play", "start", "new" );
-    }
-  }
-
   if( this->doecho ) {
-    if( this->player ) {
-      postdatabacktojsfromthread( shared_from_this(), "play", "end", "doecho" );
+    if( ourplayer ) {
+      postdatabacktojsfromthread( self, "play", "end", "doecho" );
+      SpinLockGuard guard( this->playerlock );
       this->player = nullptr;
     }
 
@@ -583,20 +575,21 @@ void projectrtpchannel::handletick( const boost::system::error_code& error ) {
       dst << this->outcodec;
       this->writepacket( dst );
     }
-  } else if( this->player ) {
+  } else if( ourplayer ) {
     rtppacket *out = this->gettempoutbuf();
     rawsound r;
-    if( this->player->read( r ) ) {
+    if( ourplayer->read( r ) ) {
       if( r.size() > 0 ) {
         this->outcodec << r;
         out << this->outcodec;
         this->writepacket( out );
       }
     } else {
+      postdatabacktojsfromthread( self, "play", "end", "completed" );
+      SpinLockGuard guard( this->playerlock );
       this->player = nullptr;
-      postdatabacktojsfromthread( shared_from_this(), "play", "end", "completed" );
     }
-  } 
+  }
 
   this->writerecordings();
 
@@ -628,50 +621,47 @@ void projectrtpchannel::setnexttick( void ) {
 }
 
 void projectrtpchannel::requestplay( soundsoup::pointer newdef ) {
-  SpinLockGuard guard( this->newplaylock );
-  this->newplaydef = newdef;
+  SpinLockGuard guard( this->playerlock );
+
+  auto self = shared_from_this();
+
+  this->doecho = false;
+
+  if( nullptr != this->player ) {
+    postdatabacktojsfromthread( self, "play", "end", "replaced" );
+  }
+
+  postdatabacktojsfromthread( self, "play", "start", "new" );
+  this->player = newdef;
 }
 
 /*
 Post a request to record (or modify a param of a record). This function is typically
 called from a control thread (i.e. node).
 */
-void projectrtpchannel::requestrecord( channelrecorder::pointer rec ) {
-  SpinLockGuard guard( this->newrecorderslock );
-  this->newrecorders.push_back( rec );
-}
-
-/*
-Check for new channels to add to the mix in our own thread. This will be a different thread
-to requestrecord.
-*/
-void projectrtpchannel::checkfornewrecorders( void ) {
-  channelrecorder::pointer rec;
-  SpinLockGuard guard( this->newrecorderslock );
-
-  for ( auto const& newrec : this->newrecorders ) {
-    for( auto& currentrec: this->recorders ) {
-      if( currentrec->file == newrec->file ) {
-        currentrec->pause = newrec->pause;
-        currentrec->requestfinish = newrec->requestfinish;
-        goto endofwhileloop;
-      }
+void projectrtpchannel::requestrecord( channelrecorder::pointer newrec ) {
+  SpinLockGuard guard( this->recorderslock );
+
+  for( auto& currentrec: this->recorders ) {
+    if( currentrec->file == newrec->file ) {
+      currentrec->pause.store( newrec->pause );
+      currentrec->requestfinish.store( newrec->requestfinish );
+      return;
     }
+  }
 
-    newrec->sfile = soundfilewriter::create(
-        newrec->file,
-        newrec->numchannels,
-        soundfile::getsampleratefrompt( this->codec ) );
-
-    this->recorders.push_back( newrec );
+  newrec->sfile = soundfilewriter::create(
+      newrec->file,
+      newrec->numchannels,
+      soundfile::getsampleratefrompt( this->codec ) );
 
-endofwhileloop:;
-  }
 
-  this->newrecorders.clear();
+  this->recorders.push_back( newrec );
 }
 
-void projectrtpchannel::removeoldrecorders( void ) {
+void projectrtpchannel::removeoldrecorders( pointer self ) {
+
+  SpinLockGuard guard( this->recorderslock );
 
   for ( auto const& rec : this->recorders ) {
     if( rec->isactive() ) {
@@ -686,7 +676,7 @@ void projectrtpchannel::removeoldrecorders( void ) {
       if( rec->requestfinish ) {
         rec->completed = true;
         rec->maxsincestartpower = 0;
-        postdatabacktojsfromthread( shared_from_this(), "record", rec->file, "finished.requested" );
+        postdatabacktojsfromthread( self, "record", rec->file, "finished.requested" );
         continue;
       }
 
@@ -699,14 +689,14 @@ void projectrtpchannel::removeoldrecorders( void ) {
           rec->lastpowercalc < rec->finishbelowpower ) {
         rec->completed = true;
         rec->maxsincestartpower = 0;
-        postdatabacktojsfromthread( shared_from_this(), "record", rec->file, "finished.belowpower" );
+        postdatabacktojsfromthread( self, "record", rec->file, "finished.belowpower" );
         continue;
       }
 
       if( 0 != rec->maxduration && diff.total_milliseconds() > rec->maxduration ) {
         rec->completed = true;
         rec->maxsincestartpower = 0;
-        postdatabacktojsfromthread( shared_from_this(), "record", rec->file, "finished.timeout" );
+        postdatabacktojsfromthread( self, "record", rec->file, "finished.timeout" );
         continue;
       }
     }
@@ -725,12 +715,15 @@ bool projectrtpchannel::recordercompleted( const channelrecorder::pointer& rec )
  */
 static char dtmfchars[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '*', '#', 'A', 'B', 'C', 'D', 'F' };
 void projectrtpchannel::sendtelevent( void ) {
+  auto self = shared_from_this();
+  SpinLockGuard guard( this->playerlock );
+
   if( this->player && this->player->doesinterupt() ) {
-    postdatabacktojsfromthread( shared_from_this(), "play", "end", "telephone-event" );
+    postdatabacktojsfromthread( self, "play", "end", "telephone-event" );
     this->player = nullptr;
   }
 
-  postdatabacktojsfromthread( shared_from_this(), "telephone-event", std::string( 1, dtmfchars[ this->lasttelephoneevent ] ) );
+  postdatabacktojsfromthread( self, "telephone-event", std::string( 1, dtmfchars[ this->lasttelephoneevent ] ) );
 }
 /*
 ## checkfordtmf
@@ -785,11 +778,22 @@ If our codecs (in and out) have data then write to recorded files.
 */
 void projectrtpchannel::writerecordings( void ) {
 
-  if( 0 == this->recorders.size() ) return;
+  if( !this->active ) return;
+
+  auto self = shared_from_this();
+
+  chanrecptrlist worklist;
+  {
+    SpinLockGuard guard( this->recorderslock );
+    worklist = this->recorders;
+  }
+
+  if( 0 == worklist.size() ) return;
+
   uint16_t power = 0;
 
   /* Decide if we need to calc power as it is expensive */
-  for( auto& rec: this->recorders ) {
+  for( auto& rec: worklist ) {
     if( ( !rec->isactive() && 0 != rec->startabovepower ) || 0 != rec->finishbelowpower ) {
       power = this->incodec.power();
       break;
@@ -797,7 +801,7 @@ void projectrtpchannel::writerecordings( void ) {
   }
 
   /* Check if we need to trigger the start of any recordings and write */
-  for( auto& rec: this->recorders ) {
+  for( auto& rec: worklist ) {
 
     if( rec->completed ) continue;
 
@@ -812,11 +816,11 @@ void projectrtpchannel::writerecordings( void ) {
     if( !rec->isactive() ) {
       if( 0 == rec->startabovepower ) {
         rec->active();
-        postdatabacktojsfromthread( shared_from_this(), "record", rec->file, "recording" );
+        postdatabacktojsfromthread( self, "record", rec->file, "recording" );
       } else {
         if( pav > rec->startabovepower ) {
           rec->active();
-          postdatabacktojsfromthread( shared_from_this(), "record", rec->file, "recording.abovepower" );
+          postdatabacktojsfromthread( self, "record", rec->file, "recording.abovepower" );
         }
       }
     }
@@ -826,7 +830,9 @@ void projectrtpchannel::writerecordings( void ) {
     }
   }
 
-  this->removeoldrecorders();
+  /* this function is also protected by this->recorderslock - so ensure it is free before calling */
+  /* pass in sefl to ensure no gap in destruction/auto ptr destruction */
+  this->removeoldrecorders( self );
 }
 
 bool projectrtpchannel::dtlsnegotiate( void ) {
@@ -1148,30 +1154,49 @@ bool projectrtpchannel::mix( projectrtpchannel::pointer other ) {
     return true;
   }
 
-  SpinLockGuard guard( this->mixerlock );
+  auto self = shared_from_this();
+
+  {
+    SpinLockGuard guard( this->playerlock );
+    if( nullptr != this->player ) {
+      postdatabacktojsfromthread( self, "play", "end", "channelmixing" );
+    }
+    this->player = nullptr;
+  }
+  {
+    SpinLockGuard guard( other->playerlock );
+    if( nullptr != other->player ) {
+      postdatabacktojsfromthread( other, "play", "end", "channelmixing" );
+    }
+    other->player = nullptr;
+  }
 
-  if( nullptr == this->mixer && nullptr != other->mixer ) {
-    this->mixer = other->mixer;
-    this->mixer->addchannel( shared_from_this() );
+  {
+    SpinLockGuard guard( this->mixerlock );
 
-  } else if ( nullptr != this->mixer && nullptr == other->mixer ) {
-    other->mixer = this->mixer;
-    this->mixer->addchannel( other );
+    if( nullptr == this->mixer && nullptr != other->mixer ) {
+      this->mixer = other->mixer;
+      this->mixer->addchannel( self );
 
-  } else if( nullptr == this->mixer && nullptr == other->mixer  ) {
-    this->mixer = projectchannelmux::create( workercontext );
-    other->mixer = this->mixer;
+    } else if ( nullptr != this->mixer && nullptr == other->mixer ) {
+      other->mixer = this->mixer;
+      this->mixer->addchannel( other );
 
-    this->mixer->addchannels( shared_from_this(), other );
+    } else if( nullptr == this->mixer && nullptr == other->mixer  ) {
+      this->mixer = projectchannelmux::create( workercontext );
+      other->mixer = this->mixer;
 
-    this->mixer->go();
-  } else {
-    /* If we get here this and other are already mixing and should be cleaned up first */
-    postdatabacktojsfromthread( shared_from_this(), "mix", "busy" );
-    return false;
+      this->mixer->addchannels( self, other );
+
+      this->mixer->go();
+    } else {
+      /* If we get here this and other are already mixing and should be cleaned up first */
+      postdatabacktojsfromthread( self, "mix", "busy" );
+      return false;
+    }
   }
 
-  postdatabacktojsfromthread( shared_from_this(), "mix", "start" );
+  postdatabacktojsfromthread( self, "mix", "start" );
   postdatabacktojsfromthread( other, "mix", "start" );
 
   return true;
@@ -1217,6 +1242,12 @@ void projectrtpchannel::dtmf( std::string digits ) {
   this->queueddigits += digits;
 }
 
+const char volume = 10;
+const char endofevent = 0x80;
+
+const int numevents = 3;
+const int numendevents = 3;
+
 /*
 Now send each digit.
 */
@@ -1231,7 +1262,6 @@ void projectrtpchannel::senddtmf( void ) {
     SpinLockGuard guard( this->queuddigitslock );
     if( this->queueddigits.size() > 0 ) {
       tosend = this->queueddigits[ 0 ];
-      this->queueddigits.erase( this->queueddigits.begin() );
     }
   }
 
@@ -1265,77 +1295,42 @@ void projectrtpchannel::senddtmf( void ) {
     return;
   }
 
-  const char volume = 10;
-  const char endofevent = 0x80;
-
-  rtppacket *dst = this->gettempoutbuf();
-  dst->setpayloadtype( this->rfc2833pt );
-  dst->setpayloadlength( 4 );
-  uint8_t *pl =  dst->getpayload();
-  pl[ 0 ] = tosend;
-  pl[ 1 ] = volume; /* end of event & reserved & volume */
-  uint16_t *tmp = ( uint16_t * ) &pl[ 2 ]; /* event duration */
-  *tmp = htons( 160 );
-
-  this->writepacket( dst );
-
-  dst = this->gettempoutbuf();
-  dst->setpayloadtype( this->rfc2833pt );
-  dst->setpayloadlength( 4 );
-  pl =  dst->getpayload();
-  pl[ 0 ] = tosend;
-  pl[ 1 ] = volume; /* end of event & reserved & volume */
-  tmp = ( uint16_t * ) &pl[ 2 ]; /* event duration */
-  *tmp = htons( 320 );
-
-  this->writepacket( dst );
-
-  dst = this->gettempoutbuf();
-  dst->setpayloadtype( this->rfc2833pt );
-  dst->setpayloadlength( 4 );
-  pl =  dst->getpayload();
-  pl[ 0 ] = tosend;
-  pl[ 1 ] = volume; /* end of event & reserved & volume */
-  tmp = ( uint16_t * ) &pl[ 2 ]; /* event duration */
-  *tmp = htons( 480 );
-
-  this->writepacket( dst );
-
-  dst = this->gettempoutbuf();
-  dst->setpayloadtype( this->rfc2833pt );
-  dst->setmarker();
-  dst->setpayloadlength( 4 );
-  pl =  dst->getpayload();
-  pl[ 0 ] = tosend;
-  pl[ 1 ] = endofevent | volume; /* end of event & reserved & volume */
-  tmp = ( uint16_t * ) &pl[ 2 ]; /* event duration */
-  *tmp = htons( 640 );
-
-  this->writepacket( dst );
-
-  dst = this->gettempoutbuf();
-  dst->setpayloadtype( this->rfc2833pt );
-  dst->setpayloadlength( 4 );
-  pl =  dst->getpayload();
-  pl[ 0 ] = tosend;
-  pl[ 1 ] = endofevent | volume; /* end of event & reserved & volume */
-  tmp = ( uint16_t * ) &pl[ 2 ]; /* event duration */
-  *tmp = htons( 640 );
-
-  this->writepacket( dst );
-
-  dst = this->gettempoutbuf();
-  dst->setpayloadtype( this->rfc2833pt );
-  dst->setpayloadlength( 4 );
-  pl =  dst->getpayload();
-  pl[ 0 ] = tosend;
-  pl[ 1 ] = endofevent | volume; /* end of event & reserved & volume */
-  tmp = ( uint16_t * ) &pl[ 2 ]; /* event duration */
-  *tmp = htons( 640 );
-
-  this->writepacket( dst );
-
-  this->lastdtmfsn = this->snout;
+  if( this->dtmfsendcount <= numevents ) {
+    rtppacket *dst = this->gettempoutbuf();
+    dst->setpayloadtype( this->rfc2833pt );
+    dst->setpayloadlength( 4 );
+    uint8_t *pl =  dst->getpayload();
+    pl[ 0 ] = tosend;
+    pl[ 1 ] = volume; /* end of event & reserved & volume */
+    uint16_t *tmp = ( uint16_t * ) &pl[ 2 ]; /* event duration */
+    *tmp = htons( ( this->dtmfsendcount + 1 ) * 160 );
+
+    this->writepacket( dst );
+    
+  } else {
+    /* end packet */
+    rtppacket *dst = this->gettempoutbuf();
+    dst->setpayloadtype( this->rfc2833pt );
+    dst->setmarker();
+    dst->setpayloadlength( 4 );
+    uint8_t *pl =  dst->getpayload();
+    pl[ 0 ] = tosend;
+    pl[ 1 ] = endofevent | volume; /* end of event & reserved & volume */
+    uint16_t *tmp = ( uint16_t * ) &pl[ 2 ]; /* event duration */
+    *tmp = htons( ( numevents + 2 ) * 160 );
+
+    this->writepacket( dst );
+  }
+
+  if( this->dtmfsendcount >= ( numevents + numendevents ) ) {
+    SpinLockGuard guard( this->queuddigitslock );
+    this->queueddigits.erase( this->queueddigits.begin() );
+    this->lastdtmfsn = this->snout;
+    this->dtmfsendcount = 0;
+    return;
+  }
+
+  this->dtmfsendcount++;
 }
 
 /*

package/src/projectrtpchannel.h

@@ -196,8 +196,7 @@ private:
   void incrtsout( void );
 
   bool checkidlerecv( void );
-  void checkfornewrecorders( void );
-  void removeoldrecorders( void );
+  void removeoldrecorders( pointer );
   void writerecordings( void );
 
   bool checkfordtmf( rtppacket *src );
@@ -234,15 +233,14 @@ private:
   codecx incodec;
 
   soundsoup::pointer player;
-  soundsoup::pointer newplaydef;
-  std::atomic_bool newplaylock;
+  soundsoup::pointer playerstash;
+  std::atomic_bool playerlock;
 
   std::atomic_bool doecho;
   boost::asio::steady_timer tick;
   std::chrono::high_resolution_clock::time_point nexttick;
 
-  chanrecptrlist newrecorders;
-  std::atomic_bool newrecorderslock;
+  std::atomic_bool recorderslock;
   chanrecptrlist recorders;
 
   /* DTLS Session */
@@ -258,6 +256,7 @@ private:
   /* outbound DTMF */
   std::string queueddigits;
   std::atomic_bool queuddigitslock;
+  uint8_t dtmfsendcount;
   uint16_t lastdtmfsn;
 
   boost::posix_time::ptime tickstarttime;