@babblevoice/projectrtp 2.5.26 → 2.5.28

package/README.md

@@ -60,7 +60,7 @@ If you wish to build outsode of a Docker image, there are npm target scripts for
 
 ```bash
 docker buildx prune
-docker buildx build --platform linux/amd64,linux/arm64 -t tinpotnick/projectrtp:2.5.23_beta4 . --push
+docker buildx build --platform linux/amd64,linux/arm64 -t tinpotnick/projectrtp:2.5.27 . --push
 ```
 
 ## Example scripts

package/lib/server.js

@@ -4,9 +4,10 @@ const net = require( "net" )
 const { v4: uuidv4 } = require( "uuid" )
 
 const EventEmitter = require( "events" )
-
 const message = require( "./message" )
 
+const opentimeout = 5000
+
 /**
  * Node host address and port object
  * @typedef { object } nodehost
@@ -105,12 +106,36 @@ class channel {
    */
   openresolve
 
+  /** 
+   * @private
+   * @type { function } 
+   */
+  closeresolve
+
   /** 
    * @private
    * @type { function } 
    */
   openreject
 
+  /** 
+   * @private
+   * @type { function } 
+   */
+  closereject
+
+  /** 
+   * @private
+   * @type { NodeJS.Timeout }
+   */
+  opentimer
+
+  /** 
+   * @private
+   * @type { NodeJS.Timeout }
+   */
+  closetimer
+
   /** 
    * Array of messages sent to and from the remote end.
    * @type { Array< any > } 
@@ -206,14 +231,15 @@ class channel {
   }
 
   /**
-   * Creates a new channel which connects to a remote rtp node.
+   * Connects to a RTP server then creates channel
    * @param { object } options
    * @param { channelcallback } cb
    * @param { function } openresolve
+   * @param { function } openreject
    * @returns { Promise< channel > } - resolves when the connection is connected
    * @internal
    */
-  static _createforconnect( options, cb, openresolve /* openreject do something with me */ ) {
+  static _createforconnect( options, cb, openresolve, openreject ) {
 
     const newchannel = new channel( options.id )
     if( cb ) newchannel.em.on( "all", cb )
@@ -228,6 +254,9 @@ class channel {
         "type": nodeconnectiontype.connect
       }
 
+      newchannel.openresolve = openresolve
+      newchannel.openreject = openreject
+
       newchannel.connection.sock.setKeepAlive( true )
       newchannel.channels = [ newchannel ]
 
@@ -236,6 +265,15 @@ class channel {
         if ( connectresolve ) connectresolve( newchannel )
       } )
 
+      newchannel.opentimer = setTimeout( () => {
+        if( newchannel.openreject ) {
+          newchannel.openreject()
+          delete newchannel.openresolve
+          delete newchannel.openreject
+          delete newchannel.opentimer
+        }
+      }, opentimeout )
+
       const state = message.newstate()
       newchannel.connection.sock.on( "data", ( data ) => {
         message.parsemessage( state, data, ( /** @type { object } */ receivedmsg ) => {
@@ -248,8 +286,6 @@ class channel {
           if( receivedmsg && receivedmsg.status && receivedmsg.status.instance ) {
             newchannel.connection.instance = receivedmsg.status.instance
           }
-
-          if ( openresolve ) openresolve( newchannel )
         } )
       } )
 
@@ -259,6 +295,16 @@ class channel {
       } )
 
       newchannel.connection.sock.on( "close", () => {
+        newchannel.channels.forEach( chnl => {
+          channels.delete( chnl.id )
+          if( chnl.openreject ) {
+            chnl.openreject()
+            clearTimeout( chnl.opentimer )
+            delete chnl.openresolve
+            delete chnl.openreject
+            delete chnl.opentimer
+          }
+        } )
       } )
     } )
   }
@@ -294,7 +340,17 @@ class channel {
       newchannel.channels = this.channels
       newchannel.channels.push( newchannel )
       newchannel.openresolve = resolve
+      newchannel.openreject = reject
       newchannel._write( options )
+
+      newchannel.opentimer = setTimeout( () => {
+        if( newchannel.openreject ) {
+          newchannel.openreject()
+          delete newchannel.openresolve
+          delete newchannel.openreject
+          delete newchannel.opentimer
+        }
+      }, opentimeout )
     } )
 
     return resolvepromise
@@ -314,12 +370,24 @@ class channel {
   }
 
   /**
-   * @summary Close the channel
+   * Closes the channel. It might throw a timeout error if the channel is not closed within 5 seconds.
+   * @param { object } [ options ]
+   * @param { number } [ options.timeout ] - different timeout to wait
+   * @returns { Promise< object > }
    */
