@babblevoice/projectrtp 2.5.26 → 2.5.29

package/src/projectrtpbuffer.cpp

@@ -53,7 +53,21 @@ Returns the next packet in order - does not modify our structure.
 rtppacket* rtpbuffer::peek( void ) {
   if( nullptr != this->peekedpopped ) return this->peekedpopped;
   uint16_t bufindex = this->outsn % this->buffercount;
-  this->peekedpopped = this->orderedrtpdata.at( bufindex );
+  rtppacket *out = this->orderedrtpdata.at( bufindex );
+
+  if( out == nullptr ) {
+    this->outsn++;
+    return nullptr;
+  }
+
+  if( out->getsequencenumber() != this->outsn ) {
+    this->orderedrtpdata.at( this->outsn % this->buffercount ) = nullptr;
+    this->availablertpdata.push( out );
+    this->badsn++;
+    return nullptr;
+  }
+
+  this->peekedpopped = out;
   return this->peekedpopped;
 }
 
@@ -72,7 +86,7 @@ rtppacket* rtpbuffer::poppeeked( void ) {
     this->availablertpdata.push( out );
   }
 
-  if( out->getsequencenumber() != oldsn ) return nullptr;
+  this->popped++;
   return out;
 }
 
@@ -81,25 +95,9 @@ Returns the next packet in order.
 */
 rtppacket* rtpbuffer::pop( void ) {
   rtppacket *out = this->peek();
-  uint16_t oldsn = this->outsn;
-  this->outsn++;
-
-  this->peekedpopped = nullptr;
   if( nullptr == out ) return nullptr;
+  this->poppeeked();
 
-  uint16_t bufindex = oldsn % this->buffercount;
-  if( nullptr != this->orderedrtpdata.at( bufindex ) ) {
-    this->orderedrtpdata.at( bufindex ) = nullptr;
-    this->availablertpdata.push( out );
-  }
-
-  auto outsn = out->getsequencenumber();
-  if( outsn != oldsn ) {
-    this->badsn++;
-    return nullptr;
-  }
-
-  this->popped++;
   return out;
 }
 

package/src/projectrtpbuffer.h

@@ -48,6 +48,7 @@ public:
                          int waterlevel = BUFFERPACKETCAP /* the level we build up before allowing a read */ );
 
   rtppacket* peek( void );
+  rtppacket* peeked( void ) { return this->peekedpopped; }
   rtppacket* poppeeked( void );
   rtppacket* pop( void );
   void push( void );

package/src/projectrtpchannel.cpp

@@ -19,7 +19,49 @@
 extern boost::asio::io_context workercontext;
 std::queue < unsigned short >availableports;
 std::atomic_bool availableportslock( false );
