@babblevoice/projectrtp 2.5.20 → 2.5.22

package/package.json

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

package/src/globals.h

@@ -9,6 +9,9 @@
 #define G711PAYLOADBYTES 160
 #define G722PAYLOADBYTES 160
 #define L16PAYLOADSAMPLES 160
+#define G711PAYLOADSAMPLES 160
+#define G722PAYLOADSAMPLES 160
+#define L1616PAYLOADSAMPLES 320
 #define L16NARROWBANDBYTES 320
 #define L16WIDEBANDBYTES 640
 #define ILBC20PAYLOADBYTES 38

package/src/projectrtpchannelmux.cpp

@@ -15,7 +15,8 @@ projectchannelmux::projectchannelmux( boost::asio::io_context &iocontext ):
   newchannels(),
   newchannelslock( false ),
   added(),
-  subtracted() {
+  subtracted(),
+  active( false ) {
 }
 
 projectchannelmux::~projectchannelmux() {
@@ -29,22 +30,24 @@ projectchannelmux::pointer projectchannelmux::create( boost::asio::io_context &i
 void projectchannelmux::mixall( void ) {
   /* First decide on a common rate (if we only have 8K channels it is pointless
   upsampling them all and wasting resources) */
-  int l16krequired = L168KPAYLOADTYPE;
+  int l16format = L168KPAYLOADTYPE;
   size_t insize = L16PAYLOADSAMPLES;
 
   for( auto& chan: this->channels ) {
     switch( chan->codec ) {
       case G722PAYLOADTYPE:
       case L1616KPAYLOADTYPE: {
-        l16krequired = L1616KPAYLOADTYPE;
+        l16format = L1616KPAYLOADTYPE;
+        insize = L1616PAYLOADSAMPLES;
         goto endofforloop;
       }
     }
   }
   endofforloop:
 
-  this->added.malloc( insize, sizeof( int16_t ), l16krequired );
-  this->subtracted.malloc( insize, sizeof( int16_t ), l16krequired );
+  /* allocate the max needed */
+  this->added.malloc( insize, sizeof( int16_t ), l16format );
+  this->subtracted.malloc( insize, sizeof( int16_t ), l16format );
   this->added.zero();
 
   /* We first have to add them all up */
@@ -186,6 +189,8 @@ Our timer handler.
 void projectchannelmux::handletick( const boost::system::error_code& error ) {
   if ( error == boost::asio::error::operation_aborted ) return;
 
+  if( !this->active ) return;
+
   this->checkfornewmixes();
 
   /* Check for channels which have request removal */
@@ -193,6 +198,7 @@ void projectchannelmux::handletick( const boost::system::error_code& error ) {
 
   if( 0 == this->channels.size() ) {
     /* We're done */
+    this->active = false;
     return;
   }
 
@@ -233,6 +239,10 @@ void projectchannelmux::setnexttick( void ) {
 }
 
 void projectchannelmux::go( void ) {
+
+  if( this->active ) return;
+  this->active = true;
+
   this->nexttick = std::chrono::high_resolution_clock::now() + std::chrono::milliseconds( 20 );
 
   this->tick.expires_after( this->nexttick - std::chrono::high_resolution_clock::now() );

package/src/projectrtpchannelmux.h

@@ -22,8 +22,8 @@ typedef std::shared_ptr< projectrtpchannel > projectrtpchannelptr;
 typedef std::list< projectrtpchannelptr > projectchanptrlist;
 
 class projectchannelmux:
-  public std::enable_shared_from_this< projectchannelmux >
-{
+  public std::enable_shared_from_this< projectchannelmux > {
+
 public:
   projectchannelmux( boost::asio::io_context &iocontext );
   ~projectchannelmux();
@@ -58,6 +58,8 @@ private:
 
   rawsound added;
   rawsound subtracted;
+
+  bool active;
 };
 
 #endif /* PROJECTRTPCHANNELMUX_H */

package/src/projectrtpcodecx.cpp

@@ -87,7 +87,6 @@ codecx::codecx() :
   ilbcencoder( nullptr ),
   ilbcdecoder( nullptr ),
   lpfilter(),
-  resamplelastsample( 0 ),
   l168kref(),
   l1616kref(),
   pcmaref(),
@@ -146,7 +145,6 @@ Do enough to manage missing packets.
 void codecx::restart( void ) {
   this->lpfilter.reset();
   this->dcpowerfilter.reset();
-  this->resamplelastsample = 0;
   this->_hasdata = false;
 }
 
@@ -160,19 +158,17 @@ bool codecx::alaw2ulaw( void ) {
   if( this->pcmaref.isdirty() ) return false;
 
   uint8_t *inbufptr, *outbufptr;
-  size_t insize;
 
-  insize = this->pcmaref.size();
   inbufptr = this->pcmaref.c_str();
   outbufptr = this->pcmuref.c_str();
-  this->pcmuref.size( insize );
+  this->pcmuref.size( G711PAYLOADBYTES );
 
   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++ ) {
+  for( size_t i = 0; i < G711PAYLOADBYTES; i++ ) {
     *outbufptr = alaw_to_ulaw_table[ *inbufptr ];
     inbufptr++;
     outbufptr++;
@@ -187,19 +183,17 @@ bool codecx::ulaw2alaw( void ) {
   if( this->pcmuref.isdirty() ) return false;
 
   uint8_t *inbufptr, *outbufptr;
-  size_t insize;
 
-  insize = this->pcmuref.size();
   inbufptr = this->pcmuref.c_str();
   outbufptr = this->pcmaref.c_str();
-  this->pcmaref.size( insize );
+  this->pcmaref.size( G711PAYLOADBYTES );
 
   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++ ) {
+  for( size_t i = 0; i < G711PAYLOADBYTES; i++ ) {
     *outbufptr = ulaw_to_alaw_table[ *inbufptr ];
     inbufptr++;
     outbufptr++;
@@ -217,25 +211,22 @@ bool codecx::g711tol16( void )
 {
   uint8_t *in;
   int16_t *convert;
-  size_t insize;
 
   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() ) {
     in = this->pcmuref.c_str();
     convert = _pcmutol16;
-    insize = this->pcmuref.size();
   } else {
     return false;
   }
 
-  this->l168kref.malloc( insize, sizeof( int16_t ), L168KPAYLOADTYPE );
+  this->l168kref.malloc( G711PAYLOADSAMPLES, sizeof( int16_t ), L168KPAYLOADTYPE );
 
   int16_t *out = ( int16_t * ) this->l168kref.c_str();
 
-  for( size_t i = 0; i < insize; i++ ) {
+  for( size_t i = 0; i < G711PAYLOADSAMPLES; i++ ) {
     *out = convert[ *in ];
     in++;
     out++;
@@ -257,11 +248,10 @@ bool codecx::l16topcma( void )
   uint8_t *out = this->pcmaref.c_str();
 
   int16_t *in;
-  size_t l168klength = this->l168kref.size();
   in = ( int16_t * ) this->l168kref.c_str();
 
   uint16_t index;
-  for( size_t i = 0; i < l168klength; i++ ) {
+  for( size_t i = 0; i < G711PAYLOADBYTES; i++ ) {
     index = *in + 32768;
     *out = _l16topcma[ index ];
     in++;
@@ -281,11 +271,10 @@ bool codecx::l16topcmu( void ) {
   uint8_t *out = this->pcmuref.c_str();;
 
   int16_t *in;
-  size_t l168klength = this->l168kref.size();
   in = ( int16_t * ) this->l168kref.c_str();
 
   uint16_t index;
-  for( size_t i = 0; i < l168klength; i++ ) {
+  for( size_t i = 0; i < G711PAYLOADBYTES; i++ ) {
     index = *in + 32768;
     *out = _l16topcmu[ index ];
     in++;
@@ -315,43 +304,16 @@ bool codecx::ilbctol16( void ) {
 
   int16_t l168klength = WebRtcIlbcfix_Decode( this->ilbcdecoder,
                         ( ilbcencodedval ) this->ilbcref.c_str(),
-                        this->ilbcref.size(),
+                        ILBC20PAYLOADBYTES,
                         ( ilbcdecodedval )this->l168kref.c_str(),
                         &speechType
                       );
 
   if( -1 == l168klength ) {
-    this->l168kref.size( 0 );
     return false;
   }
 
   this->l168kref.dirty( false );
-  this->l168kref.size( l168klength );
-  return true;
-}
-
-/*!md
-## l16tog722
-As it says.
-*/
-bool codecx::l16tog722( void ) {
-  if( 0 == this->l1616kref.size() ) return false;
-  if( this->l1616kref.isdirty() ) return false;
-
-  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 ) {
-    this->g722ref.size( len );
-    this->g722ref.dirty( false );
-  } else {
-    std::cerr << "g722_encode didn't encode any data" << std::endl;
-    this->g722ref.size( 0 );
-  }
-
   return true;
 }
 
@@ -375,11 +337,10 @@ bool codecx::l16toilbc( void ) {
 
   int16_t len = WebRtcIlbcfix_Encode( this->ilbcencoder,
                             ( ilbcdecodedval ) this->l168kref.c_str(),
-                            this->l168kref.size(),
+                            L16PAYLOADSAMPLES,
                             ( ilbcencodedval ) this->ilbcref.c_str()
                           );
   if ( len > 0 ) {
-    this->ilbcref.size( len );
     this->ilbcref.dirty( false );
     return true;
   }
@@ -390,6 +351,33 @@ bool codecx::l16toilbc( void ) {
 }
 
 
+/*!md
+## l16tog722
+As it says.
+*/
+bool codecx::l16tog722( void ) {
+
+  if( 0 == this->l1616kref.size() ) return false;
+  if( this->l1616kref.isdirty() ) return false;
+
+  if( nullptr == this->g722encoder ) {
+    this->g722encoder = g722_encode_init( NULL, 64000, G722_PACKED );
+  }
+
+  // TODO - when we convert to g722 - 722 buffer is always output -so malloc need sto be able to detect that.
+  //this->g722ref.malloc( G722PAYLOADSAMPLES, sizeof( int8_t ), G722PAYLOADTYPE );
+
+  int len = g722_encode( this->g722encoder, this->g722ref.c_str(), ( int16_t * ) this->l1616kref.c_str(), L1616PAYLOADSAMPLES );
+
+  if( 160 != len ) {
+    std::cerr << "g722_encode didn't encode correct length of data" << std::endl;
+    return false;
+  }
+
+  this->g722ref.dirty( false );
+  return true;
+}
+
 /*!md
 ## g722tol16
 As it says.
@@ -398,8 +386,7 @@ 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 );
+  this->l1616kref.malloc( L1616PAYLOADSAMPLES, sizeof( int16_t ), L1616KPAYLOADTYPE );
 
   if( nullptr == this->g722decoder ) {
     this->g722decoder = g722_decode_init( NULL, 64000, G722_PACKED );
@@ -411,9 +398,10 @@ bool codecx::g722tol16( void ) {
   size_t l1616klength = g722_decode( this->g722decoder,
                                 ( int16_t * ) this->l1616kref.c_str(),
                                 this->g722ref.c_str(),
-                                this->g722ref.size() );
+                                G722PAYLOADBYTES );
 
-  this->l1616kref.size( l1616klength );
+  if( 320 != l1616klength ) return false;
+  
   this->l1616kref.dirty( false );
   return true;
 }
@@ -423,23 +411,19 @@ bool codecx::g722tol16( void ) {
 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 ) {
-  size_t l168klength = this->l168kref.size();
 
-  if( 0 == l168klength ) return false;
+  if( 0 == this->l168kref.size() ) return false;
   if( this->l168kref.isdirty() ) return false;
 
-  this->l1616kref.malloc( l168klength, sizeof( int16_t ), L1616KPAYLOADTYPE );
+  this->l1616kref.malloc( L1616PAYLOADSAMPLES, sizeof( int16_t ), L1616KPAYLOADTYPE );
 
   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++ ) {
-    *out = ( ( *in - this->resamplelastsample ) / 2 ) + this->resamplelastsample;
-    this->resamplelastsample = *in;
+  for( size_t i = 0; i < L16PAYLOADSAMPLES; i++ ) {
+    *out = this->lpfilter.execute( *in );
     out++;
-
-    *out = *in;
-
+    *out = this->lpfilter.execute( 0 );
     out++;
     in++;
   }
@@ -457,7 +441,7 @@ bool codecx::requirewideband( void ) {
   if( this->g722tol16() ) return true;
   if( !this->g711tol16() )
   {
-    if( this->ilbctol16() ) return false;
+    if( !this->ilbctol16() ) return false;
   }
 
   return this->l16lowtowideband();
@@ -467,22 +451,20 @@ bool codecx::requirewideband( void ) {
 ##  l16widetolowband
 Downsample our L16 wideband samples to 8K. Pass through filter then grab every other sample.
 */
-bool codecx::l16widetonarrowband( void )
-{
-  size_t l1616klength = this->l1616kref.size();
+bool codecx::l16widetonarrowband( void ) {
 
-  if( 0 == l1616klength ) return false;
+  if( 0 == this->l1616kref.size() ) return false;
   if( this->l1616kref.isdirty() ) return false;
 
-  this->l168kref.malloc( l1616klength / 2, sizeof( int16_t ), L168KPAYLOADTYPE );
+  this->l168kref.malloc( L16PAYLOADSAMPLES, sizeof( int16_t ), L168KPAYLOADTYPE );
 
   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 );
+  for( size_t i = 0; i < L16PAYLOADSAMPLES; i++ ) {
+    this->lpfilter.execute( *in );
     in++;
-    *out = lpfilter.execute( *in );
+    *out = this->lpfilter.execute( *in );
     in++;
     out++;
   }
@@ -628,52 +610,43 @@ We pass a packet in, then we can take multiple out - i.e. we may want different
 
 Have a think about if this is where we want to mix audio data.
 */
-codecx& operator << ( codecx& c, rtppacket& pk )
-{
+codecx& operator << ( codecx& c, rtppacket& pk ) {
   c.inpkcount++;
   rawsound r = rawsound( pk );
   c << r;
   return c;
 }
 
-codecx& operator << ( codecx& c, rawsound& raw )
-{
+codecx& operator << ( codecx& c, rawsound& raw ) {
   int inpayloadtype = raw.getformat();
 
-  switch( inpayloadtype )
-  {
-    case PCMAPAYLOADTYPE:
-    {
+  switch( inpayloadtype ) {
+    case PCMAPAYLOADTYPE: {
       c.pcmaref = raw;
       c._hasdata = true;
       break;
     }
-    case PCMUPAYLOADTYPE:
-    {
+    case PCMUPAYLOADTYPE: {
       c.pcmuref = raw;
       c._hasdata = true;
       break;
     }
-    case ILBCPAYLOADTYPE:
-    {
+    case ILBCPAYLOADTYPE: {
       c.ilbcref = raw;
       c._hasdata = true;
       break;
     }
-    case G722PAYLOADTYPE:
-    {
+    case G722PAYLOADTYPE: {
       c.g722ref = raw;
       c._hasdata = true;
       break;
     }
-    case L168KPAYLOADTYPE:
-    {
+    case L168KPAYLOADTYPE: {
       c.l168kref = raw;
       c._hasdata = true;
       break;
     }
-    case L1616KPAYLOADTYPE:
-    {
+    case L1616KPAYLOADTYPE: {
       c.l1616kref = raw;
       c._hasdata = true;
       break;

package/src/projectrtpcodecx.h

@@ -85,10 +85,8 @@ private:
   ilbcencinst *ilbcencoder;
   ilbcdecinst *ilbcdecoder;
 
-  /* If we require downsampling */
+  /* If we require up/downsampling */
   lowpass3_4k16k lpfilter;
-  /* When we up sample we need to interpolate so need last sample */
-  int16_t resamplelastsample;
 
   rawsound l168kref;
   rawsound l1616kref;

package/src/projectrtprawsound.cpp

@@ -147,24 +147,17 @@ rawsound::~rawsound()
 ## zero
 Reset buffer with zero
 */
-void rawsound::zero( void )
-{
-  if( nullptr != this->data )
-  {
-    size_t zeroamount = this->samples * this->bytespersample;
-    if( L1616KPAYLOADTYPE == format )
-    {
-      zeroamount = zeroamount * 2;
-    }
+void rawsound::zero( void ) {
+  if( nullptr == this->data ) return;
 
-    if( 0 != this->allocatedlength && zeroamount > this->allocatedlength )
-    {
-      std::cerr << "Trying to zero memory but capped by allocated amount" << std::endl;
-      zeroamount = this->allocatedlength;
-    }
+  size_t zeroamount = this->samples * this->bytespersample;
 
-    memset( this->data, 0, zeroamount );
+  if( 0 != this->allocatedlength && zeroamount > this->allocatedlength ) {
+    std::cerr << "Trying to zero memory but capped by allocated amount" << std::endl;
+    zeroamount = this->allocatedlength;
   }
+
+  memset( this->data, 0, zeroamount );
 }
 
 /*
@@ -172,49 +165,31 @@ void rawsound::zero( void )
 * Target (this) MUST have memory available.
 * format must be set appropriatly before the call
 */
-void rawsound::copy( uint8_t *src, size_t len )
-{
-  if( nullptr != this->data )
-  {
-    memcpy( this->data,
-            src,
-            len );
+void rawsound::copy( uint8_t *src, size_t len ) {
+  if( nullptr == this->data ) return;
 
-    switch( this->format )
-    {
-      case L168KPAYLOADTYPE:
-      case L1616KPAYLOADTYPE:
-      {
-        this->samples = len / 2;
-        break;
-      }
-      default:
-      {
-        this->samples = len;
-        break;
-      }
-    }
-  }
+  memcpy( this->data,
+          src,
+          len );
 }
 
 /*
 ## copy (from other)
 * Target (this) MUST have data allocated.
 */
-void rawsound::copy( rawsound &other )
-{
-  if( nullptr != this->data && this->samples >= other.samples )
-  {
-    this->bytespersample = other.bytespersample;
-    this->samplerate = other.samplerate;
-    this->format = other.format;
-    this->samples = other.samples;
+void rawsound::copy( rawsound &other ) {
 
-    memcpy( this->data,
-            other.data,
-            other.samples * other.bytespersample );
+  if( nullptr == this->data || this->samples < other.samples ) return;
+
+  this->bytespersample = other.bytespersample;
+  this->samplerate = other.samplerate;
+  this->format = other.format;
+  this->samples = other.samples;
+
+  memcpy( this->data,
+          other.data,
+          other.samples * other.bytespersample );
 
-  }
 }
 
 /*
@@ -237,15 +212,11 @@ void rawsound::subtract( void )
 ## malloc
 Allocate our own memory.
 */
-void rawsound::malloc( size_t samplecount, size_t bytespersample, int format )
-{
+void rawsound::malloc( size_t samplecount, size_t bytespersample, int format ) {
   this->samples = samplecount;
   this->bytespersample = bytespersample;
   this->format = format;
   size_t requiredsize = samplecount * bytespersample;
-  if( L1616KPAYLOADTYPE == format ) {
-    requiredsize = requiredsize * 2;
-  }
 
   if( this->allocatedlength > 0 ) {
     if( this->allocatedlength >= requiredsize ) {
@@ -262,46 +233,39 @@ void rawsound::malloc( size_t samplecount, size_t bytespersample, int format )
 ## operator +=
 Used for mixing audio
 */
-rawsound& rawsound::operator+=( codecx& rhs )
-{
+rawsound& rawsound::operator+=( codecx& rhs ) {
   size_t length;
 
   int16_t *in;
   int16_t *out = ( int16_t * ) this->data;
 
-  switch( this->format )
-  {
-    case L168KPAYLOADTYPE:
-    {
+  switch( this->format ) {
+    case L168KPAYLOADTYPE: {
       rhs.requirenarrowband();
-
+      if( rhs.l168kref.isdirty() ) return *this;
       length = rhs.l168kref.size();
       in = ( int16_t * ) rhs.l168kref.c_str();
       break;
     }
-    case L1616KPAYLOADTYPE:
-    {
+    case L1616KPAYLOADTYPE: {
       rhs.requirewideband();
-
+      if( rhs.l1616kref.isdirty() ) return *this;
       length = rhs.l1616kref.size();
       in = ( int16_t * ) rhs.l1616kref.c_str();
       break;
     }
-    default:
-    {
+    default: {
       std::cerr << "Attemping to perform an addition on a none linear format" << std::endl;
       return *this;
     }
   }
 
-  if( length > this->samples )
-  {
+  if( length > this->samples ) {
     std::cerr << "We have been asked to add samples but we don't have enough space" << std::endl;
     length = this->samples;
   }
 
-  for( size_t i = 0; i < length; i++ )
-  {
+  for( size_t i = 0; i < length; i++ ) {
     *out++ += *in++;
   }
 

package/test/interface/pcap.js

@@ -132,9 +132,9 @@ module.exports.readpcap = async ( file, maxnumberofpackets = 5000 ) => {
           etherpacket.ipv4.udp = {}
           etherpacket.ipv4.udp.srcport = parseInt( toHex( etherpacket.ipv4.data[ 20 ] ) + toHex( etherpacket.ipv4.data[ 21 ] ), 16 )
           etherpacket.ipv4.udp.dstport = parseInt( toHex( etherpacket.ipv4.data[ 22 ] ) + toHex( etherpacket.ipv4.data[ 23 ] ), 16 )
-          etherpacket.ipv4.udp.length = parseInt( toHex( etherpacket.ipv4.data[ 24 ] ) + toHex( etherpacket.ipv4.data[ 25 ] ), 16 )
+          etherpacket.ipv4.udp.length = parseInt( toHex( etherpacket.ipv4.data[ 24 ] ) + toHex( etherpacket.ipv4.data[ 25 ] ), 16 ) - /* udp header */ 8
           etherpacket.ipv4.udp.checksum = parseInt( toHex( etherpacket.ipv4.data[ 26 ] ) + toHex( etherpacket.ipv4.data[ 27 ] ), 16 )
-          etherpacket.ipv4.udp.data = etherpacket.ipv4.data.subarray( 28, 28 + etherpacket.ipv4.data.length )
+          etherpacket.ipv4.udp.data = etherpacket.ipv4.data.subarray( 28, 28 + etherpacket.ipv4.udp.length )
           break
         case 6:
           /* TCP */

package/test/interface/projectrtpdtmf.js

@@ -1,9 +1,9 @@
 
 const expect = require( "chai" ).expect
-const projectrtp = require( "../../index.js" ).projectrtp
+const projectrtp = require( "../../index" ).projectrtp
 const dgram = require( "dgram" )
 
-const pcap = require( "./pcap.js" )
+const pcap = require( "./pcap" )
 
 /*
 i.e. the RTP payload

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
@@ -9,6 +9,7 @@ const projectrtp = require( "../../index" ).projectrtp
 const expect = require( "chai" ).expect
 const dgram = require( "dgram" )
 const fs = require( "fs" )
+const pcap = require( "./pcap" )
 
 
 /*
@@ -167,6 +168,20 @@ function pcmutolinear( inarray ) {
   return out
 }
 
+/**
+ * Send Buffer to server at required time
+ * @param { number } sendtime 
+ * @param { Buffer } pk 
+ * @param { number } dstport 
+ * @param { dgram.Socket } server 
+ * @returns 
+ */
+function sendpayload( sendtime, pk, dstport, server ) {
+  return setTimeout( () => {
+    server.send( pk, dstport, "localhost" )
+  }, sendtime )
+}
+
 /**
  * 
  * @param { number } sn - should start from 0 which we use to index into the supplied data buffer
@@ -653,5 +668,154 @@ describe( "Transcode", function() {
 
     await fs.promises.unlink( "/tmp/ukringing.wav" ).catch( () => {} )
   } )
+
+  it( "replay captured g722 from poly", async () => {
+
+    const g722endpoint = dgram.createSocket( "udp4" )
+    g722endpoint.on( "message", function() {} )
+
+    const pcmuendpoint = dgram.createSocket( "udp4" )
+    let receivedpcmu = []
+    pcmuendpoint.on( "message", function( msg ) {
+      pcmuendpoint.send( msg, pcmuchannel.local.port, "localhost" )
+
+      receivedpcmu = [ ...receivedpcmu,  ...Array.from( pcmutolinear( parsepk( msg ).payload ) ) ]
+    } )
+
+    g722endpoint.bind()
+    await new Promise( resolve => g722endpoint.on( "listening", resolve ) )
+    pcmuendpoint.bind()
+    await new Promise( resolve => pcmuendpoint.on( "listening", resolve ) )
+
+    const allstats = {}
+
+    const g722channel = await projectrtp.openchannel( { "id": "4", "remote": { "address": "localhost", "port": g722endpoint.address().port, "codec": 9 } }, function( d ) {
+      if( "close" === d.action ) {
+        g722endpoint.close()
+        pcmuendpoint.close()
+        pcmuchannel.close()
+        allstats.achannel = { stats: d.stats }
+      }
+    } )
+
+    let done
+    const allclose = new Promise( resolve => done = resolve )
+    const pcmuchannel = await projectrtp.openchannel( { "id": "4", "remote": { "address": "localhost", "port": pcmuendpoint.address().port, "codec": 0 } }, function( d ) {
+      if( "close" === d.action ) {
+        allstats.bchannel = { stats: d.stats }
+        done()
+      }
+    } )
+
+    const ourpcap = ( await pcap.readpcap( "test/interface/pcaps/440hzinbackgroundg722.pcap" ) ).slice( 0, 50 )
+
+    g722channel.mix( pcmuchannel )
+
+    const offset = 0
+    ourpcap.forEach( ( packet ) => {
+      if( packet.ipv4 && packet.ipv4.udp && 10018 == packet.ipv4.udp.dstport ) {
+        sendpayload( ( 1000 * packet.ts_sec_offset ) - offset, packet.ipv4.udp.data, g722channel.local.port, g722endpoint )
+      }
+    } )
+
+    await new Promise( resolve => setTimeout( resolve, 1400 ) )
+    g722channel.close()
+    await allclose
+
+    npl.plot( [ {
+      y: Array.from( receivedpcmu ),
+      type: "scatter"
+    } ] )
+
+    const amps = ampbyfrequency( Int16Array.from( receivedpcmu ) )
+    const bin = 225
+    expect( 20000 < amps[ bin ] ).to.be.true
+
+    npl.plot( [ {
+      y: Array.from( amps ),
+      type: "scatter"
+    } ] )
+
+  } )
+
+  it( "replay captured g722 no transcode from poly 3 way mix", async () => {
+
+    const g722endpoint = dgram.createSocket( "udp4" )
+    g722endpoint.on( "message", function() {} )
+
+    const pcmuendpoint = dgram.createSocket( "udp4" )
+    let receivedpcmu = []
+
+    pcmuendpoint.on( "message", function( msg ) {
+      pcmuendpoint.send( msg, pcmuchannel.local.port, "localhost" )
+
+      receivedpcmu = [ ...receivedpcmu,  ...Array.from( pcmutolinear( parsepk( msg ).payload ) ) ]
+    } )
+
+    g722endpoint.bind()
+    await new Promise( resolve => g722endpoint.on( "listening", resolve ) )
+    pcmuendpoint.bind()
+    await new Promise( resolve => pcmuendpoint.on( "listening", resolve ) )
+
+    const allstats = {}
+
+    const g722channel = await projectrtp.openchannel( { "id": "4", "remote": { "address": "localhost", "port": g722endpoint.address().port, "codec": 9 } }, function( d ) {
+      if( "close" === d.action ) {
+        g722endpoint.close()
+        pcmuendpoint.close()
+        pcmuchannel.close()
+        secondg722.close()
+        allstats.achannel = { stats: d.stats }
+      }
+    } )
+
+    let done
+    const allclose = new Promise( resolve => done = resolve )
+    const pcmuchannel = await projectrtp.openchannel( { "id": "4", "remote": { "address": "localhost", "port": pcmuendpoint.address().port, "codec": 0 } }, function( d ) {
+      if( "close" === d.action ) {
+        allstats.bchannel = { stats: d.stats }
+        done()
+      }
+    } )
+
+    const secondg722 = await projectrtp.openchannel( { "id": "4", "remote": { "address": "localhost", "port": 9990, "codec": 9 } }, function( d ) {
+      if( "close" === d.action ) {
+        allstats.bchannel = { stats: d.stats }
+        done()
+      }
+    } )
+
+    const ourpcap = ( await pcap.readpcap( "test/interface/pcaps/440hzinbackgroundg722.pcap" ) ).slice( 0, 50 )
+
+    g722channel.mix( pcmuchannel )
+    g722channel.mix( secondg722 )
+
+    const offset = 0
+    ourpcap.forEach( ( packet ) => {
+      if( packet.ipv4 && packet.ipv4.udp && 10018 == packet.ipv4.udp.dstport ) {
+        sendpayload( ( 1000 * packet.ts_sec_offset ) - offset, packet.ipv4.udp.data, g722channel.local.port, g722endpoint )
+      }
+    } )
+
+    await new Promise( resolve => setTimeout( resolve, 1400 ) )
+    g722channel.close()
+    await allclose
+
+    npl.plot( [ {
+      y: Array.from( receivedpcmu ),
+      type: "scatter"
+    } ] )
+
+    const amps = ampbyfrequency( Int16Array.from( receivedpcmu ) )
+
+    npl.plot( [ {
+      y: Array.from( amps ),
+      type: "scatter"
+    } ] )
+
+    const bin = 430
+    expect( 20000 < amps[ bin ] ).to.be.true
+
+  } )
 } )