-  close() {
+  close( options ) {
 
-    /* any outstanding to remove where unmix was not called first? */
-    //this._removebridge()
+    let timeout = opentimeout
+    if( options && options.timeout ) timeout = options.timeout
+
+    this.closetimer = setTimeout( () => {
+      if( this.closereject ) {
+        this.closereject()
+        delete this.closereject
+        delete this.closeresolve
+        delete this.closetimer
+      }
+    }, timeout )
     
     /* close us */
     this._write( {
@@ -327,11 +395,18 @@ class channel {
       "uuid": this.uuid
     } )
 
-    if( this.openresolve ) {
-      this.openresolve()
+    if( this.openreject ) {
+      this.openreject()
+      clearTimeout( this.opentimer )
       delete this.openresolve
       delete this.openreject
+      delete this.opentimer
     }
+
+    return new Promise( ( resolve, reject ) => {
+      this.closeresolve = resolve
+      this.closereject = reject
+    } )
   }
 
   /**
@@ -354,142 +429,6 @@ class channel {
     return true
   }
 
-  /**
-   * Add _bridge object to both channel
-   * @param { object } other - other channel
-   * @returns { void }
-   */
-  _createbridges( other ) {
-
-    if( !this._bridge && !other._bridge ) {
-      this._bridge = other._bridge = {
-        "bridges": [],
-        "main": this.connection.instance
-      }
-    }
-
-    if( !this._bridge && other._bridge ) this._bridge = other._bridge
-    if( this._bridge && !other._bridge ) other._bridge = this._bridge
-
-    if( this._bridge !== other._bridge )
-      throw new Error( "some complex mixing occured and this function needs finishing" )
-  }
-
-  /**
-   * Any channels which have been mixed we create an
-   * object common to both channels so we can keep track of channels which 
-   * require tidyin up. We try to maintain a star shaped network.
-   * In the example diagram, the out mix method mixes between phone1 and this
-   * and phone2 and other. 
-   * Markdown (mermaid)
-      graph TD
-        this -->|rtp - our created bridge to link the 2 remote channels| other
-        other --> this
-
-        phone1 --> this
-        this --> phone1
-
-        phone2 --> other
-        other --> phone2
-   * @private
-   * @param { object } other - other channel
-   * @returns { Promise< boolean > }
-   */
-  async _addbridge( other ) {
-
-    let leftid = this.connection.instance
-    const rightid = other.connection.instance
-
-    this._createbridges( other )
-
-    /* nothing more to do if we are on the same node */
-    if( rightid === leftid ) return false
-
-    /* It might have changed now we have linked them up */
-    leftid = this._bridge.main
-
-    let found = false
-    for( const bridge of this._bridge.bridges ) {
-      if( ( bridge.left.connection.instance === leftid || bridge.right.connection.instance === leftid ) &&
-          ( bridge.left.connection.instance === rightid || bridge.right.connection.instance === rightid ) ) {
-        found = true
-        bridge.channels.add( this )
-        bridge.channels.add( other )
-
-        this.mix( bridge.left )
-        other.mix( bridge.right )
-      }
-    }
-
-    if( found ) return
-
-    const bridge = {
-      /* TODO: this will need reworking with to support reverse connection types */
-      "left": await serverinterface.get().openchannel( { "nodeinstance": leftid } ),
-      "right": await serverinterface.get().openchannel( { "nodeinstance": rightid } ),
-      "channels": new Set( [ this, other ] )
-    }
-
-    const addressleft = bridge.left.local.privateaddress || bridge.left.local.address
-    const addressright = bridge.right.local.privateaddress || bridge.right.local.address
-    const g722 = 9
-
-    bridge.left.remote( { "address": addressright, "port": bridge.right.local.port, "codec": g722 } )
-    bridge.right.remote( { "address": addressleft, "port": bridge.left.local.port, "codec": g722 } )
-
-    this._bridge.bridges.push( bridge )
-
-    this._write( {
-      "channel": "mix",
-      "other": {
-        "id": bridge.left.id,
-        "uuid": bridge.left.uuid
-      }
-    } )
-
-    other._write( {
-      "channel": "mix",
-      "other": {
-        "id": bridge.right.id,
-        "uuid": bridge.right.uuid
-      }
-    } )
-
-    return true
-  }
-
-  /**
-   * We check if we are a remote node (i.e.. not the centre of the star)
-   * then we close down the link between the two.
-   * @private
-   * @returns { boolean }
-   */
-  _removebridge() {
-
-    /* no remote bridges have been created */
-    if( !this._bridge || !this._bridge.main ) return
-
-    const usid = this.connection.instance
-
-    /* The centre of star cannot remove from the network until last man standing */
-    if( usid == this._bridge.main ) return
-
-    this._bridge.bridges = this._bridge.bridges.filter( ( bridge ) => {
-      bridge.channels.delete( this )
-
-      if( 2 > bridge.channels.size ) {
-
-        bridge.left._write( { "channel": "unmix" } )
-        bridge.left._write( { "channel": "unmix" } )
-
-        bridge.left.close()
-        bridge.right.close()
-        return false /* remove */
-      }
-      return true /* keep */
-    } )
-  }
-
   /**
   @summary Removes us from an existing mix
   @returns { boolean }
@@ -592,6 +531,7 @@ class channel {
   }
 
   /**
+   * We have received teh open confirm message so we should action it
    * @private
    * @param { object } msg
    * @returns { boolean } - is further processing required
@@ -605,33 +545,50 @@ class channel {
 
     if( !this.openresolve ) return true
     this.openresolve( this )
+    clearTimeout( this.opentimer )
     delete this.openresolve
     delete this.openreject
+    delete this.opentimer
 
     return true
   }
 
   /**
-   * 
+   * We have received a close message so we should action it
+   * @param { object } msg
    * @returns { void }
    * @private
    */
-  _runclose() {
-    if( undefined !== this.openresolve ) {
-      this.openresolve()
+  _runclose( msg ) {
+    if( this.openreject ) {
+      this.openreject()
+      clearTimeout( this.opentimer )
       delete this.openresolve
       delete this.openreject
+      delete this.opentimer
+    }
+
+    if( this.closeresolve ) {
+      this.closeresolve( msg )
+      clearTimeout( this.closetimer )
+      delete this.closeresolve
+      delete this.closereject
+      delete this.closetimer
     }
 
+    this.#cleanupsharedchannels()
+    channels.delete( this.id )
+  }
+
+  #cleanupsharedchannels() {
     if( this.channels ) { 
       // adjust with filter
       const index = this.channels.indexOf( this )
       if( -1 < index ) this.channels.splice( index, 1 )
-      if( 0 === this.channels.length && this.connection.sock ) this.connection.sock.destroy()
+      if( 0 === this.channels.length && this.connection.sock ) {
+        this.connection.sock.destroy()
+      }
     }
-
-
-    channels.delete( this.id )
   }
 
   /**
@@ -647,7 +604,7 @@ class channel {
     this.em.emit( "all", msg )
     this.em.emit( msg.action, msg )
 
-    if( "close" == msg.action ) this._runclose()
+    if( "close" == msg.action ) this._runclose( msg )
   }
 
   /**
@@ -772,9 +729,9 @@ class rtpserver {
       request.channel = "open"
   
       const node = randomenode( options.nodeinstance )
-  
+
       if ( 0 < nodes.size ) channel._createforlisten( request, node, callback, resolve, reject )
-      else channel._createforconnect( request, callback, resolve )
+      else channel._createforconnect( request, callback, resolve, reject )
 
     } )
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babblevoice/projectrtp",
-  "version": "2.5.26",
+  "version": "2.5.28",
   "description": "A scalable Node addon RTP server",
   "main": "index.js",
   "directories": {

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,63 @@ 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 ) {
+    this->badsocketopen( "failed to bind rtp socket" );
+    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 ) {
+    this->badsocketopen( "failed to bind rtcp socket" );
     return;
   }
 
@@ -333,11 +409,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 +445,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 +685,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 +894,7 @@ void projectrtpchannel::correctaddress( void ) {
   if( this->autoadjust ) {
     this->confirmedrtpsenderendpoint = this->rtpsenderendpoint;
     this->remoteconfirmed = true;
+    this->hardtickswithnortpcount = 0;
     this->autoadjust = false;
   }
 }
@@ -905,6 +998,7 @@ void projectrtpchannel::readsomertp( void ) {
         */
 
         this->tickswithnortpcount = 0;
+        this->hardtickswithnortpcount = 0;
 
         /* dynamic payload types */
         auto pt = buf->getpayloadtype();
@@ -1168,15 +1262,18 @@ 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();
@@ -1184,9 +1281,10 @@ void projectrtpchannel::senddtmf( void ) {
   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 ] = volume; /* end of event & reserved & volume */
+  tmp = ( uint16_t * ) &pl[ 2 ]; /* event duration */
+  *tmp = htons( 320 );
+
   this->writepacket( dst );
 
   dst = this->gettempoutbuf();
@@ -1194,9 +1292,44 @@ 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 ] = 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;
@@ -1928,10 +2061,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 +2078,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 +2325,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 +2356,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;

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 )