@babblevoice/projectrtp 2.5.20 → 2.5.25

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/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/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/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

@@ -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
@@ -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 )