@babblevoice/projectrtp 2.5.22 → 2.5.26

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.4.20_beta1 . --push
+docker buildx build --platform linux/amd64,linux/arm64 -t tinpotnick/projectrtp:2.5.23_beta4 . --push
 ```
 
 ## Example scripts

package/lib/server.js

@@ -277,7 +277,15 @@ class channel {
 
     options.channel = "open"
 
-    const resolvepromise = new Promise( ( resolve ) => {
+    const resolvepromise = new Promise( ( resolve, reject ) => {
+
+      if ( 0 < nodes.size ) {
+        const node = randomenode( options.nodeinstance )
+        const request = JSON.parse( JSON.stringify( options ) )
+        request.channel = "open"
+        channel._createforlisten( request, node, cb, resolve, reject )
+        return
+      }
 
       const newchannel = new channel()
       if( cb ) newchannel.em.on( "all", cb )

package/package.json

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

package/src/projectrtpchannel.cpp

@@ -655,7 +655,7 @@ bool projectrtpchannel::checkfordtmf( rtppacket *src ) {
   uint16_t sn = src->getsequencenumber();
 
   if( 0 != this->rfc2833pt &&
-      src->getpayloadtype() == this->rfc2833pt ) {
+      src->getpayloadtype() == RFC2833PAYLOADTYPE ) {
 
     if( src->getpayloadlength() >= 4 ) {
       /* We have to look for DTMF events handling issues like missing events - such as the marker or end bit */
@@ -811,7 +811,8 @@ void projectrtpchannel::correctaddress( void ) {
  */
 void projectrtpchannel::correctssrc( uint32_t ssrc ) {
   if( !this->receivedrtp ) {
-    this->receivedrtp = true;
+    /* allow settling */
+    if( this->inbuff->getpushed() > 5 )this->receivedrtp = true;
     this->ssrcin = ssrc;
   }
 }
@@ -871,15 +872,24 @@ void projectrtpchannel::readsomertp( void ) {
           goto readsomemore;
         }
 
-        if( !this->recv ) {
+        /* TODO ZRTP? */
+        if( buf->getpacketextension() ) {
           this->receivedpkskip++;
           goto readsomemore;
         }
 
-        this->tickswithnortpcount = 0;
-
         this->correctaddress();
+
+        if( !this->recv ) {
+          this->receivedpkskip++;
+          goto readsomemore;
+        }
+
+        /*
+        after speaking with Magrathea - more streams are changing ssrc without notice mid-stream
+        for now do not check.
         this->correctssrc( buf->getssrc() );
+        */
         
         if( this->confirmedrtpsenderendpoint != this->rtpsenderendpoint ) {
           /* After the first packet - we only accept data from the verified source */
@@ -887,10 +897,14 @@ void projectrtpchannel::readsomertp( void ) {
           goto readsomemore;
         }
 
+        /*
         if( buf->getssrc() != this->ssrcin ) {
           this->receivedpkskip++;
           goto readsomemore;
         }
+        */
+
+        this->tickswithnortpcount = 0;
 
         /* dynamic payload types */
         auto pt = buf->getpayloadtype();

package/src/projectrtpchannelmux.cpp

@@ -325,8 +325,8 @@ void projectchannelmux::postrtpdata( projectrtpchannelptr srcchan, projectrtpcha
     return;
   }
 
-  if( src->getpayloadtype() == srcchan->rfc2833pt ) {
-    dst->setpayloadtype( srcchan->rfc2833pt );
+  if( src->getpayloadtype() == RFC2833PAYLOADTYPE ) {
+    dst->setpayloadtype( dstchan->rfc2833pt );
     dst->copy( src );
   } else {
     srcchan->incodec << codecx::next;

package/src/projectrtpcodecx.cpp

@@ -438,10 +438,16 @@ Search for the relevent data and convert as necessary.
 */
 bool codecx::requirewideband( void ) {
   if( 0 != this->l1616kref.size() && !this->l1616kref.isdirty() ) return true;
+
+  if( 0 != this->l168kref.size() && !this->l168kref.isdirty() ) {
+    return this->l16lowtowideband();
+  }
+
   if( this->g722tol16() ) return true;
-  if( !this->g711tol16() )
-  {
-    if( !this->ilbctol16() ) return false;
+  if( !this->g711tol16() ) {
+    if( !this->ilbctol16() ) {
+      return false;
+    }
   }
 
   return this->l16lowtowideband();
@@ -477,9 +483,13 @@ bool codecx::l16widetonarrowband( void ) {
 ## requirenarrowband
 Search for the relevent data and convert as necessary.
 */
-bool codecx::requirenarrowband( void )
-{
+bool codecx::requirenarrowband( void ) {
   if( 0 != this->l168kref.size() && !this->l168kref.isdirty() ) return true;
+
+  if( 0 != this->l1616kref.size() && !this->l1616kref.isdirty() ) {
+    return this->l16widetonarrowband();
+  }
+
   if( this->g711tol16() ) return true;
   if( this->ilbctol16() ) return true;
   this->g722tol16();

package/src/projectrtpsoundfile.cpp

@@ -101,6 +101,7 @@ soundfilereader::soundfilereader( std::string &url ) :
   blocksize( L16NARROWBANDBYTES ),
   badheader( false ),
   headerread( false ),
+  bodyread( false ),
   initseekmseconds( 0 ),
   ploadtype( L168KPAYLOADTYPE ) {
 
@@ -127,15 +128,13 @@ soundfilereader::soundfilereader( std::string &url ) :
   /* read */
   if ( aio_read( &this->cbwavheader ) == -1 ) {
     fprintf( stderr, "aio_read read of header failed in soundfile\n" );
-    close( this->file );
-    this->file = -1;
+    this->badheader = true;
     return;
   }
 
   if ( aio_read( &this->cbwavblock[ this->currentcbindex ] ) == -1 ) {
     fprintf( stderr, "aio_read read of block failed in soundfile" );
-    close( this->file );
-    this->file = -1;
+    this->bodyread = true;
     return;
   }
 
@@ -153,8 +152,7 @@ soundfilereader::~soundfilereader() {
 # create
 Shared pointer version of us.
 */
-soundfilereader::pointer soundfilereader::create( std::string url )
-{
+soundfilereader::pointer soundfilereader::create( std::string url ) {
   return pointer( new soundfilereader( url ) );
 }
 
@@ -177,16 +175,17 @@ bool soundfilereader::read( rawsound &out ) {
 
   if( this->badheader ) {
     fprintf( stderr, "Bad wav file\n" );
-    return false;
-  }
-
-  if( !this->headerread &&
-      aio_error( &this->cbwavheader ) == EINPROGRESS ) {
-    fprintf( stderr, "Read of soundfile wav header has not completed\n" );
-    return false;
+    out.zero();
+    return true;
   }
 
   if( !this->headerread ) {
+    if( aio_error( &this->cbwavheader ) == EINPROGRESS ) {
+      fprintf( stderr, "Read of soundfile wav header has not completed\n" );
+      out.zero();
+      return true;
+    }
+
     if( 'W' != this->ourwavheader.wave_header[ 0 ] ) {
       this->badheader = true;
     }
@@ -197,7 +196,9 @@ bool soundfilereader::read( rawsound &out ) {
         break;
       default:
         fprintf( stderr, "Bad sample rate in wav\n" );
-        return false;
+        this->badheader = true;
+        out.zero();
+        return true;
     }
 
     this->ploadtype = L168KPAYLOADTYPE;
@@ -211,7 +212,9 @@ bool soundfilereader::read( rawsound &out ) {
           this->ploadtype = L1616KPAYLOADTYPE;
           this->blocksize = L16WIDEBANDBYTES;
         } else {
-          return false;
+          this->badheader = true;
+          out.zero();
+          return true;
         }
         break;
       }
@@ -236,8 +239,10 @@ bool soundfilereader::read( rawsound &out ) {
         break;
       }
       default: {
+        this->badheader = true;
+        out.zero();
         fprintf( stderr, "Bad audio format in wav\n" );
-        return false;
+        return true;
       }
     }
     this->headerread = true;
@@ -245,12 +250,15 @@ bool soundfilereader::read( rawsound &out ) {
 
   if( this->initseekmseconds > 0 ) {
     this->setposition( this->initseekmseconds );
+    out.zero();
     return true;
   }
 
   if( aio_error( &this->cbwavblock[ this->currentcbindex ] ) == EINPROGRESS ) {
     fprintf( stderr, "Read of soundfile wav block has not completed\n" );
-    return false;
+    /* return some silence */
+    out.zero();
+    return true;
   }
 
   /* success? */
@@ -258,12 +266,20 @@ bool soundfilereader::read( rawsound &out ) {
 
   if( -1 == numbytes ) {
     fprintf( stderr, "Bad call to aio_return\n" );
-    return false;
+    this->bodyread = true;
+    out.zero();
+    return true;
   }
 
   uint8_t *current = ( uint8_t * ) this->cbwavblock[ this->currentcbindex ].aio_buf;
   out = rawsound( current, this->blocksize, this->ploadtype, this->ourwavheader.sample_rate );
 
+  if( numbytes < this->blocksize ) {
+    this->bodyread = true;
+    /* TODO if we get a partial read we probably should not zero that part */
+    out.zero();
+  }
+
   /* Get the next block reading */
   auto lastreadoffset = this->cbwavblock[ this->currentcbindex ].aio_offset;
   this->currentcbindex = ( this->currentcbindex + 1 ) % SOUNDFILENUMBUFFERS;
@@ -277,10 +293,10 @@ bool soundfilereader::read( rawsound &out ) {
   this->cbwavblock[ this->currentcbindex ].aio_nbytes = this->blocksize;
 
   /* read next block */
-  if ( aio_read( &this->cbwavblock[ this->currentcbindex ] ) == -1 ) {
-    close( this->file );
-    this->file = -1;
-    return false;
+  if ( !this->bodyread && aio_read( &this->cbwavblock[ this->currentcbindex ] ) == -1 ) {
+    this->bodyread = true;
+    out.zero();
+    return true;
   }
 
   return true;
@@ -291,11 +307,10 @@ bool soundfilereader::read( rawsound &out ) {
 Have we completed reading the file.
 */
 bool soundfilereader::complete( void ) {
-  if( this->badheader || !this->headerread ) {
-    return false;
-  }
-
-  return ( this->cbwavblock[ this->currentcbindex ].aio_offset + this->blocksize ) > this->ourwavheader.chunksize;
+  if( this->badheader ) return true;
+  if( !this->headerread ) return false;
+  if( -1 == this->file ) return true;
+  return this->bodyread;
 }
 
 /*!md
@@ -315,35 +330,31 @@ void soundfilereader::setposition( long mseconds ) {
     this->headerread = true;
   }
 
+  if( !this->headerread ) {
+    this->initseekmseconds = mseconds;
+    return;
+  }
 
-  if( this->headerread ) {
-    while( AIO_NOTCANCELED == aio_cancel( this->file, NULL ) );
+  this->bodyread = false;
+  while( AIO_NOTCANCELED == aio_cancel( this->file, NULL ) );
 
-    this->currentcbindex = ( this->currentcbindex + 1 ) % SOUNDFILENUMBUFFERS;
+  this->currentcbindex = ( this->currentcbindex + 1 ) % SOUNDFILENUMBUFFERS;
 
-    off_t our_aio_offset = ( this->ourwavheader.bit_depth /*16*/ / 8 ) * ( this->ourwavheader.sample_rate / 1000 ) * mseconds; /* bytes per sample */
-    our_aio_offset = ( our_aio_offset / this->blocksize ) * this->blocksize; /* realign to the nearest block */
-    our_aio_offset += sizeof( wavheader );
+  off_t our_aio_offset = ( this->ourwavheader.bit_depth /*16*/ / 8 ) * ( this->ourwavheader.sample_rate / 1000 ) * mseconds; /* bytes per sample */
+  our_aio_offset = ( our_aio_offset / this->blocksize ) * this->blocksize; /* realign to the nearest block */
+  our_aio_offset += sizeof( wavheader );
 
-    for( auto i = 0; i < SOUNDFILENUMBUFFERS; i++ ) {
-      memset( &this->cbwavblock[ i ], 0, sizeof( aiocb ) );
-      this->cbwavblock[ i ].aio_nbytes = L16WIDEBANDBYTES;
-      this->cbwavblock[ i ].aio_fildes = this->file;
-      this->cbwavblock[ i ].aio_offset = sizeof( wavheader ) + our_aio_offset + ( i * L16WIDEBANDBYTES );
-      this->cbwavblock[ i ].aio_buf = this->buffer + ( i * L16WIDEBANDBYTES );
-    }
-
-    /* read ahead */
-    this->currentcbindex = 0;
-    if ( aio_read( &this->cbwavblock[ this->currentcbindex ] ) == -1 ) {
-      close( this->file );
-      this->file = -1;
-    }
+  for( auto i = 0; i < SOUNDFILENUMBUFFERS; i++ ) {
+    this->cbwavblock[ ( this->currentcbindex + i ) % SOUNDFILENUMBUFFERS ].aio_offset = our_aio_offset + ( i * L16WIDEBANDBYTES );
+  }
 
-    this->initseekmseconds = 0;
-  } else {
-    this->initseekmseconds = mseconds;
+  /* read ahead */
+  if ( aio_read( &this->cbwavblock[ this->currentcbindex ] ) == -1 ) {
+    this->bodyread = true;
   }
+
+  this->initseekmseconds = 0;
+
 }
 
 long soundfilereader::offtomsecs( void ) {
@@ -423,8 +434,7 @@ soundfilewriter::~soundfilewriter() {
 # create
 Shared pointer for writing.
 */
-soundfilewriter::pointer soundfilewriter::create( std::string &url, int16_t numchannels, int32_t samplerate )
-{
+soundfilewriter::pointer soundfilewriter::create( std::string &url, int16_t numchannels, int32_t samplerate ) {
   return pointer( new soundfilewriter( url, numchannels, samplerate ) );
 }
 

package/src/projectrtpsoundfile.h

@@ -119,6 +119,7 @@ private:
   int blocksize;
   bool badheader;
   bool headerread;
+  bool bodyread;
   long initseekmseconds;
   int ploadtype;
 };

package/test/interface/projectrtpchannel.js

@@ -5,6 +5,7 @@ const dgram = require( "dgram" )
 const projectrtp = require( "../../index" ).projectrtp
 const node = require( "../../lib/node" ).interface
 const server = require( "../../lib/server" ).interface
+const rtputil = require( "../util/rtp" )
 
 /**
  * Common channel tester
@@ -360,15 +361,9 @@ describe( "rtpchannel", function() {
     let totalsndiff = 0
     let totaltsdiff = 0
     server.on( "message", function( msg ) {
-      let sn = 0
-      sn = msg[ 2 ] << 8
-      sn = sn | msg[ 3 ]
-
-      let ts = 0
-      ts = msg[ 4 ] << 24
-      ts = ts | ( msg[ 5 ] << 16 )
-      ts = ts | ( msg[ 6 ] << 8 )
-      ts = ts | msg[ 7 ]
+      const pk = rtputil.parsepk( msg )
+      const sn = pk.sn
+      const ts = pk.ts
 
       if( -1 !== lastsn ) {
         totalsndiff += sn - lastsn - 1

package/test/interface/projectrtpdtmf.js

@@ -66,16 +66,14 @@ function sendpk( sn, ts, sendtime, dstport, server, pt = 0, ssrc ) {
 /*
 
 */
-function senddtmf( sn, ts, sendtime, dstport, server, endofevent, ev ) {
+function senddtmf( sn, ts, sendtime, dstport, server, endofevent, ev, pt = 101 ) {
 
   return setTimeout( () => {
     const ssrc = 25
-    const pklength = 58
+    const pklength = 16
 
     const header = Buffer.alloc( pklength )
 
-    const pt = 101
-
     header.writeUInt8( 0x80 )
     header.writeUInt8( pt, 1 ) // payload type
     header.writeUInt16BE( ( sn ) % ( 2**16 ), 2 )
@@ -715,6 +713,149 @@ describe( "dtmf", function() {
   } )
 
 
+  it( "mix 2 channels - pcmu <-> pcma and send DTMF different 2833 pt", async function() {
+
+    /*
+      When mixing 2 channels, we expect the second leg to receive the 2833 packets
+      and our server to emit events indicating the DTMF on the first channel.
+    */
+    this.timeout( 3000 )
+    this.slow( 2000 )
+
+    const endpointa = dgram.createSocket( "udp4" )
+    const endpointb = dgram.createSocket( "udp4" )
+
+    const receivedmessages = []
+
+    let endpointapkcount = 0
+    let endpointbpkcount = 0
+    let dtmfpkcount = 0
+
+    endpointa.on( "message", function( msg ) {
+      endpointapkcount++
+      expect( msg.length ).to.equal( 172 )
+      expect( 0x7f & msg [ 1 ] ).to.equal( 0 )
+    } )
+
+    endpointb.on( "message", function( msg ) {
+      endpointbpkcount++
+      if( 101 == ( 0x7f & msg [ 1 ] ) ) {
+        dtmfpkcount++
+      } else {
+        expect( msg.length ).to.equal( 172 )
+        expect( 0x7f & msg [ 1 ] ).to.equal( 8 )
+        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, "rfc2833pt": 127 } }, function( d ) {
+      receivedmessages.push( d )
+
+      if( "close" === d.action ) channelb.close()
+    } )
+
+    const channelb = await projectrtp.openchannel( { "remote": { "address": "localhost", "port": endpointb.address().port, "codec": 8, "rfc2833pt": 101 } }, function( d ) {
+      if( "close" === d.action ) done()
+    } )
+
+    /* mix */
+    expect( channela.mix( channelb ) ).to.be.true
+
+    /* send a packet every 20mS x 50 */
+    sendpk( 0, 0, 0, channela.local.port, endpointa )
+    sendpk( 1, 1*160, 1*20, channela.local.port, endpointa )
+    sendpk( 2, 2*160, 2*20, channela.local.port, endpointa )
+    sendpk( 3, 3*160, 3*20, channela.local.port, endpointa )
+    sendpk( 4, 4*160, 4*20, channela.local.port, endpointa )
+    sendpk( 5, 5*160, 5*20, channela.local.port, endpointa )
+    sendpk( 6, 6*160, 6*20, channela.local.port, endpointa )
+    sendpk( 7, 7*160, 7*20, channela.local.port, endpointa )
+    sendpk( 8, 8*160, 8*20, channela.local.port, endpointa )
+    sendpk( 9, 9*160, 9*20, channela.local.port, endpointa )
+    sendpk( 10, 10*160, 10*20, channela.local.port, endpointa )
+    sendpk( 11, 11*160, 11*20, channela.local.port, endpointa )
+    sendpk( 12, 12*160, 12*20, channela.local.port, endpointa )
+
+    senddtmf( 13, 13*160, 13*20, channela.local.port, endpointa, false, "4", 127 )
+    sendpk( 14, 13*160, 13*20, channela.local.port, endpointa, 0 )
+    sendpk( 15, 14*160, 14*20, channela.local.port, endpointa, 0 )
+    senddtmf( 16, (15*160)+10, (15*20)+10, channela.local.port, endpointa, false, "4", 127 )
+    sendpk( 17, 15*160, 15*20, channela.local.port, endpointa, 0 )
+    sendpk( 18, 16*160, 16*20, channela.local.port, endpointa, 0 )
+    senddtmf( 19, (17*160)+20, (17*20)+20, channela.local.port, endpointa, true, "4", 127 )
+    sendpk( 20, 17*160, 17*20, channela.local.port, endpointa, 0 )
+    sendpk( 21, 18*160, 18*20, channela.local.port, endpointa, 0 )
+    senddtmf( 22, (18*160)+30, (18*20)+30, channela.local.port, endpointa, true, "4", 127 )
+    sendpk( 23, 19*160, 19*20, channela.local.port, endpointa, 0 )
+    sendpk( 24, 20*160, 20*20, channela.local.port, endpointa, 0 )
+    sendpk( 25, 21*160, 21*20, channela.local.port, endpointa, 0 )
+    sendpk( 26, 22*160, 22*20, channela.local.port, endpointa, 0 )
+    sendpk( 27, 23*160, 23*20, channela.local.port, endpointa, 0 )
+    sendpk( 28, 24*160, 24*20, channela.local.port, endpointa, 0 )
+    sendpk( 29, 25*160, 25*20, channela.local.port, endpointa, 0 )
+
+    senddtmf( 30, 26*160, 26*20, channela.local.port, endpointa, false, "5", 127 )
+    sendpk( 31, 26*160, 26*20, channela.local.port, endpointa, 0 )
+    sendpk( 32, 27*160, 27*20, channela.local.port, endpointa, 0 )
+    senddtmf( 33, (27*160)+10, (27*20)+10, channela.local.port, endpointa, false, "5", 127 )
+    sendpk( 34, 28*160, 28*20, channela.local.port, endpointa, 0 )
+    sendpk( 35, 29*160, 28*20, channela.local.port, endpointa, 0 )
+    senddtmf( 36, (28*160)+20, (28*20)+20, channela.local.port, endpointa, true, "5", 127 )
+    sendpk( 37, 30*160, 29*20, channela.local.port, endpointa, 0 )
+    sendpk( 38, 31*160, 30*20, channela.local.port, endpointa, 0 )
+
+    senddtmf( 39, (38*160)+30, (30*20)+30, channela.local.port, endpointa, true, "5", 127 )
+    sendpk( 40, 32*160, 31*20, channela.local.port, endpointa, 0 )
+    sendpk( 41, 33*160, 32*20, channela.local.port, endpointa, 0 )
+
+    sendpk( 42, 34*160, 33*20, channela.local.port, endpointa, 0 )
+    sendpk( 43, 35*160, 34*20, channela.local.port, endpointa, 0 )
+    sendpk( 44, 36*160, 35*20, channela.local.port, endpointa, 0 )
+    sendpk( 45, 37*160, 36*20, channela.local.port, endpointa, 0 )
+    sendpk( 46, 38*160, 37*20, channela.local.port, endpointa, 0 )
+    sendpk( 47, 39*160, 38*20, channela.local.port, endpointa, 0 )
+    sendpk( 48, 40*160, 39*20, channela.local.port, endpointa, 0 )
+    sendpk( 49, 51*160, 40*20, channela.local.port, endpointa, 0 )
+
+    await new Promise( ( r ) => { setTimeout( () => r(), 1400 ) } )
+
+    channela.close()
+    endpointa.close()
+    endpointb.close()
+
+    await finished
+
+    expect( endpointapkcount ).to.be.within( 30, 51 )
+    expect( endpointbpkcount ).to.be.within( 30, 51 )
+
+    expect( receivedmessages.length ).to.equal( 5 )
+
+    expect( dtmfpkcount ).to.be.within( 4, 8 )
+
+    expect( receivedmessages[ 0 ].action ).to.equal( "mix" )
+    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" )
+    expect( receivedmessages[ 1 ].event ).to.equal( "4" )
+    expect( receivedmessages[ 2 ].event ).to.equal( "5" )
+    expect( receivedmessages[ 3 ].event ).to.equal( "finished" )
+
+  } )
+
+
   it( "mix 3 channels - pcmu <-> pcma and ilbc and send DTMF", async function() {
 
     this.timeout( 3000 )

package/test/interface/projectrtpmix.js

@@ -5,9 +5,8 @@ const expect = require( "chai" ).expect
 const dgram = require( "dgram" )
 const projectrtp = require( "../../index.js" ).projectrtp
 
-function sendpk( sn, sendtime, dstport, server, data = undefined ) {
+function sendpk( sn, sendtime, dstport, server, data = undefined, pt = 0, ssrc = 25 ) {
 
-  const ssrc = 25
   const pklength = 172
 
   return setTimeout( () => {
@@ -27,8 +26,11 @@ function sendpk( sn, sendtime, dstport, server, data = undefined ) {
     subheader.writeUInt32BE( ts, 2 )
     subheader.writeUInt32BE( ssrc, 6 )
 
+    const header = Buffer.from( [ 0x80, 0x00 ] )
+    header.writeUInt8( pt, 1 ) // payload type
+
     const rtppacket = Buffer.concat( [
-      Buffer.from( [ 0x80, 0x00 ] ),
+      header,
       subheader,
       payload ] )
 
@@ -101,6 +103,75 @@ describe( "channel mix", function() {
 
   } )
 
+  it( "basic mix 2 channels with start 2 packets wrong payload type", 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( msg.length ).to.equal( 172 )
+      expect( 0x7f & msg [ 1 ] ).to.equal( 8 )
+    } )
+
+    endpointb.on( "message", function( msg ) {
+      endpointbpkcount++
+
+      expect( msg.length ).to.equal( 172 )
+      expect( 0x7f & msg [ 1 ] ).to.equal( 0 )
+      endpointb.send( msg, channelb.local.port, "localhost" )
+    } )
+
+    endpointa.bind()
+    await new Promise( ( r ) => { endpointa.on( "listening", function() { r() } ) } )
+
+    endpointb.bind()
+    await new Promise( ( r ) => { endpointb.on( "listening", function() { r() } ) } )
+
+    let done
+    const finished = new Promise( ( r ) => { done = r } )
+
+    const channela = await projectrtp.openchannel( {}, function( d ) {
+      if( "close" === d.action ) channelb.close()
+    } )
+
+    const channelb = await projectrtp.openchannel( { "remote": { "address": "localhost", "port": endpointb.address().port, "codec": 0 } }, function( d ) {
+      if( "close" === d.action ) done()
+    } )
+
+    /* mix */
+    expect( channela.mix( channelb ) ).to.be.true
+
+    /* a problem was highlighted that would remote would be called before rtp stream was updated */
+    channela.remote( { "address": "localhost", "port": endpointa.address().port, "codec": 8 } )
+
+    sendpk( 0, 0, channela.local.port, endpointa )
+    sendpk( 1, 1, channela.local.port, endpointa )
+
+    /* Now, when we send UDP on endpointb it  passes through our mix then arrives at endpointa */
+    for( let i = 2;  50 > i; i ++ ) {
+      sendpk( i, i, channela.local.port, endpointa, undefined, 8, 27 )
+    }
+
+    await new Promise( ( resolve ) => { setTimeout( () => resolve(), 1300 ) } )
+
+    channela.close()
+    endpointa.close()
+    endpointb.close()
+
+    expect( endpointapkcount ).to.be.within( 30, 51 )
+    expect( endpointbpkcount ).to.be.within( 30, 51 )
+
+    await finished
+
+  } )
+
 
   it( "mix 2 channels then unmix", async function() {
 
@@ -900,9 +971,9 @@ describe( "channel mix", function() {
     endpointb.close()
     endpointc.close()
 
-    expect( endpointapkcountzero ).to.be.within( 65, 75 )
-    expect( endpointbpkcountzero ).to.be.within( 65, 75 )
-    expect( endpointcpkcountzero ).to.be.within( 65, 75 )
+    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( endpointcpkcountnotzero ).to.be.below( 2 )

package/test/interface/projectrtpsound.js

@@ -1,4 +1,9 @@
 
+
+//const npl = require( "nodeplotlib" )
+// eslint-disable-next-line no-unused-vars
+const npl = { plot: ( /** @type {any} */ a ) => {} }
+
 /*
 Note, timing in Node doesn't appear that accurate. This requires more work if
 we can measure jitter. The pcap traces show 0.01 mS jitter but we are getting 4mS
@@ -8,7 +13,48 @@ when playing in node. For now, leave checking of timing.
 const expect = require( "chai" ).expect
 const fs = require( "fs" )
 const dgram = require( "dgram" )
-const prtp = require( "../../index.js" )
+const prtp = require( "../../index" )
+const rtputils = require( "../util/rtp" )
+
+function gensignal( hz, datalength, magnitude ) {
+
+  const y = Buffer.alloc( datalength * 2 )
+
+  for( let i = 0; i < datalength; i ++ ) {
+    y.writeInt16LE( Math.sin( i * ( Math.PI * 2 * ( 1 / 8000 ) ) * hz ) * magnitude, i * 2 )
+  }
+
+  return y
+}
+
+/**
+ * 
+ * @param { Array< number > } inarray
+ * @returns { Int16Array }
+ */
+function pcmutolinear( inarray ) {
+  const out = new Int16Array( inarray.length )
+  for( let i = 0; i < inarray.length; i++ ) {
+    out[ i ] = prtp.projectrtp.codecx.pcmu2linear16( inarray[ i ] )
+  }
+
+  return out
+}
+
+/**
+ * Limitation of not parsing ccrc.
+ * @param { Buffer } packet
+ * @return { object }
+ */
+function parsertppk( packet ) {
+  return {
+    sn: packet.readUInt16BE( 2 ),
+    ts: packet.readUInt32BE( 4 ),
+    pt: packet.readUInt8( 1 ) & 0x7f,
+    ssrc: packet.readUInt32BE( 8 ),
+    payload: new Uint8Array( packet.slice( 12 ) )
+  }
+}
 
 /**
  * @param { number } samples
@@ -75,13 +121,16 @@ describe( "rtpsound", function() {
     /* create our RTP/UDP endpoint */
     const server = dgram.createSocket( "udp4" )
     let receviedpkcount = 0
+    let receivedcorrectvalue = 0
 
     /** @type { prtp.channel } */
     let channel
 
     server.on( "message", function( msg ) {
       /* This is PCMA encoded data from our flat file */
-      expect( msg[ 16 ] ).to.equal( 0x99 )
+      const pk = parsertppk( msg )
+      /* we can also receive silence */
+      if( 228 == pk.payload[ 10 ] ) receivedcorrectvalue++
       receviedpkcount++
     } )
 
@@ -114,10 +163,11 @@ describe( "rtpsound", function() {
 
     await finished
 
-    expect( receviedpkcount ).to.be.within( 48, 50 )
+    expect( receviedpkcount ).to.be.within( 48, 60 )
+    expect( receivedcorrectvalue ).to.be.within( 48, 60 )
   } )
 
-  it( "loop in soundsoup and check udp data", function( done ) {
+  it( "loop in soundsoup and check udp data", async function() {
 
     this.timeout( 6000 )
     this.slow( 5000 )
@@ -125,45 +175,52 @@ describe( "rtpsound", function() {
     /* create our RTP/UDP endpoint */
     const server = dgram.createSocket( "udp4" )
     let receviedpkcount = 0
-    let channel
+    let correctvalcount = 0
+    let done, cleanedup
+    const completpromise = new Promise( resolve => done = resolve )
+    const cleanedpromise = new Promise( resolve => cleanedup = resolve )
 
     server.on( "message", function( msg ) {
 
       /* This is PCMA encoded data from our flat file */
-      expect( msg[ 16 ] ).to.equal( 0x99 )
+      if( 228 == msg[ 16 ] ) correctvalcount++
       receviedpkcount++
       /*
       flat.wav has 1 S of audio (8000 samples). 160 per packet compressed = 320 PCM.
       200 packets is 64000 samples so this must have looped to work.
       */
       if( 220 < receviedpkcount ) {
-        channel.close()
+        done()
       }
     } )
 
     server.bind()
-    server.on( "listening", async function() {
+    await new Promise( resolve => server.on( "listening", resolve ) )
 
-      const ourport = server.address().port
+    const ourport = server.address().port
 
-      channel = await prtp.projectrtp.openchannel( { "remote": { "address": "localhost", "port": ourport, "codec": 0 } }, function( d ) {
+    const channel = await prtp.projectrtp.openchannel( { "remote": { "address": "localhost", "port": ourport, "codec": 0 } }, function( d ) {
+      if( "close" == d.action ) cleanedup()
+    } )
 
-        if( "close" === d.action ) {
-          server.close()
-          done()
-        }
-      } )
+    expect( channel.play( {
+      "loop": true,
+      "files": [
+        { "wav": "/tmp/flat.wav" }
+      ]
+    } ) ).to.be.true
 
-      expect( channel.play( {
-        "loop": true,
-        "files": [
-          { "wav": "/tmp/flat.wav" }
-        ]
-      } ) ).to.be.true
+    await completpromise
 
-    } )
+    channel.close()
+    server.close()
+
+    await cleanedpromise
+    expect( correctvalcount ).to.be.above( 210 )
   } )
 
+  /* I have also used this test to play with file codec conversion to check it is working properly */
+
   it( "loop in soundsoup file and check udp data", function( done ) {
 
     this.timeout( 6000 )
@@ -174,10 +231,12 @@ describe( "rtpsound", function() {
     let receviedpkcount = 0
     let channel
 
+    let receivedpcmu = []
     server.on( "message", function( msg ) {
+      receivedpcmu = [ ...receivedpcmu,  ...Array.from( pcmutolinear( rtputils.parsepk( msg ).payload ) ) ]
 
       /* This is PCMA encoded data from our flat file */
-      expect( msg[ 16 ] ).to.equal( 0x99 )
+      //expect( msg[ 16 ] ).to.equal( 0x99 )
 
       receviedpkcount++
       /*
@@ -199,13 +258,20 @@ describe( "rtpsound", function() {
 
         if( "close" === d.action ) {
           server.close()
+
+          npl.plot( [ {
+            y: receivedpcmu,
+            type: "scatter"
+          } ] )
+
+
           done()
         }
       } )
 
       expect( channel.play( {
         "files": [
-          { "loop": true, "wav": "/tmp/flat.wav" }
+          { "loop": true, "wav": "/tmp/440sine.wav" }
         ]
       } ) ).to.be.true
 
@@ -220,6 +286,7 @@ describe( "rtpsound", function() {
     /* create our RTP/UDP endpoint */
     const server = dgram.createSocket( "udp4" )
     let receviedpkcount = 0
+    let receviedgoodcount = 0
 
     /** @type { prtp.channel } */
     let channel
@@ -232,8 +299,7 @@ describe( "rtpsound", function() {
       receviedpkcount++
 
       /* This is PCMA encoded data from our flat file */
-      expect( msg[ 17 ] ).to.equal( 153 /* 0x99 */ )
-      expect( msg[ 150 ] ).to.equal( 153 /* 0x99 */ )
+      if( 228 == msg[ 17 ] ) receviedgoodcount++
     } )
 
     server.bind()
@@ -258,7 +324,8 @@ describe( "rtpsound", function() {
       8000 samples looped twice. 100 packets (50 packets/S).
     */
 
-    expect( receviedpkcount ).to.be.within( 97, 100 )
+    expect( receviedpkcount ).to.above( 90 )
+    expect( receviedgoodcount ).to.be.above( 90 )
   } )
 
   it( "slightly more complex soundsoup file and check udp data", async function() {
@@ -270,73 +337,61 @@ describe( "rtpsound", function() {
     const server = dgram.createSocket( "udp4" )
     let receviedpkcount = 0
 
-    /** @type { prtp.channel } */
-    let channel
+    let enoughpackets
+    const enoughpacketspromise = new Promise( resolve => enoughpackets = resolve )
 
     let done
     const finished = new Promise( ( r ) => { done = r } )
 
+    // eslint-disable-next-line complexity
     server.on( "message", function( msg ) {
 
       receviedpkcount++
-
-      /* This is PCMA encoded data from our soundsoup:
-      { "loop": 2, "files": [
-        { "wav": "/tmp/flat.wav", "loop": 2 },
-        { "wav": "/tmp/flat2.wav" },
-        { "wav": "/tmp/flat.wav" },
-        { "wav": "/tmp/flat3.wav", "start": 40, "stop": 60 },  should be 2 packets
-      ] }
-      */
-      if( 75 == receviedpkcount ) {
-        /* flat.wav */
-        expect( msg[ 17 ] ).to.equal( 153 /* 0x99 */ )
-        expect( msg[ 150 ] ).to.equal( 153 /* 0x99 */ )
-      } else if( 125 == receviedpkcount ) {
-        /* flat2.wav */
-        expect( msg[ 17 ] ).to.equal( 3 )
-        expect( msg[ 150 ] ).to.equal( 3 )
-      } else if( 175 == receviedpkcount ) {
-        /* flat.wav */
-        expect( msg[ 17 ] ).to.equal( 153 /* 0x99 */ )
-        expect( msg[ 150 ] ).to.equal( 153 /* 0x99 */ )
-      } else if( 250 == receviedpkcount ) {
-        /* flat.wav */
-        expect( msg[ 17 ] ).to.equal( 153 )
-        expect( msg[ 150 ] ).to.equal( 153 )
-      } else if( 325 == receviedpkcount ) {
+      const secondouterloopoffset = 205
+
+      /* This is PCMA encoded data from our soundsoup */
+      if( 25 == receviedpkcount || ( 25 + secondouterloopoffset ) == receviedpkcount ) {
+        /* flat.wav first loop */
+        expect( msg[ 17 ] ).to.equal( 228 )
+        expect( msg[ 150 ] ).to.equal( 228 )
+      } else if( 75 == receviedpkcount || ( 75 + secondouterloopoffset ) == receviedpkcount ) {
+        /* flat.wav second loop */
+        expect( msg[ 17 ] ).to.equal( 228 )
+        expect( msg[ 150 ] ).to.equal( 228 )
+      } else if( 125 == receviedpkcount || ( 125 + secondouterloopoffset ) == receviedpkcount ) {
         /* flat2.wav */
-        expect( msg[ 17 ] ).to.equal( 3 )
-        expect( msg[ 150 ] ).to.equal( 3 )
-      } else if( 375 == receviedpkcount ) {
+        expect( msg[ 17 ] ).to.equal( 223 )
+        expect( msg[ 150 ] ).to.equal( 223 )
+      } else if( 175 == receviedpkcount || ( 175 + secondouterloopoffset ) == receviedpkcount ) {
         /* flat.wav */
-        expect( msg[ 17 ] ).to.equal( 153 )
-        expect( msg[ 150 ] ).to.equal( 153 )
-      } else if( 403 == receviedpkcount ) {
+        expect( msg[ 17 ] ).to.equal( 228 )
+        expect( msg[ 150 ] ).to.equal( 228 )
+      } else if( 206 == receviedpkcount || 413 == receviedpkcount ) {
         /* flat3.wav */
-        expect( msg[ 17 ] ).to.equal( 54 )
-        expect( msg[ 150 ] ).to.equal( 54 )
+        expect( msg[ 17 ] ).to.equal( 220 )
+        expect( msg[ 150 ] ).to.equal( 220 )
+      } else if( ( 207 * 2 ) == receviedpkcount ) {
+        enoughpackets()
       }
     } )
 
     server.bind()
-    server.on( "listening", async function() {
-
-      const ourport = server.address().port
+    await new Promise( resolve => server.on( "listening", resolve ) )
 
-      channel = await prtp.projectrtp.openchannel( { "remote": { "address": "localhost", "port": ourport, "codec": 0 } }, function( d ) {
-        if( "close" === d.action ) done()
-      } )
+    const ourport = server.address().port
 
-      expect( channel.play( { "loop": 2, "files": [
-        { "wav": "/tmp/flat.wav", "loop": 2 },
-        { "wav": "/tmp/flat2.wav" },
-        { "wav": "/tmp/flat.wav" },
-        { "wav": "/tmp/flat3.wav", "start": 40, "stop": 60 }, /* should be 2 packets */
-      ] } ) ).to.be.true
+    const channel = await prtp.projectrtp.openchannel( { "remote": { "address": "localhost", "port": ourport, "codec": 0 } }, function( d ) {
+      if( "close" === d.action ) done()
     } )
 
-    await new Promise( ( resolve ) => { setTimeout( () => resolve(), 9000 ) } )
+    expect( channel.play( { "loop": 2, "files": [
+      { "wav": "/tmp/flat.wav", "loop": 2 },
+      { "wav": "/tmp/flat2.wav" },
+      { "wav": "/tmp/flat.wav" },
+      { "wav": "/tmp/flat3.wav", "start": 40, "stop": 100 }, /* should be 4 packets */
+    ] } ) ).to.be.true
+
+    await enoughpacketspromise
     channel.close()
     server.close()
 
@@ -345,7 +400,7 @@ describe( "rtpsound", function() {
     /*
       8000 samples looped twice with 3 sections to play. 400 packets (50 packets/S).
     */
-    expect( receviedpkcount ).to.be.within( 390, 405 )
+    expect( receviedpkcount ).to.be.above( 400 )
   } )
 
   before( async () => {
@@ -355,35 +410,34 @@ describe( "rtpsound", function() {
     const wavheader = createwavheader( samples )
     const values = Buffer.alloc( samples * bytespersample )
     for( let i = 0; i < samples; i++ ) {
-      values.writeUInt16BE( 300, i * 2 )
+      values.writeUInt16LE( 300, i * 2 )
     }
     /* Put a marker at the start of the file */
-    values.writeUInt16BE( 1000, 50 )
+    values.writeUInt16LE( 1000, 50 )
 
-    await fs.writeFile( "/tmp/flat.wav", Buffer.concat( [ wavheader, values ] ), function() {} )
+    await fs.promises.writeFile( "/tmp/flat.wav", Buffer.concat( [ wavheader, values ] ) )
 
     for( let i = 0; i < samples; i++ ) {
-      values.writeUInt16BE( 400, i * 2 )
+      values.writeUInt16LE( 400, i * 2 )
     }
 
-    await fs.writeFile( "/tmp/flat2.wav", Buffer.concat( [ wavheader, values ] ), function() {} )
+    await fs.promises.writeFile( "/tmp/flat2.wav", Buffer.concat( [ wavheader, values ] ) )
 
     for( let i = 0; i < samples; i++ ) {
-      values.writeUInt16BE( 0, i * 2 )
+      values.writeUInt16LE( 500, i * 2 )
     }
 
+    await fs.promises.writeFile( "/tmp/flat3.wav", Buffer.concat( [ wavheader, values ] ) )
 
-    for( let i = 0; 320 > i; i++ ) {
-      values.writeUInt16BE( 500, 640 + ( i * 2 ) )
-    }
-
-    await fs.writeFile( "/tmp/flat3.wav", Buffer.concat( [ wavheader, values ] ), function() {} )
+    const sig = gensignal( 440, 8000, 1000 )
+    await fs.promises.writeFile( "/tmp/440sine.wav", Buffer.concat( [ wavheader, sig ] ) )
 
   } )
 
   after( async () => {
-    await new Promise( ( resolve ) => { fs.unlink( "/tmp/flat.wav", () => { resolve() } ) } )
-    await new Promise( ( resolve ) => { fs.unlink( "/tmp/flat2.wav", () => { resolve() } ) } )
-    await new Promise( ( resolve ) => { fs.unlink( "/tmp/flat3.wav", () => { resolve() } ) } )
+    await fs.promises.unlink( "/tmp/flat.wav" )
+    await fs.promises.unlink( "/tmp/flat2.wav" )
+    await fs.promises.unlink( "/tmp/flat3.wav" )
+    await fs.promises.unlink( "/tmp/440sine.wav" )
   } )
 } )

package/test/interface/transcode.js

@@ -1,7 +1,7 @@
 /* if we want to see what is going on - use nodeplotlib instead of our placeholder */
-const npl = require( "nodeplotlib" )
+//const npl = require( "nodeplotlib" )
 // eslint-disable-next-line no-unused-vars
-//const npl = { plot: ( /** @type {any} */ a ) => {} }
+const npl = { plot: ( /** @type {any} */ a ) => {} }
 
 
 const fft = require( "fft-js" ).fft

package/test/util/rtp.js

@@ -0,0 +1,17 @@
+
+
+
+/**
+ * Limitation of not parsing ccrc.
+ * @param { Buffer } packet
+ * @return { object }
+ */
+module.exports.parsepk = function( packet ) {
+  return {
+    sn: packet.readUInt16BE( 2 ),
+    ts: packet.readUInt32BE( 4 ),
+    pt: packet.readUInt8( 1 ) & 0x7f,
+    ssrc: packet.readUInt32BE( 8 ),
+    payload: new Uint8Array( packet.slice( 12 ) )
+  }
+}