@babblevoice/projectrtp 2.4.5 → 2.4.9

package/lib/node.js

@@ -22,6 +22,198 @@ const channelmap = {
   "direction": ( chan, msg ) => chan.direction( msg.options )
 }
 
+/**
+ * One for each connection spawned by rtpnode.
+ */
+class rtpnodeconnection {
+  constructor( parent, connection ) {
+    this.connectionid = uuidv4()
+    this.connection = connection
+    this.connectionlength = 0
+    this.mode = "listen"
+    this.parent = parent
+    this.messagestate = message.newstate()
+    this._reconnecttime = 500 /* mS */
+    this._destroying = false
+
+    // spawned from listen
+    if( connection ) {
+      connection.setKeepAlive( true )
+      connection.on( "data", this._onsocketdata.bind( this ) )
+    }
+  }
+
+  static create( parent, connection ) {
+    return new rtpnodeconnection( parent, connection )
+  }
+
+  destroy() {
+    this._destroying = true
+    if( this._reconnecttimerid ) {
+      clearTimeout( this._reconnecttimerid )
+      delete this._reconnecttimerid
+    }
+
+    this.connection.destroy()
+  }
+
+  _onsocketdata( data ) {
+    message.parsemessage( this.messagestate, data, ( msg ) => {
+      try {
+        this.parent._pre( msg, ( modifiedmsg ) => {
+          this._processmessage( modifiedmsg )
+        } )
+      } catch( e ) {
+        console.error( "Unhandled exception in babble-rtp", e )
+      }
+    } )
+  }
+
+  /**
+   * @private
+   * @param { object } msg
+   * @returns boolean
+   */
+  _updatechannel( msg ) {
+
+    if( undefined === msg.channel ) return false
+    if( undefined === msg.uuid ) return false
+
+    const chan = channels.get( msg.uuid )
+    if( undefined == chan ) return false
+
+    if( msg.channel in channelmap ) {
+      channelmap[ msg.channel ]( chan, msg )
+    } else {
+      const channelidentifiers = {
+        "id": msg.id,
+        "uuid": msg.uuid
+      }
+      this.send( { ...{ "error": "Unknown method" }, ...channelidentifiers } )
+    }
+
+    return true
+  }
+
+  /**
+   * 
+   * @param { object } msg 
+   * @returns { Promise< Boolean > }
+   */
+  async _processmessage( msg ) {
+    if( "open" == msg.channel ) return await this._openchannel( msg )
+
+    return this._updatechannel( msg )
+  }
+
+  /**
+   * Send a message back to the main server, include stats to help with load balancing.
+   * @param { object } msg
+   * @returns { void }
+   */
+  send( msg, cb = undefined ) {
+    this.parent._post( msg, ( modifiedmsg ) => {
+      if( this._destroying ) return
+      msg.status = this.parent.prtp.stats()
+      msg.status.instance = instance
+      this.connection.write( message.createmessage( modifiedmsg ) )
+      if (cb !== undefined) cb(msg)
+    } )
+  }
+
+
+  /**
+   * @private
+   * @param { object } msg
+   * @returns { Promise< Boolean > }
+   */
+  async _openchannel( msg ) {
+    this.connectionlength += 1
+    msg.forcelocal = true
+
+    const chan = await this.parent.prtp.openchannel( msg, ( cookie ) => {
+      // TODO: we might want to ensure the actual event has been written
+      // to the server before cleaning up the channel on our side?
+      this.send( { ...{ "id": chan.id, "uuid": chan.uuid }, ...cookie },
+        ( cookie ) => {
+          if ( "close" === cookie.action )  {
+            this.connectionlength -= 1
+            channels.delete( chan.uuid )
+
+            if( 0 == this.connectionlength && "listen" == this.mode ) {
+              this.parent.connections.delete( this.connectionid )
+              this.connection.destroy()
+            }
+          }
+        } )
+    } )
+    channels.set( chan.uuid, chan )
+    this.send( { ...chan, ...{ "action": "open" } } )
+
+    return true
+  }
+
+
+  /**
+   * @summary Connect to a server.
+   * @param {string} host
+   * @param {number} port
+   * @return {Promise} - Promise which resolves to an rtpnode
+  */
+  connect( host, port ) {
+    this.host = host
+    this.port = port
+    this.mode = "connect"
+
+    return new Promise( resolve => {
+
+      this.connection = net.createConnection( this.port, this.host )
+      this.connection.on( "data", this._onsocketdata.bind( this ) )
+
+      this.connection.setKeepAlive( true )
+
+      this.connection.on( "connect", () => {
+        this.send( {} )
+        resolve()
+        this._reconnecttime = 500 /* mS */
+      } )
+      
+      this.connection.on( "error", () => {
+        if( this._destroying ) return
+        this._runreconnect()
+      } )
+      this.connection.on( "close", () => {
+        if( this._destroying ) return
+        this._runreconnect()
+      } )
+    } )
+  }
+
+  /**
+   * @private
+   * @returns { void }
+   */
+  _reconnect() {
+    delete this._reconnecttimerid
+    this.connect( this.host, this.port )
+  }
+  
+  /**
+   * @private
+   * @returns { void }
+   */
+  _runreconnect() {
+    if( this._reconnecttimerid ) return
+    console.log( "Disconnected - trying to reconnect to " + this.host + ":" + this.port )
+
+    this._reconnecttimerid = setTimeout( this._reconnect.bind( this ), this._reconnecttime )
+
+    this._reconnecttime = this._reconnecttime * 2
+    if( this._reconnecttime > ( 1000 * 2 ) ) this._reconnecttime = this._reconnecttime / 2
+  }
+
+}
+
 /**
  * @summary An RTP node. We are a remote RTP node which waits for intruction from our server.
  */