-uint32_t channelscreated = 0;
+
+std::atomic< std::uint32_t > channelscreated{ 0 };
+
+/**
+ * Get the next available port.
+ */
+unsigned short getavailableport( void ) {
+  AQUIRESPINLOCK( availableportslock );
+  auto ourport = availableports.front();
+  availableports.pop();
+  RELEASESPINLOCK( availableportslock );
+
+  channelscreated.fetch_add( 1 );
+
+  return ourport;
+}
+
+/**
+ * Returns the number of ports we still have available.
+ * @returns { size_t }
+ */
+auto getvailableportsize() {
+  AQUIRESPINLOCK( availableportslock );
+  auto availableportssize = availableports.size();
+  RELEASESPINLOCK( availableportslock );
+
+  return availableportssize;
+}
+
+/**
+ * Return a port number to the available list (to the back) and clear our value
+ * so we cannot return it twice.
+ */
+void projectrtpchannel::returnavailableport( void ) {
+
+  if( 0 == this->port ) return;
+  AQUIRESPINLOCK( availableportslock );
+  availableports.push( this->port );
+  this->port = 0;
+  RELEASESPINLOCK( availableportslock );
+
+  channelscreated.fetch_sub( 1 );
+}
 
 /* useful for random string generation */
 const char alphanumsecret[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
@@ -53,6 +95,7 @@ projectrtpchannel::projectrtpchannel( unsigned short port ):
   totalticktime( 0 ),
   totaltickcount( 0 ),
   tickswithnortpcount( 0 ),
+  hardtickswithnortpcount( 0 ),
   outpkwritecount( 0 ),
   outpkcount( 0 ),
   outpkskipcount( 0 ),
@@ -107,8 +150,6 @@ projectrtpchannel::projectrtpchannel( unsigned short port ):
   lastdtmfsn( 0 ),
   tickstarttime() {
 
-  channelscreated++;
-
   gnutls_rnd( GNUTLS_RND_RANDOM, &this->ssrcout, 4 );
 
   char localicepwd[ 25 ];
@@ -241,6 +282,7 @@ void projectrtpchannel::handleremoteresolve (
 
   this->confirmedrtpsenderendpoint = *it;
   this->remoteconfirmed = true;
+  this->hardtickswithnortpcount = 0;
 
   /* allow us to re-auto correct */
   this->autoadjust = true;
@@ -264,29 +306,65 @@ uint32_t projectrtpchannel::requestopen( void ) {
   return this->ssrcout;
 }
 
+/**
+ * handle errors on socket open
+*/
+void projectrtpchannel::badsocketopen( const char *err ) {
+
+  fprintf( stderr, "Socket issue - refusing a new channel: %s\n", err );
+
+  if( this->rtpsocket.is_open()  ) {
+    this->rtpsocket.close();
+  }
+
+  if( !this->rtcpsocket.is_open() ) {
+    this->rtcpsocket.close();
+  }
+
+  this->returnavailableport();
+
+  postdatabacktojsfromthread( shared_from_this(), "close", "error.nosocket" );
+}
+
 /**
  * Must be called in the workercontext.
  */
 void projectrtpchannel::doopen( void ) {
 
+  boost::system::error_code ec;
+
   this->outcodec.reset();
   this->incodec.reset();
 
-  boost::asio::socket_base::reuse_address reuseoption( true );
-  this->rtpsocket.open( boost::asio::ip::udp::v4() );
-  this->rtpsocket.set_option( reuseoption );
+  this->rtpsocket.open( boost::asio::ip::udp::v4(), ec );
+
+  if( ec ) {
+    this->badsocketopen( "failed to open rtp socket" );
+    return;
+  }
+
   this->rtpsocket.bind( boost::asio::ip::udp::endpoint(
-      boost::asio::ip::udp::v4(), this->port ) );
+      boost::asio::ip::udp::v4(), this->port ), ec );
+
+  if( ec ) {
+    auto err = std::string( "failed to bind rtp socket: " ) + std::to_string( this->port ) + std::string( ": " ) + ec.message();
+    this->badsocketopen( err.c_str() );
+    return;
+  }
+
+  this->rtcpsocket.open( boost::asio::ip::udp::v4(), ec );
+
+  if( ec ) {
+    this->badsocketopen( "failed to open rtcp socket" );
+    return;
+  }
 
-  this->rtcpsocket.open( boost::asio::ip::udp::v4() );
-  this->rtcpsocket.set_option( reuseoption );
   this->rtcpsocket.bind( boost::asio::ip::udp::endpoint(
-      boost::asio::ip::udp::v4(), this->port + 1 ) );
+      boost::asio::ip::udp::v4(), this->port + 1 ), ec );
 
