@babblevoice/projectrtp 2.4.12 → 2.4.16

package/package.json

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

package/src/projectrtpchannel.cpp

@@ -121,11 +121,13 @@ projectrtpchannel::projectrtpchannel( unsigned short port ):
 }
 
 void projectrtpchannel::requestclose( std::string reason ) {
-  if( !this->_requestclose.exchange( true, std::memory_order_acquire ) ) {
-    this->closereason = reason;
-  }
 
-  this->removemixer = true;
+  this->closereason = reason;
+  if( this->mixing ) {
+    this->removemixer = true;
+  } else {
+    this->_requestclose.exchange( true, std::memory_order_acquire );
+  }
 }
 
 void projectrtpchannel::remote( std::string address,
@@ -390,6 +392,11 @@ void projectrtpchannel::handletick( const boost::system::error_code& error ) {
   if( error == boost::asio::error::operation_aborted ) return;
   if( !this->active ) return;
 
+  if( this->_requestclose ) {
+    this->doclose();
+    return;
+  }
+
   if( this->dtlsnegotiate() ) {
     this->setnexttick();
     return;
@@ -400,11 +407,6 @@ void projectrtpchannel::handletick( const boost::system::error_code& error ) {
     return;
   };
 
-  if( this->_requestclose ) {
-    this->doclose();
-    return;
-  }
-
   this->startticktimer();
 
   this->incrtsout();
@@ -1025,21 +1027,20 @@ bool projectrtpchannel::mix( projectrtpchannel::pointer other ) {
   if( nullptr == this->mixer && nullptr != other->mixer ) {
     this->mixer = other->mixer;
     this->mixer->addchannel( shared_from_this() );
-    postdatabacktojsfromthread( shared_from_this(), "mix", "start" );
+
   } else if ( nullptr != this->mixer && nullptr == other->mixer ) {
     other->mixer = this->mixer;
     this->mixer->addchannel( other );
-    postdatabacktojsfromthread( shared_from_this(), "mix", "start" );
+
   } else if( nullptr == this->mixer && nullptr == other->mixer  ) {
     this->mixer = projectchannelmux::create( workercontext );
     other->mixer = this->mixer;
 
     this->mixer->addchannels( shared_from_this(), other );
-    postdatabacktojsfromthread( shared_from_this(), "mix", "start" );
-    postdatabacktojsfromthread( other, "mix", "start" );
   } else {
     /* If we get here this and other are already mixing and should be cleaned up first */
     RELEASESPINLOCK( this->mixerlock );
+    postdatabacktojsfromthread( shared_from_this(), "mix", "busy" );
     return false;
   }
 
@@ -1050,6 +1051,9 @@ bool projectrtpchannel::mix( projectrtpchannel::pointer other ) {
 
   RELEASESPINLOCK( this->mixerlock );
 
+  postdatabacktojsfromthread( shared_from_this(), "mix", "start" );
+  postdatabacktojsfromthread( other, "mix", "start" );
+
   return true;
 }
 
@@ -1059,7 +1063,11 @@ Add the other to a mixer - both channels have access to the same mixer.
 n way relationship. Adds to queue for when our main thread calls into us.
 */
 bool projectrtpchannel::unmix( void ) {
-  this->removemixer = true;
+
+  AQUIRESPINLOCK( this->mixerlock );
+  if( nullptr != this->mixer ) this->removemixer = true;
+  RELEASESPINLOCK( this->mixerlock );
+
   return true;
 }
 
@@ -1075,6 +1083,10 @@ void projectrtpchannel::dounmix( void ) {
   RELEASESPINLOCK( this->mixerlock );
 
   postdatabacktojsfromthread( shared_from_this(), "mix", "finished" );
+
+  if( this->closereason.length() > 0 ) {
+    this->_requestclose.exchange( true, std::memory_order_acquire );
+  }
 }
 
 /*

package/src/projectrtpcodecx.cpp

@@ -559,7 +559,7 @@ rawsound& codecx::getref( int pt ) {
     }
     case PCMAPAYLOADTYPE: {
       if( this->pcmuref.size() > 0 ) {
-        this->alaw2ulaw();
+        this->ulaw2alaw();
       } else {
         this->requirenarrowband();
         this->l16topcma();
@@ -568,7 +568,7 @@ rawsound& codecx::getref( int pt ) {
     }
     case PCMUPAYLOADTYPE: {
       if( this->pcmaref.size() > 0 ) {
-        this->ulaw2alaw();
+        this->alaw2ulaw();
       } else {
         this->requirenarrowband();
         this->l16topcmu();
@@ -697,8 +697,7 @@ codecx& operator << ( codecx& c, const char& a )
 
 
 
-void codectests( void )
-{
+void codectests( void ) {
   /* init transcoding stuff */
   gen711convertdata();
 
@@ -715,8 +714,7 @@ void codectests( void )
 
 
   g722_decode_state_t *g722decoder = g722_decode_init( NULL, 64000, G722_PACKED );
-  if( nullptr == g722decoder )
-  {
+  if( nullptr == g722decoder ) {
     std::cerr << "Failed to init G722 decoder" << std::endl;
   }
 
@@ -727,15 +725,13 @@ void codectests( void )
                                 g722samplepk,
                                 160 );
   std::cout << "g722_decode returned " << l1616klength << " for an in packet of 160 bytes" << std::endl;
-  if( 320 != l1616klength )
-  {
+  if( 320 != l1616klength ) {
     std::cerr << "ERROR - decoded length is not 320 bytes" << std::endl;
   }
   g722_decode_free( g722decoder );
 
   std::cout << "L16 OUT (g722_decode) =" << std::endl;
-  for( int i = 0; i < 160; i ++ )
-  {
+  for( int i = 0; i < 160; i ++ ) {
     std::cout << unsigned( outbuf[ i ] ) << " ";
   }
   std::cout << std::endl;
@@ -744,66 +740,123 @@ void codectests( void )
   /*
   Move onto test our interface.
   */
-  rawsound r( g722samplepk, sizeof( g722samplepk ), G722PAYLOADTYPE, 16000 );
-  std::cout << "G722 raw packet size " << r.size() << " with a format of " << r.getformat() << " and sample rate " << r.getsamplerate() << std::endl;
+  {
+    rawsound r( g722samplepk, sizeof( g722samplepk ), G722PAYLOADTYPE, 16000 );
+    std::cout << "G722 raw packet size " << r.size() << " with a format of " << r.getformat() << " and sample rate " << r.getsamplerate() << std::endl;
 
-  codecx ourcodec;
+    codecx ourcodec;
 
-  ourcodec << codecx::next;
-  ourcodec << r;
+    ourcodec << codecx::next;
+    ourcodec << r;
 
-  rtppacket outpk;
-  outpk.setpayloadtype( PCMAPAYLOADTYPE );
-  outpk.setpayloadlength( 160 );
-  outpk.setsequencenumber( 0 );
-  outpk.settimestamp( 0 );
-  outpk << ourcodec;
+    
 
-  std::cout << "PCMA OUT =" << std::endl;
-  uint8_t *pl = outpk.getpayload();
+    rtppacket outpk;
+    outpk.setpayloadtype( PCMAPAYLOADTYPE );
+    outpk.setpayloadlength( 160 );
+    outpk.setsequencenumber( 0 );
+    outpk.settimestamp( 0 );
+    outpk << ourcodec;
 
-  for( int i = 0; i < 160; i ++ )
-  {
-    std::cout << unsigned( pl[ i ] ) << " ";
-  }
-  std::cout << std::endl;
+    std::cout << "PCMA OUT =" << std::endl;
+    uint8_t *pl = outpk.getpayload();
+
+    for( int i = 0; i < 160; i ++ ) {
+      std::cout << unsigned( pl[ i ] ) << " ";
+    }
+    std::cout << std::endl;
+
+    if( 213 != pl[ 0 ] ) std::cout << "ERROR ERROR First byte should be 213???" << std::endl;
+    if( 85 != pl[ 9 ] ) std::cout << "ERROR ERROR 9th byte should be 85???" << std::endl;
+
+    rawsound &ref8k = ourcodec.getref( L168KPAYLOADTYPE );
+
+    if( ref8k.isdirty() ) std::cout << "ERROR our 8k out ref should not be dirty" << std::endl;
+
+    /* Repeat as this will use a different bit of code getting cached bit */
+    ref8k = ourcodec.getref( L168KPAYLOADTYPE );
+    if( ref8k.isdirty() ) std::cout << "ERROR our 8k out ref should not be dirty" << std::endl;
+
+    std::cout << "8k is dirty: " << std::boolalpha << ref8k.isdirty() << std::endl;
+    std::cout << "8k size: " << ref8k.size() << std::endl;
+    std::cout << "8k bytes per sample (should be 2): " << ref8k.getbytespersample() << std::endl;
 
-  if( 213 != pl[ 0 ] ) std::cout << "ERROR ERROR First byte should be 213???" << std::endl;
-  if( 85 != pl[ 9 ] ) std::cout << "ERROR ERROR 9th byte should be 85???" << std::endl;
+    /* 2 bytes per sample */
+    int16_t *pl16 = ( int16_t * ) ref8k.c_str();
+    for( size_t i = 0; i < ref8k.size(); i ++ ) {
+      std::cout << static_cast<int16_t>( pl16[ i ] ) << " ";
+    }
+    std::cout << std::endl;
 
-  rawsound &ref8k = ourcodec.getref( L168KPAYLOADTYPE );
 
-  if( ref8k.isdirty() ) std::cout << "ERROR our 8k out ref should not be dirty" << std::endl;
+    rawsound &ref16k = ourcodec.getref( L1616KPAYLOADTYPE );
+    if( ref16k.isdirty() ) std::cout << "ERROR our 16k out ref should not be dirty" << std::endl;
+    std::cout << "16k is dirty: " << std::boolalpha << ref16k.isdirty() << std::endl;
+    std::cout << "16k size: " << ref16k.size() << std::endl;
+    std::cout << "16k bytes per sample (should be 2): " << ref16k.getbytespersample() << std::endl;
 
-  /* Repeat as this will use a different bit of code getting cached bit */
-  ref8k = ourcodec.getref( L168KPAYLOADTYPE );
-  if( ref8k.isdirty() ) std::cout << "ERROR our 8k out ref should not be dirty" << std::endl;
+    pl16 = ( int16_t * ) ref16k.c_str();
+    for( size_t i = 0; i < ref16k.size(); i ++ ) {
+      std::cout << static_cast<int16_t>( pl16[ i ] ) << " ";
+    }
+    std::cout << std::endl;
+  }
 
-  std::cout << "8k is dirty: " << std::boolalpha << ref8k.isdirty() << std::endl;
-  std::cout << "8k size: " << ref8k.size() << std::endl;
-  std::cout << "8k bytes per sample (should be 2): " << ref8k.getbytespersample() << std::endl;
 
-  /* 2 bytes per sample */
-  int16_t *pl16 = ( int16_t * ) ref8k.c_str();
-  for( size_t i = 0; i < ref8k.size(); i ++ )
   {
-    std::cout << static_cast<int16_t>( pl16[ i ] ) << " ";
+    /* problem with converting pcmu to pcma */
+    /* use the same data, but pretend it is PCMU */
+    rawsound r( g722samplepk, sizeof( g722samplepk ), PCMUPAYLOADTYPE, 8000 );
+
+    codecx ourcodec;
+
+    ourcodec << codecx::next;
+    ourcodec << r;
+
+    rtppacket outpk;
+    outpk.setpayloadtype( PCMAPAYLOADTYPE );
+    outpk.setpayloadlength( 160 );
+    outpk.setsequencenumber( 0 );
+    outpk.settimestamp( 0 );
+    outpk << ourcodec;
+
+    std::cout << "PCMA OUT (it should not be all zeros) = " << std::endl;
+
+    uint8_t *pl = outpk.getpayload();
+
+    for( int i = 0; i < 160; i ++ ) {
+      std::cout << unsigned( pl[ i ] ) << " ";
+    }
+    std::cout << std::endl;
   }
-  std::cout << std::endl;
 
+    {
+    /* problem with converting pcmu to pcma */
+    /* use the same data, but pretend it is PCMU */
+    rawsound r( g722samplepk, sizeof( g722samplepk ), PCMAPAYLOADTYPE, 8000 );
 
-  rawsound &ref16k = ourcodec.getref( L1616KPAYLOADTYPE );
-  if( ref16k.isdirty() ) std::cout << "ERROR our 16k out ref should not be dirty" << std::endl;
-  std::cout << "16k is dirty: " << std::boolalpha << ref16k.isdirty() << std::endl;
-  std::cout << "16k size: " << ref16k.size() << std::endl;
-  std::cout << "16k bytes per sample (should be 2): " << ref16k.getbytespersample() << std::endl;
+    codecx ourcodec;
 
-  pl16 = ( int16_t * ) ref16k.c_str();
-  for( size_t i = 0; i < ref16k.size(); i ++ )
-  {
-    std::cout << static_cast<int16_t>( pl16[ i ] ) << " ";
+    ourcodec << codecx::next;
+    ourcodec << r;
+
+    rtppacket outpk;
+    outpk.setpayloadtype( PCMUPAYLOADTYPE );
+    outpk.setpayloadlength( 160 );
+    outpk.setsequencenumber( 0 );
+    outpk.settimestamp( 0 );
+    outpk << ourcodec;
+
+    std::cout << "PCMU OUT (it should not be all zeros) = " << std::endl;
+
+    uint8_t *pl = outpk.getpayload();
+
+    for( int i = 0; i < 160; i ++ ) {
+      std::cout << unsigned( pl[ i ] ) << " ";
+    }
+    std::cout << std::endl;
   }
-  std::cout << std::endl;
+  
 }
 
 #ifdef NODE_MODULE

package/test/codectests.js

@@ -0,0 +1,10 @@
+
+
+const prtp = require( "../index.js" )
+
+prtp.projectrtp.run()
+
+
+prtp.projectrtp.codecx.codectests()
+
+prtp.projectrtp.shutdown()

package/test/interface/projectrtpdtmf.js

@@ -620,6 +620,7 @@ describe( "dtmf", function() {
     expect( receivedmessages[ 1 ].action ).to.equal( "telephone-event" )
     expect( receivedmessages[ 2 ].action ).to.equal( "telephone-event" )
     expect( receivedmessages[ 3 ].action ).to.equal( "mix" )
+    expect( receivedmessages[ 3 ].event ).to.equal( "finished" )
     expect( receivedmessages[ 4 ].action ).to.equal( "close" )
 
     expect( receivedmessages[ 0 ].event ).to.equal( "start" )

package/test/interface/projectrtpfullserver.js

@@ -2,6 +2,7 @@
 const prtp = require( "../../index" )
 const node = require( "../../lib/node" )
 const expect = require( "chai" ).expect
+const fs = require( "node:fs" )
 
 /**
  * Test file to run tests acting as a remote note. Starts a babble-rtp node in the background
@@ -25,7 +26,7 @@ describe( "server connect interface", () => {
 
   it( "server connect and open channel", async function () {
     this.timeout( 6000 )
-    this.slow( 3000 )
+    this.slow( 30000 )
 
     const totalotherchannelcount = 100
     let chanclosecount = 0
@@ -37,6 +38,8 @@ describe( "server connect interface", () => {
     }
 
     // A very short wav file
+    await fs.promises.rm( "/tmp/serverconnecttestwav.wav", { force: true } )
+    await fs.promises.rm( "/tmp/otherserverconnecttestwav.wav", { force: true } )
     prtp.projectrtp.tone.generate( "350+440*0.5:100", "/tmp/serverconnecttestwav.wav" )
     prtp.projectrtp.tone.generate( "350+440*0.5:100", "/tmp/otherserverconnecttestwav.wav" )
 
@@ -48,16 +51,13 @@ describe( "server connect interface", () => {
     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)

package/test/interface/projectrtpmix.js

@@ -172,6 +172,101 @@ describe( "channel mix", function() {
 
   } )
 
+
+  it( "mix 2 channels then unmix then mix again", async function() {
+
+    this.timeout( 6000 )
+    this.slow( 5000 )
+
+    const endpointa = dgram.createSocket( "udp4" )
+    const endpointb = dgram.createSocket( "udp4" )
+
+    const endpointapkcount = [ 0, 0, 0, 0 ]
+    const endpointbpkcount = [ 0, 0, 0, 0 ]
+
+    endpointa.on( "message", function( msg ) {
+      endpointapkcount[ 0x7f & msg[ 50 ] ]++
+      expect( msg.length ).to.equal( 172 )
+      expect( 0x7f & msg [ 1 ] ).to.equal( 0 )
+    } )
+
+    endpointb.on( "message", function( msg ) {
+      endpointbpkcount[ 0x7f & msg[ 50 ] ]++
+      expect( msg.length ).to.equal( 172 )
+      expect( 0x7f & msg [ 1 ] ).to.equal( 0 )
+    } )
+
+    endpointa.bind()
+    await new Promise( ( resolve ) => { endpointa.on( "listening", function() { resolve() } ) } )
+
+    endpointb.bind()
+    await new Promise( ( resolve ) => { endpointb.on( "listening", function() { resolve() } ) } )
+
+    let promisearesolve, promisebresolve
+    const promisea = new Promise( r => promisearesolve = r )
+    const promiseb = new Promise( r => promisebresolve = r )
+    
+    const channela = await projectrtp.openchannel( { "remote": { "address": "localhost", "port": endpointa.address().port, "codec": 0 } }, function( d ) {
+      if( "close" === d.action ) {
+        promisearesolve()
+      }
+    } )
+
+    const channelb = await projectrtp.openchannel( { "remote": { "address": "localhost", "port": endpointb.address().port, "codec": 0 } }, function( d ) {
+      if( "close" === d.action ) {
+        promisebresolve()
+      }
+    } )
+
+    /* mix */
+    expect( channela.mix( channelb ) ).to.be.true
+    /* Now, when we send UDP on endpointb it  passes through our mix then arrives at endpointa */
+    let dataa = Buffer.alloc( 172 - 12 ).fill( 0 )
+    let datab = Buffer.alloc( 172 - 12 ).fill( 1 )
+
+    for( let i = 0;  50 > i; i ++ ) {
+      sendpk( i, i, channela.local.port, endpointa, dataa )
+      sendpk( i, i, channelb.local.port, endpointb, datab )
+    }
+
+    /* 1S for 50 packets to get through, 0.5 seconds to allow all through jitter buffers */
+    await new Promise( ( resolve ) => { setTimeout( () => resolve(), 1700 ) } )
+
+    channela.direction( { send: true, recv: false } )
+    expect( channelb.unmix( channela ) ).to.be.true
+    channelb.play( { "loop": true, "files": [
+      { "wav": "/tmp/ukringing.wav" } ] } )
+
+    await new Promise( ( resolve ) => { setTimeout( () => resolve(), 200 ) } )
+
+    channela.direction( { send: true, recv: true } )
+    expect( channelb.mix( channela ) ).to.be.true
+    
+
+    dataa = Buffer.alloc( 172 - 12 ).fill( 2 )
+    datab = Buffer.alloc( 172 - 12 ).fill( 3 )
+    for( let i = 0;  50 > i; i ++ ) {
+      sendpk( i, i, channela.local.port, endpointa, dataa )
+      sendpk( i, i, channelb.local.port, endpointb, datab )
+    }
+
+    await new Promise( ( resolve ) => { setTimeout( () => resolve(), 1700 ) } )
+
+    channelb.close()
+    channela.close()
+    endpointa.close()
+    endpointb.close()
+
+    /* have we cleaned up? */
+    await Promise.all( [ promisea, promiseb ] )
+
+    expect( endpointapkcount[ 1 ] ).to.be.within( 49, 51 )
+    expect( endpointapkcount[ 3 ] ).to.be.within( 49, 51 )
+    expect( endpointbpkcount[ 0 ] ).to.be.within( 49, 51 )
+    expect( endpointbpkcount[ 2 ] ).to.be.within( 49, 51 )
+
+  } )
+
   it( "mix 2 channels then close b", async function() {
 
     this.timeout( 3000 )