@@ -38,7 +230,6 @@ class rtpnode {
     this.port = port
     this.instance = uuidv4()
     this.connections = new Map()
-    this.messagestate = message.newstate()
 
     /* pre callbacks are called when we receive an instruction from
     our server and we want to check if there is anything to do such as
@@ -50,42 +241,19 @@ class rtpnode {
     to our server - this is to, for example, upload a recording to a remote storage
     facility. */
     this._post = this._defaulthandler.bind( this )
-
-    /**
-     * @type { NodeJS.Timeout }
-     */
-    this._reconnecttimerid
   }
 
   /**
    * @summary Connect to a server.
-   * @param {number} port
    * @param {string} host
+   * @param {number} port
    * @return {Promise<rtpnode>} - Promise which resolves to an rtpnode
   */
-  connect( port, host ) {
-    this.host = host
-    this.port = port
-    this._destroying = false
-    this._reconnecttime = 500 /* mS */
-
-    return new Promise( resolve => {
-      this._onsocketreadypromiseresolve = resolve
-      const connection = net.createConnection( this.port, this.host )
-      this.connection = connection
-      this.connection.setKeepAlive( true )
-      this.connection.on( "connect", this._onsocketconnect.bind( this ) )
-      const con = {
-        connectionid: uuidv4(),
-        connection,
-        "connectionlength": 0,
-        "mode": "connect"
-      }
-      this.connections[ con.connectionid ] = con
-      this.connection.on( "data", this._onsocketdata.bind( this, con ) )
-      this.connection.on( "error", this._onsocketerror.bind( this ) )
-      this.connection.on( "close", this._onsocketclose.bind( this ) )
-    } )
+  async connect( host, port ) {
+    const con = rtpnodeconnection.create( this )
+    await con.connect( host, port )
+    this.connections.set( con.connectionid, con )
+    return this
   }
 
   /**
@@ -95,15 +263,12 @@ class rtpnode {
     let listenresolve
     const listenpromise = new Promise( ( r ) => listenresolve = r )
     this.server = net.createServer( ( connection ) => {
-      const con = {
-        connectionid: uuidv4(),
-        connection,
-        "connectionlength": 0,
-        "mode": "listen"
+      try {
+        const con = rtpnodeconnection.create( this, connection )
+        this.connections.set( con.connectionid, con )
+      } catch( e ) {
+        console.error( "Uncaught exception in node listen", e )
       }
-      this.connections[ con.connectionid ] = con
-      connection.setKeepAlive( true )
-      connection.on( "data", this._onsocketdata.bind( this, con ) )
     } )
 
     this.server.listen( this.port, this.address )
@@ -112,17 +277,6 @@ class rtpnode {
     return listenpromise
   }
 
-  /**
-   * @private
-   * @returns { void }
-   */
-  _onsocketconnect( /* sock */ ) {
-    //console.log( "Connected to " + this.host + ":" + this.port )
-    this.send( {}, this.connection )
-    this._onsocketreadypromiseresolve( this )
-    this._reconnecttime = 500 /* mS */
-  }
-
   /**
   * This callback is displayed as a global member.
   * @callback requestComplete
@@ -159,22 +313,6 @@ class rtpnode {
     this._post = cb
   }
 
-  /**
-   * Send a message back to the main server, include stats to help with load balancing.
-   * @param { object } msg
-   * @param { object } connection
-   * @returns { void }
-   */
-  send( msg, connection, cb = undefined ) {
-    this._post( msg, ( modifiedmsg ) => {
-      if( this._destroying ) return
-      msg.status = this.prtp.stats()
-      msg.status.instance = instance
-      connection.write( message.createmessage( modifiedmsg ) )
-      if (cb !== undefined) cb(msg)
-    } )
-  }
-
   /**
    * @summary Destroy this node
    * @returns { void }
@@ -183,24 +321,10 @@ class rtpnode {
     this._destroying = true
     nodeinterface.clean()
 
-    if( this._reconnecttimerid ) clearTimeout( this._reconnecttimerid )
-    if( this.connection ) this.connection.destroy()
-    this.connections.forEach( ( connection ) => {
-      connection.destroy()
-    } )
-    if ( this.server ) this.server.close()
-  }
-
-  /**
-   * 
-   * @param { object } msg 
-   * @param { object } con
-   * @returns { Promise< Boolean > }
-   */
-  async _processmessage( msg, con ) {
-    if( "open" == msg.channel ) return await this._openchannel( msg, con )
+    this.connections.forEach( ( con ) => con.destroy() )
+    this.connections.clear()
 
-    return this._updatechannel( msg, con )
+    if ( this.server ) this.server.close()
   }
 
   /**
@@ -211,137 +335,6 @@ class rtpnode {
   _defaulthandler( msg, cb ) {
     cb( msg )
   }
-
-  /**
-   * @private
-   * @returns { void }
-   */
-  _reconnect() {
-
-    delete this._reconnecttimerid
-    this.connection = net.createConnection( this.port, this.host )
-      .on( "error", () => {
-        this._runreconnect()
-      } )
-
-    this.connection.setKeepAlive( true )
-
-    this.connection.on( "connect", this._onsocketconnect.bind( this ) )
-    this.connection.on( "data", this._onsocketdata.bind( this ) )
-    this.connection.on( "error", this._onsocketerror.bind( this ) )
-    this.connection.on( "close", this._onsocketclose.bind( this ) )
-  }
-
-  /**
-   * @private
-   * @returns { void }
-   */
-  _runreconnect() {
-    if( this._reconnecttimerid ) return
-    console.log( "Disconnected - trying to reconnect to " + this.host + ":" + this.port )
-
-    this._reconnecttimerid = setTimeout( this._reconnect.bind( this ), this._reconnecttime )
-
-    this._reconnecttime = this._reconnecttime * 2
-    if( this._reconnecttime > ( 1000 * 2 ) ) this._reconnecttime = this._reconnecttime / 2
-  }
-
-  /**
-   * @private
-   * @returns { void }
-   */
-  _onsocketclose() {
-    if( this._destroying ) return
-    this._runreconnect()
-  }
-
-  /**
-   * Reconnect on failure.
-   * @private
-   * @returns { void }
-   */
-  _onsocketerror() {
-    if( this._destroying ) return
-    this._runreconnect()
-  }
-
-  /**
-   * @privateopenchannel
-   * @param { Buffer } data
-   * @param { object } con 
-   * @returns { void }
-   */
-  _onsocketdata( con, data ) {
-    message.parsemessage( this.messagestate, data, ( msg ) => {
-      try {
-        this._pre( msg, ( modifiedmsg ) => {
-          this._processmessage( modifiedmsg, con )
-        } )
-      } catch( e ) {
-        console.error( "Unhandled exception in babble-rtp", e )
-      }
-    } )
-  }
-
-  /**
-   * @private
-   * @param { object } msg
-   * @param { object } con
-   * @returns { Promise< Boolean > }
-   */
-  async _openchannel( msg, con ) {
-    con.connectionlength += 1
-    msg.forcelocal = true
-
-    const chan = await this.prtp.openchannel( msg, ( cookie ) => {
-      // TODO: we might want to ensure the actual event has been written
-      // to the server before cleaning up the channel on our side?
-      this.send( { ...{ "id": chan.id, "uuid": chan.uuid }, ...cookie },
-        con.connection,
-        ( cookie ) => {
-          if ( "close" === cookie.action )  {
-            con.connectionlength -= 1
-            channels.delete( chan.uuid )
-
-            if( 0 == con.connectionlength && "listen" == con.mode ) {
-              this.connections.delete( con.instance )
-              con.connection.destroy()
-            }
-          }
-        } )
-    } )
-    channels.set( chan.uuid, chan )
-    this.send( { ...chan, ...{ "action": "open" } }, con.connection )
-
-    return true
-  }
-
-  /**
-   * @private
-   * @param { object } msg
-   * @param { object } con 
-   * @returns boolean
-   */
-  _updatechannel( msg, con ) {
-
-    if( undefined === msg.channel ) return false
-    if( undefined === msg.uuid ) return false
-
-    const chan = channels.get( msg.uuid )
-    if( undefined == chan ) return false
-
-    if( msg.channel in channelmap ) {
-      channelmap[ msg.channel ]( chan, msg )
-    } else {
-      const channelidentifiers = {
-        "id": msg.id,
-        "uuid": msg.uuid
-      }
-      this.send( { ...{ "error": "Unknown method" }, ...channelidentifiers }, con.connection )
-    }
-
-    return true
-  }
 }
 
 /**
@@ -386,7 +379,7 @@ class nodeinterface {
     if( nodeinterface._n ) return new Promise( r => r( nodeinterface._n ) )
 
     nodeinterface._n = new rtpnode( this.prtp )
-    return nodeinterface._n.connect( port, host )
+    return nodeinterface._n.connect( host, port )
   }
 
   /**

package/lib/server.js

@@ -5,7 +5,7 @@ const { v4: uuidv4 } = require( "uuid" )
 
 const EventEmitter = require( "events" )
 
-const message = require( "./message.js" )
+const message = require( "./message" )
 
 /**
  * Node host address and port object
@@ -599,11 +599,10 @@ class channel {
 
   /**
    * 
-   * @param { object } msg 
    * @returns { void }
    * @private
    */