-  if( !this->rtpsocket.is_open() || !this->rtcpsocket.is_open() ) {
-    fprintf( stderr, "No more sockets available - refusing a new channel\n" );
-    this->requestclose( "error.nosocket" );
-    this->doclose();
+  if( ec ) {
+    auto err = std::string( "failed to bind rtcp socket: " ) + std::to_string( this->port + 1 ) + std::string( ": " ) + ec.message();
+    this->badsocketopen( err.c_str() );
     return;
   }
 
@@ -333,11 +411,15 @@ void projectrtpchannel::requestecho( bool e ) {
   this->doecho = e;
 }
 
+/**
+ * Worker thread to perform teh close. It will only run if the channel has
+ * been active (i.e. the sockets have been opened sucsessfully)
+ */
 void projectrtpchannel::doclose( void ) {
 
   if( !this->active ) return;
-
   this->active = false;
+
   this->tick.cancel();
 
   if( nullptr != this->player ) {
@@ -365,25 +447,30 @@ void projectrtpchannel::doclose( void ) {
   this->rtpsocket.close();
   this->rtcpsocket.close();
 
-  AQUIRESPINLOCK( availableportslock );
-  availableports.push( this->getport() );
-  RELEASESPINLOCK( availableportslock );
-
-  channelscreated--;
+  this->returnavailableport();
 
   postdatabacktojsfromthread( shared_from_this(), "close", this->closereason );
 }
 
 bool projectrtpchannel::checkidlerecv( void ) {
   if( this->recv && this->active ) {
-    this->tickswithnortpcount++;
-    if( this->tickswithnortpcount > ( 50 * 20 ) ) { /* 50 (@20mS ptime)/S = 20S */
+
+    this->hardtickswithnortpcount++;
+    if( this->remoteconfirmed ) {
+
+      this->tickswithnortpcount++;
+      if( this->tickswithnortpcount > ( 50 * 20 ) ) { /* 50 (@20mS ptime)/S = 20S */
+        this->closereason = "idle";
+        this->doclose();
+        return true;
+        }
+    
+    } else if( this->hardtickswithnortpcount > ( 50 * 60 * 60 ) ) { /* 1hr hard timeout */
       this->closereason = "idle";
       this->doclose();
       return true;
     }
   }
-
   return false;
 }
 
@@ -600,20 +687,27 @@ void projectrtpchannel::removeoldrecorders( void ) {
 
       if( rec->requestfinish ) {
         rec->completed = true;
+        rec->maxsincestartpower = 0;
         postdatabacktojsfromthread( shared_from_this(), "record", rec->file, "finished.requested" );
         continue;
       }
 
-      if( rec->finishbelowpower > 0 ) {
-        if( rec->lastpowercalc < rec->finishbelowpower ) {
-          rec->completed = true;
-          postdatabacktojsfromthread( shared_from_this(), "record", rec->file, "finished.belowpower" );
-          continue;
-        }
+      if( rec->lastpowercalc > rec->maxsincestartpower ) {
+        rec->maxsincestartpower = rec->lastpowercalc;
+      }
+
+      if( rec->finishbelowpower > 0 &&
+          rec->maxsincestartpower > rec->finishbelowpower &&
+          rec->lastpowercalc < rec->finishbelowpower ) {
+        rec->completed = true;
+        rec->maxsincestartpower = 0;
+        postdatabacktojsfromthread( shared_from_this(), "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" );
         continue;
       }
@@ -802,6 +896,7 @@ void projectrtpchannel::correctaddress( void ) {
   if( this->autoadjust ) {
     this->confirmedrtpsenderendpoint = this->rtpsenderendpoint;
     this->remoteconfirmed = true;
+    this->hardtickswithnortpcount = 0;
     this->autoadjust = false;
   }
 }
@@ -905,6 +1000,7 @@ void projectrtpchannel::readsomertp( void ) {
         */
 
         this->tickswithnortpcount = 0;
+        this->hardtickswithnortpcount = 0;
 
         /* dynamic payload types */
         auto pt = buf->getpayloadtype();
@@ -1168,25 +1264,52 @@ void projectrtpchannel::senddtmf( void ) {
     return;
   }
 
+  const char volume = 15;
+  const char endofevent = 0x80;
+
   rtppacket *dst = this->gettempoutbuf();
   dst->setpayloadtype( this->rfc2833pt );
-  dst->setmarker();
   dst->setpayloadlength( 4 );
   uint8_t *pl =  dst->getpayload();
   pl[ 0 ] = tosend;
-  pl[ 1 ] = 10; /* end of event & reserved & volume */
-  pl[ 2 ] = 0; /* event duration high */
-  pl[ 3 ] = 160; /* event duration */
+  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 ] = 10; /* end of event & reserved & volume */
-  pl[ 2 ] = 0; /* event duration high */
-  pl[ 3 ] = 160; /* event duration */
+  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();
@@ -1194,9 +1317,21 @@ void projectrtpchannel::senddtmf( void ) {
   dst->setpayloadlength( 4 );
   pl =  dst->getpayload();
   pl[ 0 ] = tosend;
-  pl[ 1 ] = 0x80 | 10; /* end of event & reserved & volume */
-  pl[ 2 ] = 0; /* event duration high */
-  pl[ 3 ] = 160; /* event duration */
+  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;
@@ -1928,10 +2063,6 @@ static napi_value channelcreate( napi_env env, napi_callback_info info ) {
   napi_value nremote;
 
   napi_value result;
-  AQUIRESPINLOCK( availableportslock );
-  auto ourport = availableports.front();
-  availableports.pop();
-  RELEASESPINLOCK( availableportslock );
 
   size_t bytescopied;
 
@@ -1949,7 +2080,7 @@ static napi_value channelcreate( napi_env env, napi_callback_info info ) {
     return NULL;
   }
 
-  projectrtpchannel::pointer p = projectrtpchannel::create( ourport );
+  projectrtpchannel::pointer p = projectrtpchannel::create( getavailableport() );
 
   /* optional - remote */
   dtlssession::mode dtlsmode = dtlssession::none;
@@ -2196,7 +2327,7 @@ nodtls:
   if( napi_ok != napi_create_object( env, &nlocal ) ||
       napi_ok != napi_set_named_property( env, result, "local", nlocal ) ||
 
-      napi_ok != napi_create_int32( env, ourport, &nourport ) ||
+      napi_ok != napi_create_int32( env, p->getport(), &nourport ) ||
       napi_ok != napi_set_named_property( env, nlocal, "port", nourport ) ||
 
       napi_ok != napi_create_uint32( env, ssrc, &nssrc ) ||
@@ -2227,12 +2358,8 @@ void getchannelstats( napi_env env, napi_value &result ) {
 
   napi_value av, chcount;
 
-  AQUIRESPINLOCK( availableportslock );
-  auto availableportssize = availableports.size();
-  RELEASESPINLOCK( availableportslock );
-
-  if( napi_ok != napi_create_double( env, availableportssize, &av ) ) return;
-  if( napi_ok != napi_create_double( env, channelscreated, &chcount ) ) return;
+  if( napi_ok != napi_create_double( env, getvailableportsize(), &av ) ) return;
+  if( napi_ok != napi_create_double( env, channelscreated.load(), &chcount ) ) return;
 
   if( napi_ok != napi_set_named_property( env, channel, "available", av ) ) return;
   if( napi_ok != napi_set_named_property( env, channel, "current", chcount ) ) return;
@@ -2241,10 +2368,12 @@ void getchannelstats( napi_env env, napi_value &result ) {
 void initrtpchannel( napi_env env, napi_value &result, int32_t startport, int32_t endport ) {
   napi_value ccreate;
 
+  AQUIRESPINLOCK( availableportslock );
   while(!availableports.empty()) availableports.pop();
   for( int i = (int) startport; i < (int) endport; i = i + 2 ) {
     availableports.push( i );
   }
+  RELEASESPINLOCK( availableportslock );
 
   if( napi_ok != napi_create_function( env, "exports", NAPI_AUTO_LENGTH, channelcreate, nullptr, &ccreate ) ) return;
   if( napi_ok != napi_set_named_property( env, result, "openchannel", ccreate ) ) return;

package/src/projectrtpchannel.h

@@ -133,6 +133,7 @@ public:
   std::atomic_uint64_t totalticktime;
   std::atomic_uint64_t totaltickcount;
   std::atomic_uint16_t tickswithnortpcount;
+  std::atomic_uint16_t hardtickswithnortpcount;
 
   std::atomic_uint64_t outpkwritecount;
   std::atomic_uint64_t outpkcount;
@@ -220,6 +221,9 @@ private:
   static bool recordercompleted( const channelrecorder::pointer& value );
   void dounmix( void );
 
+  void badsocketopen( const char *err );
+  void returnavailableport( void );
+
   std::atomic_bool mixerlock;
   projectchannelmuxptr mixer;
   std::atomic_bool mixing;

package/src/projectrtpchannelmux.cpp

@@ -60,6 +60,8 @@ void projectchannelmux::mixall( void ) {
       src = chan->inbuff->peek();
       RELEASESPINLOCK( chan->rtpbufferlock );
 
+      if( nullptr == src ) break;
+
       AQUIRESPINLOCK( chan->rtpdtlslock );
       dtlssession::pointer currentdtlssession = chan->rtpdtls;
       RELEASESPINLOCK( chan->rtpdtlslock );
@@ -68,6 +70,11 @@ void projectchannelmux::mixall( void ) {
         if( !currentdtlssession->unprotect( src ) ) {
           chan->receivedpkskip++;
           src = nullptr;
+          
+          AQUIRESPINLOCK( chan->rtpbufferlock );
+          chan->inbuff->poppeeked();
+          RELEASESPINLOCK( chan->rtpbufferlock );
+          break;
         }
       }
 
@@ -93,7 +100,12 @@ void projectchannelmux::mixall( void ) {
 
   /* Now we subtract this channel to send to this channel. */
   for( auto& chan: this->channels ) {
-    if( !chan->send ) continue;
+    if( !chan->send ) {
+      AQUIRESPINLOCK( chan->rtpbufferlock );
+      chan->inbuff->poppeeked();
+      RELEASESPINLOCK( chan->rtpbufferlock );
+      continue;
+    }
 
     rtppacket *dst = chan->gettempoutbuf();
 
@@ -102,7 +114,7 @@ void projectchannelmux::mixall( void ) {
 
     if( chan->recv ) {
       AQUIRESPINLOCK( chan->rtpbufferlock );
-      rtppacket *src = chan->inbuff->peek();
+      rtppacket *src = chan->inbuff->peeked();
       RELEASESPINLOCK( chan->rtpbufferlock );
       if( nullptr != src ) {
         this->subtracted -= chan->incodec;
@@ -136,6 +148,8 @@ void projectchannelmux::mix2( void ) {
     src = chan1->inbuff->pop();
     RELEASESPINLOCK( chan1->rtpbufferlock );
 
+    if( nullptr == src ) break;
+
     AQUIRESPINLOCK( chan1->rtpdtlslock );
     dtlssession::pointer currentdtlssession = chan1->rtpdtls;
     RELEASESPINLOCK( chan1->rtpdtlslock );
@@ -144,6 +158,7 @@ void projectchannelmux::mix2( void ) {
       if( !currentdtlssession->unprotect( src ) ) {
         chan1->receivedpkskip++;
         src = nullptr;
+        break;
       }
     }
 
@@ -157,6 +172,8 @@ void projectchannelmux::mix2( void ) {
     src = chan2->inbuff->pop();
     RELEASESPINLOCK( chan2->rtpbufferlock );
 
+    if( nullptr == src ) break;
+
     AQUIRESPINLOCK( chan2->rtpdtlslock );
     dtlssession::pointer currentdtlssession = chan2->rtpdtls;
     RELEASESPINLOCK( chan2->rtpdtlslock );
@@ -165,6 +182,7 @@ void projectchannelmux::mix2( void ) {
       if( !currentdtlssession->unprotect( src ) ) {
         chan2->receivedpkskip++;
         src = nullptr;
+        break;
       }
     }
 

package/src/projectrtpchannelrecorder.cpp

@@ -12,6 +12,7 @@ channelrecorder::channelrecorder( std::string file ) :
   file( file ),
   poweraveragepackets( 50 ),
   startabovepower( 0 ),
+  maxsincestartpower( 0 ),
   finishbelowpower( 0 ),
   minduration( 0 ),
   maxduration( 0 ),

package/src/projectrtpchannelrecorder.h

@@ -30,6 +30,7 @@ public:
   /* must have started for this to kick in */
   uint16_t startabovepower;
   /* must have started for this to kick in */
+  uint16_t maxsincestartpower;
   uint16_t finishbelowpower;
   /* used in conjunction with finishbelowpower */
   uint32_t minduration; /* mSeconds */

package/src/projectrtpcodecx.cpp

@@ -69,13 +69,14 @@ static const uint8_t alaw_to_ulaw_table[256] =
 };
 
 void gen711convertdata( void ) {
-  for( int32_t i = 0; i != 65535; i++ ) {
+  int32_t i;
+  for( i = 0; i != 65536; i++ ) {
     int16_t l16val = i - 32768;
     _l16topcmu[ i ] = linear_to_ulaw( l16val );
     _l16topcma[ i ] = linear_to_alaw( l16val );
   }
 
-  for( uint8_t i = 0; i != 255; i++ ) {
+  for( i = 0; i != 256; i++ ) {
     _pcmatol16[ i ] = alaw_to_linear( i );
     _pcmutol16[ i ] = ulaw_to_linear( i );
   }

package/test/interface/projectrtpdtmf.js

@@ -149,7 +149,7 @@ describe( "dtmf", function() {
 
 
   it( "single channel and request rtp server to send 2833", function( done ) {
-
+    /* TODO - check tre fuller structure of an RTP event (duration, volume, etc) */
     /* create our RTP/UDP endpoint */
     const server = dgram.createSocket( "udp4" )
     let dtmfpkcount = 0
@@ -182,7 +182,7 @@ describe( "dtmf", function() {
 
         if( "close" === d.action ) {
           server.close()
-          expect( dtmfpkcount ).to.equal( 2*3 )
+          expect( dtmfpkcount ).to.equal( 2*6 )
           done()
         }
       } )
@@ -263,7 +263,7 @@ describe( "dtmf", function() {
     clienta.close()
     clientb.close()
 
-    expect( dtmfpkcount ).to.equal( 3*3 )
+    expect( dtmfpkcount ).to.equal( 3*6 )
   } )
 
   it( "2 channels mixing and request rtp server to send 2833 to one with dynamic payloadtype", async function() {
@@ -331,7 +331,7 @@ describe( "dtmf", function() {
     clienta.close()
     clientb.close()
 
-    expect( dtmfpkcount ).to.equal( 3*3 )
+    expect( dtmfpkcount ).to.equal( 3*6 )
   } )
 
   it( "3 channels mixing and request rtp server to send 2833 to one", async function() {
@@ -414,7 +414,7 @@ describe( "dtmf", function() {
     clientb.close()
     clientc.close()
 
-    expect( dtmfpkcount ).to.equal( 5*3 )
+    expect( dtmfpkcount ).to.equal( 5*6 )
 
     await finished
   } )

package/test/interface/projectrtpmix.js

@@ -971,11 +971,11 @@ describe( "channel mix", function() {
     endpointb.close()
     endpointc.close()
 
-    expect( endpointapkcountzero ).to.be.within( 60, 75 )
-    expect( endpointbpkcountzero ).to.be.within( 60, 75 )
-    expect( endpointcpkcountzero ).to.be.within( 60, 75 )
-    expect( endpointapkcountnotzero ).to.be.within( 4, 12 )
-    expect( endpointbpkcountnotzero ).to.be.within( 4, 12 )
+    expect( endpointapkcountzero ).to.be.within( 55, 75 )
+    expect( endpointbpkcountzero ).to.be.within( 55, 75 )
+    expect( endpointcpkcountzero ).to.be.within( 55, 75 )
+    expect( endpointapkcountnotzero ).to.be.within( 4, 18 )
+    expect( endpointbpkcountnotzero ).to.be.within( 4, 18 )
     expect( endpointcpkcountnotzero ).to.be.below( 2 )
 
     await finished

package/test/interface/projectrtprecord.js

@@ -67,11 +67,13 @@ describe( "record", function() {
     this.timeout( 1500 )
     this.slow( 1200 )
 
+    let endclose = 0
     server.bind()
     server.on( "listening", async function() {
 
       channel = await prtp.projectrtp.openchannel( { "remote": { "address": "localhost", "port": server.address().port, "codec": 0 } }, function( d ) {
         if( "close" === d.action ) {
+          endclose = Date.now()
           server.close()
         }
       } )
@@ -89,6 +91,7 @@ describe( "record", function() {
     } )
 
     await new Promise( ( resolve ) => { setTimeout( () => resolve(), 1300 ) } )
+    const startclose = Date.now()
     channel.close()
     await new Promise( resolve => { server.on( "close", resolve ) } )
 
@@ -102,6 +105,7 @@ describe( "record", function() {
     expect( wavinfo.chunksize ).to.be.within( 28000, 33000 )
     expect( wavinfo.fmtchunksize ).to.equal( 16 )
     expect( wavinfo.subchunksize ).to.be.within( 28000, 33000 )
+    expect( endclose - startclose ).to.be.below( 100 )
 
     const ourfile = await fspromises.open( "/tmp/ourrecording.wav", "r" )
     const buffer = Buffer.alloc( 28204 )