@babblevoice/projectrtp 2.5.35 → 2.5.38

package/src/projectrtpchannelmux.cpp

@@ -12,8 +12,7 @@ projectchannelmux::projectchannelmux( boost::asio::io_context &iocontext ):
   iocontext( iocontext ),
   tick( iocontext ),
   nexttick( std::chrono::high_resolution_clock::now() ),
-  newchannels(),
-  newchannelslock( false ),
+  channelslock( false ),
   added(),
   subtracted(),
   active( false ) {
@@ -99,7 +98,6 @@ void projectchannelmux::mixall( void ) {
     }
 
     if( nullptr != src ) {
-      chan->incodec << codecx::next;
       chan->incodec << *src;
       this->added += chan->incodec;
     }
@@ -135,7 +133,6 @@ void projectchannelmux::mixall( void ) {
       }
     }
 
-    chan->outcodec << codecx::next;
     chan->outcodec << this->subtracted;
     dst << chan->outcodec;
     chan->writepacket( dst );
@@ -214,12 +211,12 @@ void projectchannelmux::mix2( void ) {
 }
 
 bool projectchannelmux::channelremoverequested( const projectrtpchannelptr& chan ) {
-  if( chan->removemixer ) {
+  if( chan->removemixer || chan->_requestclose || (!chan->active) ) {
     chan->dounmix();
     return true;
   }
 
-  return false; 
+  return false;
 }
 
 /*
@@ -228,52 +225,65 @@ Our timer handler.
 void projectchannelmux::handletick( const boost::system::error_code& error ) {
   if ( error == boost::asio::error::operation_aborted ) return;
 
-  if( !this->active ) return;
+  /* ensure we are not destroyed  during tick */
+  auto self = shared_from_this();
 
-  this->checkfornewmixes();
+  if( !this->active ) return;
 
-  /* Check for channels which have request removal */
-  this->channels.remove_if( channelremoverequested );
+  projectchanptrlist workingchannels;
+  {
+    SpinLockGuard guard( this->channelslock );
+    /* Check for channels which have request removal */
+    this->channels.remove_if( channelremoverequested );
+    /* ensure we have a local copy to maintain life of all objects */
+    workingchannels = this->channels;
+  }
 
-  if( 0 == this->channels.size() ) {
+  if( 0 == workingchannels.size() ) {
     /* We're done */
     this->active = false;
     return;
   }
 
-  for( auto& chan: this->channels ) {
+  for( auto& chan: workingchannels ) {
+    chan->outcodec << codecx::next;
+    chan->incodec << codecx::next;
+
+    {
+      SpinLockGuard guard( chan->playerlock );
+      /* preserve any players during mix */
+      chan->playerstash = chan->player;
+    }
+    
     chan->startticktimer();
-    chan->checkfornewrecorders();
     chan->incrtsout();
   }
 
-  if( 2 == this->channels.size() ) {
+  if( 2 == workingchannels.size() ) {
     this->mix2();
-  } else if( this->channels.size() > 2 ) {
+  } else if( workingchannels.size() > 2 ) {
     this->mixall();
   }
 
-  for( auto& chan: this->channels ) {
+  for( auto& chan: workingchannels ) {
     chan->senddtmf();
-    chan->writerecordings();
-    chan->checkidlerecv();
+    chan->writerecordings();  //////////////////// crash here -> channel -> soundfile - there is a problem with the CODEC - this can remove recorders from channel
+    chan->checkidlerecv();    // this can call doclose() - recorders might be destroyed now
     chan->endticktimer();
+
+    chan->playerstash = nullptr;
   }
 
   /* The last thing we do */
-  this->setnexttick();
-
-  for( auto& chan: this->channels ) {
-    chan->endticktimer();
-  }
+  this->setnexttick( self );
 }
 
-void projectchannelmux::setnexttick( void ) {
+void projectchannelmux::setnexttick( pointer self ) {
   this->nexttick = this->nexttick + std::chrono::milliseconds( 20 );
 
   this->tick.expires_after( this->nexttick - std::chrono::high_resolution_clock::now() );
   this->tick.async_wait( boost::bind( &projectchannelmux::handletick,
-                                      shared_from_this(),
+                                      self,
                                       boost::asio::placeholders::error ) );
 }
 
@@ -316,35 +326,26 @@ static bool underlyingpointercmp( projectrtpchannelptr l, projectrtpchannelptr r
   return l.get() > r.get();
 }
 
-/*
-Check for new channels to add to the mix in our own thread.
-*/
-void projectchannelmux::checkfornewmixes( void ) {
-  SpinLockGuard guard( this->newchannelslock );
+void projectchannelmux::addchannel( projectrtpchannelptr chan ) {
+  SpinLockGuard guard( this->channelslock );
 
-  for ( auto const& newchan : this->newchannels ) {
-    this->channels.push_back( newchan );
-  }
-  this->newchannels.clear();
+  chan->mixing = true;
+  this->channels.push_back( chan );
 
   this->channels.sort( underlyingpointercmp );
   this->channels.unique( underlyingpointerequal );
 }
 
-void projectchannelmux::addchannel( projectrtpchannelptr chan ) {
-  SpinLockGuard guard( this->newchannelslock );
-
-  chan->mixing = true;
-  this->newchannels.push_back( chan );
-}
-
 void projectchannelmux::addchannels( projectrtpchannelptr chana, projectrtpchannelptr chanb ) {
-  SpinLockGuard guard( this->newchannelslock );
+  SpinLockGuard guard( this->channelslock );
 
   chana->mixing = true;
   chanb->mixing = true;
-  this->newchannels.push_back( chana );
-  this->newchannels.push_back( chanb );
+  this->channels.push_back( chana );
+  this->channels.push_back( chanb );
+
+  this->channels.sort( underlyingpointercmp );
+  this->channels.unique( underlyingpointerequal );
 }
 
 /*
@@ -365,9 +366,7 @@ void projectchannelmux::postrtpdata( projectrtpchannelptr srcchan, projectrtpcha
     dst->setpayloadtype( dstchan->rfc2833pt );
     dst->copy( src );
   } else {
-    srcchan->incodec << codecx::next;
     srcchan->incodec << *src;
-    dstchan->outcodec << codecx::next;
     dstchan->outcodec << *src;
     dst << dstchan->outcodec;
   }

package/src/projectrtpchannelmux.h

@@ -39,11 +39,10 @@ public:
 
 private:
 
-  void checkfornewmixes( void );
   void mix2( void );
   void mixall( void );
 
-  void setnexttick( void );
+  void setnexttick( pointer );
 
   static bool channelremoverequested( const projectrtpchannelptr& value );
 
@@ -53,8 +52,7 @@ private:
   boost::asio::steady_timer tick;
   std::chrono::high_resolution_clock::time_point nexttick;
 
-  projectchanptrlist newchannels;
-  std::atomic_bool newchannelslock;
+  std::atomic_bool channelslock;
 
   rawsound added;
   rawsound subtracted;

package/src/projectrtpchannelrecorder.h

@@ -43,15 +43,15 @@ public:
   boost::posix_time::ptime created;
   boost::posix_time::ptime activeat;
 
-  bool pause;
-  bool requestfinish;
-  bool completed; /* indicate clean up required */
+  std::atomic_bool pause;
+  std::atomic_bool requestfinish;
+  std::atomic_bool completed; /* indicate clean up required */
 
 private:
 
   /* Rolling average of power reads */
   ma_filter powerfilter;
-  bool _active;
+  std::atomic_bool _active;
 
 };
 

package/src/projectrtpcodecx.cpp

@@ -1,4 +1,7 @@
 
+/* needed to build on ubuntu */
+#include <utility>
+
 #include <iostream>
 #include <cstdlib>
 #include <iomanip>
@@ -223,11 +226,11 @@ bool codecx::g711tol16( void )
     return false;
   }
 
-  this->l168kref.malloc( G711PAYLOADSAMPLES, sizeof( int16_t ), L168KPAYLOADTYPE );
+  this->l168kref.malloc( L16PAYLOADSAMPLES, sizeof( int16_t ), L168KPAYLOADTYPE );
 
   int16_t *out = ( int16_t * ) this->l168kref.c_str();
 
-  for( size_t i = 0; i < G711PAYLOADSAMPLES; i++ ) {
+  for( size_t i = 0; i < L16PAYLOADSAMPLES; i++ ) {
     *out = convert[ *in ];
     in++;
     out++;
@@ -384,8 +387,7 @@ bool codecx::l16tog722( void ) {
 As it says.
 */
 bool codecx::g722tol16( void ) {
-  if( 0 == this->g722ref.size() ) return false;
-  if( this->g722ref.isdirty() ) return false;
+  if( !this->g722ref.hasdata() ) return false;
 
   this->l1616kref.malloc( L1616PAYLOADSAMPLES, sizeof( int16_t ), L1616KPAYLOADTYPE );
 
@@ -401,7 +403,7 @@ bool codecx::g722tol16( void ) {
                                 this->g722ref.c_str(),
                                 G722PAYLOADBYTES );
 
-  if( 320 != l1616klength ) return false;
+  if( L1616PAYLOADSAMPLES != l1616klength ) return false;
   
   this->l1616kref.dirty( false );
   return true;
@@ -460,8 +462,7 @@ Downsample our L16 wideband samples to 8K. Pass through filter then grab every o
 */
 bool codecx::l16widetonarrowband( void ) {
 
-  if( 0 == this->l1616kref.size() ) return false;
-  if( this->l1616kref.isdirty() ) return false;
+  if( !this->l1616kref.hasdata() ) return false;
 
   this->l168kref.malloc( L16PAYLOADSAMPLES, sizeof( int16_t ), L168KPAYLOADTYPE );
 
@@ -485,9 +486,9 @@ bool codecx::l16widetonarrowband( void ) {
 Search for the relevent data and convert as necessary.
 */
 bool codecx::requirenarrowband( void ) {
-  if( 0 != this->l168kref.size() && !this->l168kref.isdirty() ) return true;
+  if( this->l168kref.hasdata() ) return true;
 
-  if( 0 != this->l1616kref.size() && !this->l1616kref.isdirty() ) {
+  if( this->l1616kref.hasdata() ) {
     return this->l16widetonarrowband();
   }
 
@@ -501,10 +502,9 @@ bool codecx::requirenarrowband( void ) {
 ## requirel16
 Wide or narrow - it doesn't matter - we just need l16
 */
-rawsound& codecx::requirel16( void )
-{
-  if( 0 != this->l168kref.size() && !this->l168kref.isdirty() ) return this->l168kref;
-  if( 0 != this->l1616kref.size() && !this->l1616kref.isdirty() ) return this->l1616kref;
+rawsound& codecx::requirel16( void ) {
+  if( this->l168kref.hasdata() ) return this->l168kref;
+  if( this->l1616kref.hasdata() ) return this->l1616kref;
 
   if( this->g711tol16() ) return this->l168kref;
   if( this->ilbctol16() ) return this->l168kref;
@@ -513,77 +513,57 @@ rawsound& codecx::requirel16( void )
   return this->l168kref;
 }
 
+rawsound nullref;
 /**
  * Obtain a reference to a rawsound for the codec type pt. i.e. we alrteady have 
  * the input sound and based on the format we want to convert it to that 
  * format.
 */
 rawsound& codecx::getref( int pt ) {
-  /* If we have already have or converted this packet... */
-  if( PCMAPAYLOADTYPE == pt &&  0 != this->pcmaref.size() && !this->pcmaref.isdirty() ) {
-    return this->pcmaref;
-  }
-  else if( PCMUPAYLOADTYPE == pt && 0 != this->pcmuref.size() && !this->pcmuref.isdirty() ) {
-    return this->pcmuref;
-  }
-  else if( ILBCPAYLOADTYPE == pt && 0 != this->ilbcref.size() && !this->ilbcref.isdirty() ) {
-    return this->ilbcref;
-  }
-  else if( G722PAYLOADTYPE == pt && 0 != this->g722ref.size() && !this->g722ref.isdirty() ) {
-    return this->g722ref;
-  }
-  else if( L168KPAYLOADTYPE == pt && 0 != this->l168kref.size() && !this->l168kref.isdirty() ) {
-    return this->l168kref;
-  }
-  else if( L1616KPAYLOADTYPE == pt && 0 != this->l1616kref.size() && !this->l1616kref.isdirty() ) {
-    return this->l1616kref;
-  }
 
-  /* If we get here we may have L16 but at the wrong sample rate so check and resample - then convert */
-  /* narrowband targets */
   switch( pt ) {
-    case ILBCPAYLOADTYPE: {
-      this->requirenarrowband();
-      this->l16toilbc();
-      return this->ilbcref;
-    }
-    case G722PAYLOADTYPE: {
-      this->requirewideband();
-      this->l16tog722();
-
-      return this->g722ref;
-    }
-    case PCMAPAYLOADTYPE: {
-      if( !this->pcmuref.isdirty() && this->pcmuref.size() > 0 ) {
+    case PCMAPAYLOADTYPE:
+      if( this->pcmaref.hasdata() ) return this->pcmaref;
+      if( this->pcmuref.hasdata() ) {
         this->ulaw2alaw();
       } else {
         this->requirenarrowband();
         this->l16topcma();
       }
       return this->pcmaref;
-    }
-    case PCMUPAYLOADTYPE: {
-      if( !this->pcmaref.isdirty() && this->pcmaref.size() > 0 ) {
+    case PCMUPAYLOADTYPE:
+      if( this->pcmuref.hasdata() ) return this->pcmuref;
+      if( this->pcmaref.hasdata() ) {
         this->alaw2ulaw();
       } else {
         this->requirenarrowband();
         this->l16topcmu();
       }
       return this->pcmuref;
-    }
-    case L168KPAYLOADTYPE: {
+    case ILBCPAYLOADTYPE:
+      if( this->ilbcref.hasdata() ) return this->ilbcref;
+      this->requirenarrowband();
+      this->l16toilbc();
+      return this->ilbcref;
+    case G722PAYLOADTYPE:
+      if( this->g722ref.hasdata() ) return this->g722ref;
+      this->requirewideband();
+      this->l16tog722();
+
+      return this->g722ref;
+    case L168KPAYLOADTYPE:
+      if( this->l168kref.hasdata() ) return this->l168kref;
       this->requirenarrowband();
       return this->l168kref;
-    }
-    case L1616KPAYLOADTYPE: {
+    case L1616KPAYLOADTYPE:
+      if( this->l1616kref.hasdata() ) return this->l1616kref;
       this->requirewideband();
       return this->l1616kref;
-    }
   }
 
   /* We should ever get here unless an invalid param has been passed in */
   std::cerr << "codecx::getref call with bad pt: " << pt << std::endl;
-  return this->pcmuref;
+  return nullref;
 }
 
 /*

package/src/projectrtpnodemain.cpp

@@ -1,6 +1,9 @@
 
 #ifdef NODE_MODULE
 
+/* needed to build on ubuntu */
+#include <utility>
+
 #include <node_api.h>
 #include <string>
 #include <vector>

package/src/projectrtppacket.cpp

@@ -1,4 +1,7 @@
 
+/* needed to build on ubuntu */
+#include <utility>
+
 #include <iostream>
 #include <cstdlib>
 #include  <iomanip>

package/src/projectrtprawsound.cpp

@@ -1,4 +1,7 @@
 
+/* needed to build on ubuntu */
+#include <utility>
+
 #include <iostream>   // cerr
 #include <cstdlib>
 #include <iomanip>
@@ -93,21 +96,13 @@ void rawsound::frompt( int payloadtype )
     case L168KPAYLOADTYPE:
     {
       this->samplerate = 8000;
-      if( 1 == this->bytespersample )
-      {
-        this->bytespersample = 2;
-        this->samples = this->samples / 2;
-      }
+      this->bytespersample = 2;
       break;
     }
     case L1616KPAYLOADTYPE:
     {
       this->samplerate = 16000;
-      if( 1 == this->bytespersample )
-      {
-        this->bytespersample = 2;
-        this->samples = this->samples / 2;
-      }
+      this->bytespersample = 2;
       break;
     }
   }
@@ -225,7 +220,31 @@ void rawsound::malloc( size_t samplecount, size_t bytespersample, int format ) {
 
     delete[] this->data;
   }
-  this->data = new uint8_t[ requiredsize ];
+
+  /* make sure data is aligned as ARM and others can throw SIGSEGV on misalignment */
+  switch( bytespersample ) {
+    case 1:
+    {
+      this->data = new uint8_t[ samplecount ];
+      break;
+    }
+    case 2:
+    {
+      this->data = ( uint8_t * ) new uint16_t[ samplecount ];
+      break;
+    }
+    case 4:
+    {
+      this->data = ( uint8_t * ) new uint32_t[ samplecount ];
+      break;
+    }
+    default:
+    {
+      /* this shouldn't happen - in fact - please avoid */
+      this->data = new uint8_t[ requiredsize ];
+    }
+  }
+  
   this->allocatedlength = requiredsize;
 }
 

package/src/projectrtprawsound.h

@@ -26,12 +26,14 @@ public:
   void malloc( size_t samplecount, size_t bytespersample, int format );
   void zero( void );
 
+  bool hasdata() { return this->size() != 0 && !this->isdirty(); }
+
   /* needed for << operato on codecx */
   inline int getpayloadtype( void ) { return this->format; }
   inline void setpayloadlength( size_t length ) { this->samples = length; };
   inline void setlength( size_t length ) { this->samples = length; };
   inline bool isdirty( void ) { return this->dirtydata; }
-  inline void dirty( bool d = true ) { this->dirtydata = d; }
+  inline void dirty( bool d = true ) { this->dirtydata = d; if( d && 0 == allocatedlength ) data = nullptr; }
   void copy( uint8_t *src, size_t len );
   void copy( rawsound &other );