@babblevoice/projectrtp 2.4.8 → 2.4.10

package/package.json

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

package/src/projectrtpchannelmux.cpp

@@ -75,7 +75,7 @@ void projectchannelmux::mixall( void ) {
           this->postrtpdata( chan, dtmfchan, src );
         }
       }
-
+      /* remove the DTMF packet */
       AQUIRESPINLOCK( chan->rtpbufferlock );
       chan->inbuff->poppeeked();
       RELEASESPINLOCK( chan->rtpbufferlock );
@@ -94,7 +94,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/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/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 )