@babblevoice/projectrtp 2.5.20 → 2.5.25

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

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