-  _runclose( msg ) {
+  _runclose() {
     if( undefined !== this.openresolve ) {
       this.openresolve()
       delete this.openresolve
@@ -634,7 +633,7 @@ class channel {
     this.em.emit( "all", msg )
     this.em.emit( msg.action, msg )
 
-    if( "close" == msg.action ) this._runclose( msg )
+    if( "close" == msg.action ) this._runclose()
   }
 
   /**

package/package.json

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

package/src/projectrtpchannelmux.cpp

@@ -75,10 +75,6 @@ void projectchannelmux::mixall( void ) {
           this->postrtpdata( chan, dtmfchan, src );
         }
       }
-
-      AQUIRESPINLOCK( chan->rtpbufferlock );
-      chan->inbuff->poppeeked();
-      RELEASESPINLOCK( chan->rtpbufferlock );
     }
 
     if( nullptr != src ) {
@@ -94,7 +90,7 @@ void projectchannelmux::mixall( void ) {
 
     rtppacket *dst = chan->gettempoutbuf();
 
-    this->subtracted.zero();
+    /* start with a direct copy */
     this->subtracted.copy( this->added );
 
     if( chan->recv ) {

package/src/projectrtpcodecx.cpp

@@ -141,8 +141,7 @@ void codecx::reset()
 ## restart
 Do enough to manage missing packets.
 */
-void codecx::restart( void )
-{
+void codecx::restart( void ) {
   this->lpfilter.reset();
   this->dcpowerfilter.reset();
   this->resamplelastsample = 0;
@@ -154,8 +153,7 @@ void codecx::restart( void )
 
 From whichever PCM encoding (u or a) encode to the other without having to do intermediate l16.
 */
-bool codecx::alaw2ulaw( void )
-{
+bool codecx::alaw2ulaw( void ) {
   if( 0 == this->pcmaref.size() ) return false;
   if( this->pcmaref.isdirty() ) return false;
 
@@ -167,23 +165,22 @@ bool codecx::alaw2ulaw( void )
   outbufptr = this->pcmuref.c_str();
   this->pcmuref.size( insize );
 
-  if( nullptr == outbufptr || nullptr == inbufptr )
-  {
+  if( nullptr == outbufptr || nullptr == inbufptr ) {
     std::cerr << "PCMA NULLPTR shouldn't happen (" << (void*)outbufptr << ", " << (void*)inbufptr << ")" << std::endl;
     return false;
   }
 
-  for( size_t i = 0; i < insize; i++ )
-  {
-    *outbufptr++ = alaw_to_ulaw_table[ *inbufptr++ ];
+  for( size_t i = 0; i < insize; i++ ) {
+    *outbufptr = alaw_to_ulaw_table[ *inbufptr ];
+    inbufptr++;
+    outbufptr++;
   }
 
   this->pcmuref.dirty( false );
   return true;
 }
 
-bool codecx::ulaw2alaw( void )
-{
+bool codecx::ulaw2alaw( void ) {
   if( 0 == this->pcmuref.size() ) return false;
   if( this->pcmuref.isdirty() ) return false;
 
@@ -195,15 +192,15 @@ bool codecx::ulaw2alaw( void )
   outbufptr = this->pcmaref.c_str();
   this->pcmaref.size( insize );
 
-  if( nullptr == outbufptr || nullptr == inbufptr )
-  {
+  if( nullptr == outbufptr || nullptr == inbufptr ) {
     std::cerr << "PCMU NULLPTR shouldn't happen(" << (void*)outbufptr << ", " << (void*)inbufptr << ")" << std::endl;
     return false;
   }
 
-  for( size_t i = 0; i < insize; i++ )
-  {
-    *outbufptr++ = ulaw_to_alaw_table[ *inbufptr++ ];
+  for( size_t i = 0; i < insize; i++ ) {
+    *outbufptr = ulaw_to_alaw_table[ *inbufptr ];
+    inbufptr++;
+    outbufptr++;
   }
 
   this->pcmaref.dirty( false );
@@ -220,20 +217,15 @@ bool codecx::g711tol16( void )
   int16_t *convert;
   size_t insize;
 
-  if( this->pcmaref.size() > 0 && !this->pcmaref.isdirty() )
-  {
+  if( this->pcmaref.size() > 0 && !this->pcmaref.isdirty() ) {
     in = this->pcmaref.c_str();
     convert = _pcmatol16;
     insize = this->pcmaref.size();
-  }
-  else if ( this->pcmuref.size() > 0 && !this->pcmuref.isdirty() )
-  {
+  } else if ( this->pcmuref.size() > 0 && !this->pcmuref.isdirty() ) {
     in = this->pcmuref.c_str();
     convert = _pcmutol16;
     insize = this->pcmuref.size();
-  }
-  else
-  {
+  } else {
     return false;
   }
 
@@ -241,9 +233,10 @@ bool codecx::g711tol16( void )
 
   int16_t *out = ( int16_t * ) this->l168kref.c_str();
 
-  for( size_t i = 0; i < insize; i++ )
-  {
-    *out++ = convert[ *in++ ];
+  for( size_t i = 0; i < insize; i++ ) {
+    *out = convert[ *in ];
+    in++;
+    out++;
   }
 
   this->l168kref.dirty( false );
@@ -265,9 +258,12 @@ bool codecx::l16topcma( void )
   size_t l168klength = this->l168kref.size();
   in = ( int16_t * ) this->l168kref.c_str();
 
-  for( size_t i = 0; i < l168klength; i++ )
-  {
-    *out++ = _l16topcma[ ( *in++ ) + 32768 ];
+  uint16_t index;
+  for( size_t i = 0; i < l168klength; i++ ) {
+    index = *in + 32768;
+    *out = _l16topcma[ index ];
+    in++;
+    out++;
   }
   this->pcmaref.dirty( false );
   return true;
@@ -276,8 +272,7 @@ bool codecx::l16topcma( void )
 /*!md
 ## l16topcmu
 */
-bool codecx::l16topcmu( void )
-{
+bool codecx::l16topcmu( void ) {
   if( 0 == this->l168kref.size() ) return false;
   if( this->l168kref.isdirty() ) return false;
 
@@ -287,9 +282,12 @@ bool codecx::l16topcmu( void )
   size_t l168klength = this->l168kref.size();
   in = ( int16_t * ) this->l168kref.c_str();
 
-  for( size_t i = 0; i < l168klength; i++ )
-  {
-    *out++ = _l16topcmu[ ( *in++ ) + 32768 ];
+  uint16_t index;
+  for( size_t i = 0; i < l168klength; i++ ) {
+    index = *in + 32768;
+    *out = _l16topcmu[ index ];
+    in++;
+    out++;
   }
   this->pcmuref.dirty( false );
   return true;
@@ -299,8 +297,7 @@ bool codecx::l16topcmu( void )
 ## ilbctol16
 As it says.
 */
-bool codecx::ilbctol16( void )
-{
+bool codecx::ilbctol16( void ) {
   if( 0 == this->ilbcref.size() ) return false;
   if( this->ilbcref.isdirty() ) return false;
 
@@ -335,25 +332,20 @@ bool codecx::ilbctol16( void )
 ## l16tog722
 As it says.
 */
-bool codecx::l16tog722( void )
-{
+bool codecx::l16tog722( void ) {
   if( 0 == this->l1616kref.size() ) return false;
   if( this->l1616kref.isdirty() ) return false;
 
-  if( nullptr == this->g722encoder )
-  {
+  if( nullptr == this->g722encoder ) {
     this->g722encoder = g722_encode_init( NULL, 64000, G722_PACKED );
   }
 
   int len = g722_encode( this->g722encoder, this->g722ref.c_str(), ( int16_t * ) this->l1616kref.c_str(), this->g722ref.size() * 2 );
 
-  if( len > 0 )
-  {
+  if( len > 0 ) {
     this->g722ref.size( len );
     this->g722ref.dirty( false );
-  }
-  else
-  {
+  } else {
     std::cerr << "g722_encode didn't encode any data" << std::endl;
     this->g722ref.size( 0 );
   }
@@ -400,19 +392,16 @@ bool codecx::l16toilbc( void ) {
 ## g722tol16
 As it says.
 */
-bool codecx::g722tol16( void )
-{
+bool codecx::g722tol16( void ) {
   if( 0 == this->g722ref.size() ) return false;
   if( this->g722ref.isdirty() ) return false;
 
   /* x 2 for 16 bit instead of 8 and then x 2 sample rate */
   this->l1616kref.malloc( this->g722ref.size(), sizeof( int16_t ), L1616KPAYLOADTYPE );
 
-  if( nullptr == this->g722decoder )
-  {
+  if( nullptr == this->g722decoder ) {
     this->g722decoder = g722_decode_init( NULL, 64000, G722_PACKED );
-    if( nullptr ==  this->g722decoder )
-    {
+    if( nullptr ==  this->g722decoder ) {
       std::cerr << "Failed to init G722 decoder" << std::endl;
     }
   }
@@ -431,8 +420,7 @@ bool codecx::g722tol16( void )
 ## l16lowtowideband
 Upsample from narrow to wideband. Take each point and interpolate between them. We require the final sample from the last packet to continue the interpolating.
 */
-bool codecx::l16lowtowideband( void )
-{
+bool codecx::l16lowtowideband( void ) {
   size_t l168klength = this->l168kref.size();
 
   if( 0 == l168klength ) return false;
@@ -443,8 +431,7 @@ bool codecx::l16lowtowideband( void )
   int16_t *in = ( int16_t * ) this->l168kref.c_str();
   int16_t *out = ( int16_t * ) this->l1616kref.c_str();
 
-  for( size_t i = 0; i < l168klength; i++ )
-  {
+  for( size_t i = 0; i < l168klength; i++ ) {
     *out = ( ( *in - this->resamplelastsample ) / 2 ) + this->resamplelastsample;
     this->resamplelastsample = *in;
     out++;
@@ -463,8 +450,7 @@ bool codecx::l16lowtowideband( void )
 ## requirewideband
 Search for the relevent data and convert as necessary.
 */
-bool codecx::requirewideband( void )
-{
+bool codecx::requirewideband( void ) {
   if( 0 != this->l1616kref.size() && !this->l1616kref.isdirty() ) return true;
   if( this->g722tol16() ) return true;
   if( !this->g711tol16() )
@@ -491,10 +477,12 @@ bool codecx::l16widetonarrowband( void )
   int16_t *out = ( int16_t * ) this->l168kref.c_str();
   int16_t *in = ( int16_t * ) this->l1616kref.c_str();
 
-  for( size_t i = 0; i < l1616klength / 2; i++ )
-  {
-    lpfilter.execute( *in++ );
-    *out++ = lpfilter.execute( *in++ );
+  for( size_t i = 0; i < l1616klength / 2; i++ ) {
+    lpfilter.execute( *in );
+    in++;
+    *out = lpfilter.execute( *in );
+    in++;
+    out++;
   }
 
   this->l168kref.dirty( false );
@@ -820,6 +808,18 @@ void codectests( void )
 
 #ifdef NODE_MODULE
 
+static napi_value codectest( napi_env env, napi_callback_info info ) {
+  napi_value result;
+  if( napi_ok != napi_create_object( env, &result ) ) return NULL;
+
+  codectests();
+
+  napi_create_uint32( env, 1, &result );
+  napi_coerce_to_bool( env, result, &result );
+
+  return result;
+}
+
 /*
 Support single number just for now - but TODO detect Buffer input to convert whole bufffer.
 */
@@ -929,6 +929,9 @@ void initrtpcodecx( napi_env env, napi_value &result ) {
 
   if( napi_ok != napi_create_function( env, "exports", NAPI_AUTO_LENGTH, pcmu2linear, nullptr, &funct ) ) return;
   if( napi_ok != napi_set_named_property( env, codecx, "pcmu2linear16", funct ) ) return;
+
+  if( napi_ok != napi_create_function( env, "exports", NAPI_AUTO_LENGTH, codectest, nullptr, &funct ) ) return;
+  if( napi_ok != napi_set_named_property( env, codecx, "codectests", funct ) ) return;
 }
 
 #endif /* NODE_MODULE */

package/test/interface/projectrtpchannel.js

@@ -96,7 +96,7 @@ describe( "rtpchannel", function() {
     await finished
   } )
 
-  it( "call create channel and check the structure of the returned object ( server as listener )", async function() {
+  it( "call create channel and check the structure of the returned object - server as listener", async function() {
 
     const ourport = 45433
     await projectrtp.server.listen( ourport, "127.0.0.1" )
@@ -119,7 +119,7 @@ describe( "rtpchannel", function() {
     await server.destroy()
   } )
 
-  it( "call create channel and check the structure of the returned object ( node as listener )", async function() {
+  it( "call create channel and check the structure of the returned object - node as listener", async function() {
 
     const ourport = 45432
     projectrtp.server.clearnodes()

package/test/interface/projectrtpdtls.js

@@ -298,36 +298,24 @@ describe( "dtls", function() {
   it( "Connect then remote to another session", async function() {
 
     /*
-                    |     internal projectrtp      |
-    Clienta         |  channela          channelb  |        clientb
-        |  RTP (DTLS)     |       MIX       |      RTP        |
-        |<--------------->|<--------------->|<--------------->| Step 1.
-        |<-(close)-(rem)->|<--------------->|<--------------->| Step 2.
-    Clientc
-        |<--------------->|<--------------->|<--------------->|Step 3.
-        play                                                 echo
-
+      Play, then encrypt at one end, then unencrypt in projectrtp and send onto d
+      Create an e channel so that we mix 3
+
+                                      |      internal       |
+      channel                        channel          channel                   channel
+        a       RTP over DTLS -----------b               c      RTP               d
+        play                             b       mix     c                      echo
+                                                 mix     e                         f
+                                                                                echo
     
     */
 
     this.timeout( 6000 )
     this.slow( 2500 )
 
-    projectrtp.tone.generate( "400+450*0.5/0/400+450*0.5/0:400/200/400/2000", "/tmp/ukringing.wav" )
+    projectrtp.tone.generate( "400+450*0.25/0/400+450*0.25/0:400/200/400/2000", "/tmp/ukringing.wav" )
 
-    const channeltargeta = {
-      "address": "localhost",
-      "port": 0,
-      "codec": 0,
-      "dtls": {
-        "fingerprint": {
-          "hash": ""
-        },
-        "mode": "active" // - is this in the right place and the right way round!
-      }
-    }
-
-    const channeltargetc = {
+    const targeta = {
       "address": "localhost",
       "port": 0,
       "codec": 0,
@@ -335,36 +323,23 @@ describe( "dtls", function() {
         "fingerprint": {
           "hash": ""
         },
-        "mode": "active" // - is this in the right place and the right way round!
+        "mode": "active"
       }
     }
 
-    const clienttargeta = {
-      "address": "localhost",
-      "port": 12008,
-      "codec": 0,
-      "dtls": {
-        "fingerprint": {
-          "hash": ""
-        },
-        "mode": "passive"
-      }
-    }
+    const targetb = JSON.parse( JSON.stringify( targeta ) )
 
-    const channeltargetb = {
+    const targetc =     {
       "address": "localhost",
       "port": 0,
       "codec": 0
     }
-
-    const clienttargetb = {
-      "address": "localhost",
-      "port": 12010,
-      "codec": 0
-    }
+    const targetd = JSON.parse( JSON.stringify( targetc ) )
+    const targete = JSON.parse( JSON.stringify( targetc ) )
+    const targetf = JSON.parse( JSON.stringify( targetc ) )
 
     let done
-    const finished = new Promise( ( r ) => { done = r } )
+    const finished = new Promise( ( resolve ) => { done = resolve } )
 
     const channela = await projectrtp.openchannel( {}, function( d ) {
       if( "close" === d.action ) {
@@ -372,57 +347,66 @@ describe( "dtls", function() {
       }
     } )
 
-    const clienta = await projectrtp.openchannel( {}, function() {} )
-
-    channeltargeta.dtls.fingerprint.hash = clienta.local.dtls.fingerprint
-    channeltargeta.port = clienta.local.port
-    expect( channela.remote( channeltargeta ) ).to.be.true
-    clienttargeta.port = channela.local.port
-    clienttargeta.dtls.fingerprint.hash = channela.local.dtls.fingerprint
-    expect( clienta.remote( clienttargeta ) ).to.be.true
-
-    clienta.play( { "loop": true, "files": [
-      { "wav": "/tmp/ukringing.wav" } ] } )
+    const channelb = await projectrtp.openchannel( {}, function( d ) {
+      if( "close" === d.action ) {
+        channelc.close()
+      }
+    } )
 
+    const channelc = await projectrtp.openchannel( {}, function( d ) {
+      if( "close" === d.action ) {
+        channeld.close()
+      }
+    } )
 
-    const channelb = await projectrtp.openchannel( {}, function( d ) {
+    const channeld = await projectrtp.openchannel( {}, function( d ) {
       if( "close" === d.action ) {
-        clientb.close()
+        channele.close()
       }
     } )
 
-    const clientb = await projectrtp.openchannel( {}, function( d ) {
+    const channele = await projectrtp.openchannel( {}, function( d ) {
       if( "close" === d.action ) {
-        clientc.close()
+        channelf.close()
       }
     } )
 
-    let clientcclose = {}
-    const clientc = await projectrtp.openchannel( {}, function( d ) {
+    let channelclose = {}
+    const channelf = await projectrtp.openchannel( {}, function( d ) {
       if( "close" === d.action ) {
-        clientcclose = d
+        channelclose = d
         done()
       }
     } )
 
-    channeltargetb.port = clientb.local.port
-    expect( channelb.remote( channeltargetb ) ).to.be.true
-    clienttargetb.port = channelb.local.port
-    expect( clientb.remote( clienttargetb ) ).to.be.true
-    expect( clientb.echo() ).to.be.true
-
-    channela.mix( channelb )
+    targeta.dtls.fingerprint.hash = channelb.local.dtls.fingerprint
+    targeta.port = channelb.local.port
+    expect( channela.remote( targeta ) ).to.be.true
+    targetb.port = channela.local.port
+    targetb.dtls.fingerprint.hash = channela.local.dtls.fingerprint
+    targetb.dtls.mode = "passive"
+    expect( channelb.remote( targetb ) ).to.be.true
 
-    await new Promise( ( r ) => { setTimeout( () => r(), 500 ) } )
+    targetc.port = channeld.local.port
+    expect( channelc.remote( targetc ) ).to.be.true
+    targetd.port = channelc.local.port
+    expect( channeld.remote( targetd ) ).to.be.true
 
-    channeltargetc.dtls.fingerprint.hash = clientc.local.dtls.fingerprint
-    channeltargetc.port = clientc.local.port
-    expect( channela.remote( channeltargetc ) ).to.be.true
-    expect( clientc.remote( clienttargeta ) ).to.be.true
+    targete.port = channelf.local.port
+    expect( channele.remote( targete ) ).to.be.true
+    targetf.port = channele.local.port
+    expect( channelf.remote( targetf ) ).to.be.true
 
-    clientc.play( { "loop": true, "files": [
+    /* play on one end */
+    channela.play( { "loop": true, "files": [
       { "wav": "/tmp/ukringing.wav" } ] } )
-    clienta.close()
+
+    /* mix in the middle */
+    channelb.mix( channelc )
+    channelb.mix( channele )
+
+    /* echo at the other end */
+    expect( channeld.echo() ).to.be.true
 
     await new Promise( ( r ) => { setTimeout( () => r(), 1500 ) } )
 
@@ -431,8 +415,8 @@ describe( "dtls", function() {
     await fs.promises.unlink( "/tmp/ukringing.wav" ).catch( () => {} )
     await finished
 
-    expect( clientcclose.stats.in.count ).to.be.above( 10 )
-    expect( clientcclose.stats.in.skip ).to.be.below( 2 ) // allow a little loss in test
+    expect( channelclose.stats.in.count ).to.be.above( 30 )
+    expect( channelclose.stats.in.skip ).to.be.below( 2 ) // allow a little loss in test
 
   } )
 } )

package/test/interface/projectrtpfullserver.js

@@ -0,0 +1,83 @@
+
+const prtp = require( "../../index" )
+const node = require( "../../lib/node" )
+const expect = require( "chai" ).expect
+
+/**
+ * Test file to run tests acting as a remote note. Starts a babble-rtp node in the background
+ * before any tests begin then runs tests to open, play, polly etc.
+ */
+describe( "server connect interface", () => {
+
+  before( async () => {
+    const host = "127.0.0.1"
+    const port = 9002
+    await prtp.projectrtp.node.listen( host, port )
+    prtp.projectrtp.server.addnode( { host, port} )
+    
+  } )
+
+  after( () => {
+
+    prtp.projectrtp.server.clearnodes()
+    node.interface.destroy()
+  } )
+
+  it( "server connect and open channel", async function () {
+    this.timeout( 6000 )
+    this.slow( 3000 )
+
+    const totalotherchannelcount = 100
+    let chanclosecount = 0
+    let allchannelsclosedresolve
+    const allchannelsclosed = new Promise( resolve => allchannelsclosedresolve = resolve )
+    const onclose = ( e ) => {
+      if( "close" == e.action ) chanclosecount++
+      if( totalotherchannelcount == chanclosecount ) allchannelsclosedresolve()
+    }
+
+    // A very short wav file
+    prtp.projectrtp.tone.generate( "350+440*0.5:100", "/tmp/serverconnecttestwav.wav" )
+    prtp.projectrtp.tone.generate( "350+440*0.5:100", "/tmp/otherserverconnecttestwav.wav" )
+
+    const channels = []
+    for( let i = 0; totalotherchannelcount > i; i++ ) {
+      channels.push( await prtp.projectrtp.openchannel( onclose ) )
+    }
+
+    for( let i = 0; 3 > i; i++ ) {
+      let done
+      const finished = new Promise( resolve => done = resolve )
+  
+      const receivedmessages = []
+      const chan = await prtp.projectrtp.openchannel( ( e ) => {
+        receivedmessages.push( e )
+        if( "play" == e.action && "end" == e.event ) chan.close()
+        if( "close" == e.action ) done()
+      } )
+  
+      chan.play( { "interupt":true, "files": [ { "wav": "/tmp/serverconnecttestwav.wav" }, { "wav": "/tmp/otherserverconnecttestwav.wav" } ] } )
+  
+      await finished
+
+      //console.log(receivedmessages)
+      expect( receivedmessages.length ).to.equal( 3 )
+      expect( receivedmessages[ 0 ].action ).to.equal( "play" )
+      expect( receivedmessages[ 0 ].event ).to.equal( "start" )
+      expect( receivedmessages[ 0 ].reason ).to.equal( "new" )
+      expect( receivedmessages[ 1 ].action ).to.equal( "play" )
+      expect( receivedmessages[ 1 ].event ).to.equal( "end" )
+      expect( receivedmessages[ 1 ].reason ).to.equal( "completed" )
+      expect( receivedmessages[ 2 ].action ).to.equal( "close" )
+      expect( receivedmessages[ 2 ].reason ).to.equal( "requested" )
+    }
+
+    for( const chan of channels ) {
+      chan.close()
+    }
+
+    await allchannelsclosed
+    expect( chanclosecount ).to.equal( totalotherchannelcount )
+  } )
+
+} )

package/test/interface/projectrtpmix.js

@@ -432,6 +432,69 @@ describe( "channel mix", function() {
 
   } )
 
+  it( "mix 2 channels - pcmu <-> g722 with recording", async function() {
+
+    this.timeout( 3000 )
+    this.slow( 2000 )
+
+    const endpointa = dgram.createSocket( "udp4" )
+    const endpointb = dgram.createSocket( "udp4" )
+
+    let endpointapkcount = 0
+    let endpointbpkcount = 0
+
+    endpointa.on( "message", function( msg ) {
+      endpointapkcount++
+      expect( 0x7f & msg [ 1 ] ).to.equal( 0 )
+    } )
+
+    endpointb.on( "message", function( msg ) {
+
+      endpointbpkcount++
+      expect( 0x7f & msg [ 1 ] ).to.equal( 9 )
+      endpointb.send( msg, channelb.local.port, "localhost" )
+    } )
+
+    endpointa.bind()
+    await new Promise( ( resolve ) => { endpointa.on( "listening", function() { resolve() } ) } )
+
+    endpointb.bind()
+    await new Promise( ( resolve ) => { endpointb.on( "listening", function() { resolve() } ) } )
+
+    let done
+    const finished = new Promise( ( r ) => { done = r } )
+
+    const channela = await projectrtp.openchannel( { "remote": { "address": "localhost", "port": endpointa.address().port, "codec": 0 } }, function( d ) {
+      if( "close" === d.action ) channelb.close()
+    } )
+
+    const channelb = await projectrtp.openchannel( { "remote": { "address": "localhost", "port": endpointb.address().port, "codec": 9 } }, function( d ) {
+      if( "close" === d.action ) done()
+    } )
+
+    /* mix */
+    expect( channela.mix( channelb ) ).to.be.true
+
+    channela.record( { "file": "/tmp/g722mix2recording.wav" } )
+
+    /* Now, when we send UDP on endpointb it  passes through our mix then arrives at endpointa */
+    for( let i = 0;  50 > i; i ++ ) {
+      sendpk( i, i, channela.local.port, endpointa )
+    }
+
+    await new Promise( ( resolve ) => { setTimeout( () => resolve(), 1500 ) } )
+
+    channela.close()
+    endpointa.close()
+    endpointb.close()
+
+    expect( endpointapkcount ).to.be.above( 30 )
+    expect( endpointbpkcount ).to.be.above( 30 )
+
+    await finished
+
+  } )
+
   it( "mix 3 channels - 1 writer 3 readers", async function() {
 
     this.timeout( 3000 )