@babblevoice/projectrtp 2.5.34 → 2.5.38

package/src/projectrtpsoundfile.h

@@ -6,6 +6,7 @@
 #include <string>
 
 #include <memory>
+#include <vector>
 
 
 #include <sys/types.h>
@@ -25,6 +26,8 @@
 #define SOUNDFILENUMBUFFERS 8
 #define MAXNUMBEROFCHANNELS 2
 
+typedef std::vector< int16_t > soundbuffer;
+
 typedef struct {
     /* RIFF Header */
     uint8_t riff_header[ 4 ]; /* Contains "RIFF" */
@@ -83,12 +86,14 @@ protected:
   wavheader ourwavheader;
 
   /* asynchronous variables */
-  int currentcbindex;
+  u_int8_t currentcbindex;
   aiocb cbwavheader;
   aiocb cbwavblock[ SOUNDFILENUMBUFFERS ];
 
   /* buffer for data */
-  uint8_t *buffer;
+  soundbuffer buffer[ SOUNDFILENUMBUFFERS ];
+
+  std::atomic_bool filelock;
 };
 
 
@@ -109,14 +114,20 @@ public:
   bool complete( void );
 
   void setposition( long mseconds );
+  
   long getposition( void );
 
   inline bool isopen( void ) { return this->file != -1; }
 
 private:
   long offtomsecs( void );
+  void parseheader( void );
+
+  /* called by us - so we have a lock */
+  void realsetposition( long mseconds );
 
-  int blocksize;
+  size_t bytecount;
+  size_t samplecount;
   bool badheader;
   bool headerread;
   bool bodyread;

package/src/projectrtpsoundsoup.cpp

@@ -1,4 +1,6 @@
 
+/* needed to build on ubuntu */
+#include <utility>
 
 #include <iostream>
 #include "projectrtpsoundsoup.h"

package/src/projectrtpstun.cpp

@@ -3,6 +3,9 @@
 A very (very) simple STUN implimentation.
 */
 
+/* needed to build on ubuntu */
+#include <utility>
+
 /* printf when required */
 #include <cstdio>
 

package/stress/echorecord.scenario.js

@@ -41,8 +41,11 @@ module.exports = async ( mstimeout ) => {
   channela.echo()
 
   await utils.waitbetween( 0, 500 )
+  /* include settings which terminate the recording before OR after the channel closes */
   channela.record( {
-    "file": recording
+    "file": recording,
+    "maxduration": utils.waitbetween( 50, mstimeout * 2 ),
+    "finishbelowpower": 200
   } )
 
 }

package/stress/index.js

@@ -14,6 +14,8 @@ scenarios.push( require( "./echodualrecordpower.scenario.js" ) )
 scenarios.push( require( "./echodualrecordpausestop.scenario.js" ) )
 scenarios.push( require( "./mix2.scenario.js" ) )
 scenarios.push( require( "./mixunmix.scenario.js" ) )
+scenarios.push( require( "./playbackthenmix.scenario.js" ) )
+scenarios.push( require( "./playbackrecordtoofast.scenario.js" ) )
 
 /*
 The purpose of this script is to load up projectrtp to expose any issues with timing.
@@ -23,7 +25,7 @@ folder is for.
 We have a problem with "we should never get here - we have no more buffer available on port"
 */
 
-const maxnumberofsessions = 200
+const maxnumberofsessions = 1000
 const secondsruntime = 3600*12
 const minmscalllength = 50
 const maxmscalllength = 1000 * 60 * 10 /* 1000 mS per second 60 seconds per minute , n minutes */
@@ -43,6 +45,7 @@ const run = async () => {
   if ( "node" === process.argv.slice(2)[0] ) {
     console.log( "Mode: node as listener" )
     projectrtp.proxy.addnode( { host: "127.0.0.1", port: 9002 } )
+    // @ts-ignore
     await node.listen( projectrtp, "127.0.0.1", 9002 )
   } else console.log( "Mode: server as listener" )
 

package/stress/playbackrecordtoofast.scenario.js

@@ -0,0 +1,106 @@
+
+
+const dgram = require( "dgram" )
+
+const projectrtp = require( "../index.js" ).projectrtp
+const fs = require( "fs" )
+const utils = require( "./utils.js" )
+
+/*
+  js client (too fast) ---> channela (play/record)
+*/
+
+function sendpk( sn, sendtime, dstport, server, data = undefined, pt = 0, ssrc = 25 ) {
+
+  const pklength = 172
+
+  return setTimeout( () => {
+
+    let payload
+    if( undefined !== data ) {
+      payload = data
+    } else {
+      payload = Buffer.alloc( pklength - 12 ).fill( projectrtp.codecx.linear162pcmu( sn ) & 0xff )
+    }
+
+    const subheader = Buffer.alloc( 10 )
+
+    const ts = sn * 160
+
+    subheader.writeUInt16BE( ( sn + 100 ) % ( 2**16 ) /* just some offset */ )
+    subheader.writeUInt32BE( ts, 2 )
+    subheader.writeUInt32BE( ssrc, 6 )
+
+    const header = Buffer.from( [ 0x80, 0x00 ] )
+    header.writeUInt8( pt, 1 ) // payload type
+
+    const rtppacket = Buffer.concat( [
+      header,
+      subheader,
+      payload ] )
+
+    server.send( rtppacket, dstport, "localhost" )
+  }, sendtime * 17 )
+}
+
+async function createclient() {
+  const client = dgram.createSocket( "udp4" )
+  client.on( "message", function( msg ) {
+  } )
+
+  client.bind()
+  await new Promise( ( r ) => { client.on( "listening", function() { r() } ) } )
+
+  return client
+}
+
+module.exports = async ( mstimeout ) => {
+
+  const acodec = utils.randcodec()
+
+  utils.log( `Starting playback with record for ${mstimeout} mS but sending packets too quickly` )
+  const recording = utils.mktempwav()
+
+  const clienta = await createclient()
+  const clientb = await createclient()
+
+  const channela = await projectrtp.openchannel( { "remote": { "address": "localhost", "port": clienta.address().port, "codec": acodec } }, async ( d ) => {
+    if( "close" === d.action ) {
+      utils.logclosechannel( `Playback with record for ${mstimeout} mS completed with reason '${d.reason}'`, d, mstimeout )
+      await fs.promises.unlink( recording ).catch( () => {} )
+    }
+  } )
+
+  const channelb = await projectrtp.openchannel( { "remote": { "address": "localhost", "port": clientb.address().port, "codec": acodec } }, async ( d ) => {
+    if( "close" === d.action ) {
+      utils.logclosechannel( `Playback with record for ${mstimeout} mS completed with reason '${d.reason}'`, d, mstimeout )
+      await fs.promises.unlink( recording ).catch( () => {} )
+    }recording
+  } )
+
+  utils.lognewchannel()
+  utils.lognewchannel()
+
+  const pkcount = Math.floor( mstimeout / 20 ) 
+  for( let i = 0; i < pkcount; i++ ) {
+    sendpk( i, i, channela.local.port, clienta, )
+  }
+
+  for( let i = 0; i < pkcount; i++ ) {
+    sendpk( i, i, channelb.local.port, clientb, )
+  }
+
+  await utils.waitbetween( 0, 500 )
+  channela.mix( channelb )
+
+  await utils.waitbetween( 0, 500 )
+  channela.record( {
+    "file": recording,
+    "numchannels": utils.between( 0, 1 )
+  } )
+
+  await utils.wait( mstimeout )
+
+  clienta.close()
+  channela.close()
+}

package/stress/playbackthenmix.scenario.js

@@ -0,0 +1,70 @@
+
+const projectrtp = require( "../index.js" ).projectrtp
+const utils = require( "./utils.js" )
+const expect = require( "chai" ).expect
+
+/**
+ * clienta (echo) ---> channela (play/mix)
+ * @param { number } mstimeout 
+ */
+module.exports = async ( mstimeout ) => {
+
+  const acodec = utils.randcodec()
+  const bcodec = utils.randcodec()
+
+  utils.log( `Starting playback then mix for ${mstimeout} mS` )
+
+  const clienta = await projectrtp.openchannel( {}, ( d ) => {
+    if( "close" === d.action ) {
+      channela.close()
+      utils.logclosechannel( `Mix 2 after play (clienta) for ${mstimeout} mS completed with reason '${d.reason}'`, d, mstimeout )
+    }
+  } )
+  utils.lognewchannel()
+
+  const channela = await projectrtp.openchannel( { "remote": { "address": "localhost", "port": clienta.local.port, "codec": acodec } }, async ( d ) => {
+    if( "play" === d.action && "end" === d.event && "channelmixing" === d.reason ) {
+      utils.log( "Channel stopped playback because channel mixing" )
+    } else if( "close" === d.action ) {
+      utils.logclosechannel( `Playback then mix for ${mstimeout} mS completed with reason '${d.reason}'`, d, mstimeout )
+    }
+  } )
+
+  clienta.remote( { "address": "localhost", "port": channela.local.port, "codec": acodec } )
+  clienta.echo()
+  utils.lognewchannel()
+
+  channela.play( {
+    "loop": true,
+    "files": [
+      { "wav": "/tmp/ukringing.wav" }
+    ]
+  } )
+
+  await utils.waitbetween( 100, 1000 )
+  
+  const clientb = await projectrtp.openchannel( {}, ( d ) => {
+    if( "close" === d.action ) {
+    channelb.close()
+    utils.logclosechannel( `Mix 2 after play (clientb) for ${mstimeout} mS completed with reason '${d.reason}'`, d, mstimeout )
+    }
+  } )
+  utils.lognewchannel()
+
+  const channelb = await projectrtp.openchannel( { "remote": { "address": "localhost", "port": clientb.local.port, "codec": bcodec } }, ( d ) => {
+      if( "close" === d.action ) {
+      utils.logclosechannel( `Mix 2 after play (channelb) for ${mstimeout} mS completed with reason '${d.reason}'`, d, mstimeout )
+      }
+  } )
+  clientb.remote( { "address": "localhost", "port": channelb.local.port, "codec": bcodec } )
+  utils.lognewchannel()
+
+  expect( await channela.mix( channelb ) ).to.be.true
+  expect( clienta.play( { "loop": true, "files": [ { "wav": "/tmp/ukringing.wav" } ] } ) ).to.be.true
+  expect( clientb.echo() ).to.be.true
+
+  await new Promise( ( r ) => { setTimeout( () => r(), Math.max( mstimeout, 110 ) ) } )
+  clienta.close()
+  clientb.close()
+
+}

package/stress/utils.js

@@ -21,8 +21,8 @@ module.exports.logclosechannel = ( message, d, mstimeout ) => {
   totalcount++
   module.exports.log( message )
 
-  const score = ( d.stats.in["count"] / mstimeout * 20 ).toFixed( 2 )
-  let scoremsg = ` Score: ${ score }`
+  const score = ( d.stats.in["count"] / mstimeout * 20 )
+  let scoremsg = ` Score: ${ score.toFixed( 2 ) }`
 
   // Colour based on score: red, yellow, green
   if( 0.25 >= score ) scoremsg = "\x1B[31m" + scoremsg
@@ -50,17 +50,41 @@ module.exports.mktempwav = () => {
   return "/tmp/project_" + (Math.random() + 1).toString(36).substring(7) + ".wav"
 }
 
+/**
+ * 
+ * @param { number } min - lower value 
+ * @param { number } max - upper value
+ * @returns { number }
+ */
 module.exports.between = ( min, max ) => {
   return Math.floor(
     Math.random() * ( max - min ) + min
   )
 }
 
+/**
+ * 
+ * @param { number } min - min time mS
+ * @param { number } max - max time mS
+ * @returns { Promise }
+ */
 module.exports.waitbetween = async ( min, max ) => {
-  return new Promise( ( resolve ) => { setTimeout( () => resolve(), module.exports.between( min, max ) ) } )
+  await new Promise( ( resolve ) => { setTimeout( () => resolve(), module.exports.between( min, max ) ) } )
+}
+
+/**
+ * 
+ * @param { number } ms 
+ */
+module.exports.wait = async ( ms ) => {
+  await new Promise( ( resolve ) => { setTimeout( () => resolve(), ms ) } )
 }
 
 const possiblecodecs = [ 0, 8, 9, 97 ]
+/**
+ * Returns random supported CODEC
+ * @returns { number }
+ */
 module.exports.randcodec = () => {
   return possiblecodecs[ module.exports.between( 0, possiblecodecs.length ) ]
 }

package/test/interface/projectrtpdtmf.js

@@ -38,6 +38,26 @@ function parsepk( packet ) {
   }
 }
 
+/**
+ * Limitation of not parsing ccrc.
+ * @param { Buffer } packet
+ * @return { object }
+ */
+function parse2833pk( packet ) {
+  return {
+    sn: packet.readUInt16BE( 2 ),
+    ts: packet.readUInt32BE( 4 ),
+    pt: packet.readUInt8( 1 ) & 0x7f,
+    ssrc: packet.readUInt32BE( 8 ),
+    event: {
+      id: packet.readUInt8( 12 ),
+      eoe: ( packet.readUInt8( 13 ) & 0x80 ) == 0x80,
+      volume: packet.readUInt8( 13 ) & 0x7f,
+      duration: packet.readUInt16BE( 14 ),
+    }
+  }
+}
+
 /* helper functions */
 function sendpk( sn, ts, sendtime, dstport, server, pt = 0, ssrc ) {
 
@@ -182,7 +202,7 @@ describe( "dtmf", function() {
 
         if( "close" === d.action ) {
           server.close()
-          expect( dtmfpkcount ).to.equal( 2*6 )
+          expect( dtmfpkcount ).to.equal( 2*7 )
           done()
         }
       } )
@@ -206,10 +226,10 @@ describe( "dtmf", function() {
     const clienta = dgram.createSocket( "udp4" )
     const clientb = dgram.createSocket( "udp4" )
 
-    let dtmfpkcount = 0
+    const dtmfpks = []
     clienta.on( "message", function( msg ) {
       if( 101 == ( 0x7f & msg [ 1 ] ) ) {
-        dtmfpkcount++
+        dtmfpks.push( parse2833pk( msg ) )
       } else {
         expect( msg.length ).to.equal( 172 )
         expect( 0x7f & msg [ 1 ] ).to.equal( 0 )
@@ -219,7 +239,6 @@ describe( "dtmf", function() {
     clientb.on( "message", function( msg ) {
       if( 101 == ( 0x7f & msg [ 1 ] ) ) {
         expect( true ).to.equal( false ) //here = bad
-        dtmfpkcount++
       }
       clientb.send( msg, channelb.local.port, "localhost" )
     } )
@@ -263,7 +282,19 @@ describe( "dtmf", function() {
     clienta.close()
     clientb.close()
 
-    expect( dtmfpkcount ).to.equal( 3*6 )
+    expect( dtmfpks.length ).to.equal( 3*7 )
+    expect( dtmfpks[ 0 ].event.id ).to.equal( 10 )
+    expect( dtmfpks[ 0 ].event.duration ).to.equal( 160 )
+    expect( dtmfpks[ 0 ].event.eoe ).to.be.false
+
+    expect( dtmfpks[ 4 ].event.id ).to.equal( 10 )
+    expect( dtmfpks[ 4 ].event.duration ).to.equal( 800 )
+    expect( dtmfpks[ 4 ].event.eoe ).to.be.true
+
+    expect( dtmfpks[ 6 ].event.id ).to.equal( 10 )
+    expect( dtmfpks[ 6 ].event.duration ).to.equal( 800 )
+    expect( dtmfpks[ 6 ].event.eoe ).to.be.true
+
   } )
 
   it( "2 channels mixing and request rtp server to send 2833 to one with dynamic payloadtype", async function() {
@@ -331,7 +362,7 @@ describe( "dtmf", function() {
     clienta.close()
     clientb.close()
 
-    expect( dtmfpkcount ).to.equal( 3*6 )
+    expect( dtmfpkcount ).to.equal( 3*7 )
   } )
 
   it( "3 channels mixing and request rtp server to send 2833 to one", async function() {
@@ -341,11 +372,11 @@ describe( "dtmf", function() {
     const clientb = dgram.createSocket( "udp4" )
     const clientc = dgram.createSocket( "udp4" )
 
-    let dtmfpkcount = 0
+    let dtmfpks = []
     clienta.on( "message", function( msg ) {
       const pk = parsepk( msg )
       if( 101 == pk.pt ) {
-        dtmfpkcount++
+        dtmfpks.push( parse2833pk( msg ) )
       } else {
         expect( msg.length ).to.equal( 172 )
         expect( pk.pt ).to.equal( 0 )
@@ -355,7 +386,6 @@ describe( "dtmf", function() {
     clientb.on( "message", function( msg ) {
       if( 101 == ( 0x7f & msg [ 1 ] ) ) {
         expect( true ).to.equal( false ) //here = bad
-        dtmfpkcount++
       }
       clientb.send( msg, channelb.local.port, "localhost" )
     } )
@@ -363,7 +393,6 @@ describe( "dtmf", function() {
     clientc.on( "message", function( msg ) {
       if( 101 == ( 0x7f & msg [ 1 ] ) ) {
         expect( true ).to.equal( false ) //here = bad
-        dtmfpkcount++
       }
       clientb.send( msg, channelb.local.port, "localhost" )
     } )
@@ -407,14 +436,14 @@ describe( "dtmf", function() {
 
     await new Promise( ( resolve ) => { setTimeout( () => resolve(), 100 ) } )
     channela.dtmf( "*9ABD" )
-    await new Promise( ( resolve ) => { setTimeout( () => resolve(), 900 ) } )
+    await new Promise( ( resolve ) => { setTimeout( () => resolve(), 1500 ) } )
     channela.close()
 
     clienta.close()
     clientb.close()
     clientc.close()
 
-    expect( dtmfpkcount ).to.equal( 5*6 )
+    expect( dtmfpks.length ).to.equal( 5*7 )
 
     await finished
   } )

package/test/interface/projectrtpmix.js

@@ -4,6 +4,7 @@
 const expect = require( "chai" ).expect
 const dgram = require( "dgram" )
 const projectrtp = require( "../../index.js" ).projectrtp
+const fs = require( "node:fs" ).promises
 
 function sendpk( sn, sendtime, dstport, server, data = undefined, pt = 0, ssrc = 25 ) {
 
@@ -41,6 +42,14 @@ function sendpk( sn, sendtime, dstport, server, data = undefined, pt = 0, ssrc =
 
 describe( "channel mix", function() {
 
+  this.beforeAll( () => {
+    projectrtp.tone.generate( "400+450*0.5/0/400+450*0.5/0:400/200/400/2000", "/tmp/ukringing.wav" )
+  } )
+
+  this.afterAll( async () => {
+    await fs.unlink( "/tmp/ukringing.wav" )
+  } )
+
   it( "basic mix 2 channels", async function() {
 
     this.timeout( 3000 )
@@ -661,6 +670,75 @@ describe( "channel mix", function() {
 
   } )
 
+
+  it( "playback prompt then mix 2 channels - pcmu <-> g722 with recording", 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( 0x7f & msg [ 1 ] ).to.equal( 0 )
+    } )
+
+    endpointb.on( "message", function( msg ) {
+
+      endpointbpkcount++
+      expect( 0x7f & msg [ 1 ] ).to.equal( 9 )
+      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 } }, function( d ) {
+      if( "close" === d.action ) channelb.close()
+    } )
+
+    channela.play( { "loop": true, "files": [
+      { "wav": "/tmp/ukringing.wav" } ] } )
+
+    await new Promise( resolve => setTimeout( resolve, 500 ) )
+
+    const channelb = await projectrtp.openchannel( { "remote": { "address": "localhost", "port": endpointb.address().port, "codec": 9 } }, function( d ) {
+      if( "close" === d.action ) done()
+    } )
+
+    /* mix */
+    expect( channela.mix( channelb ) ).to.be.true
+
+    channela.record( { "file": "/tmp/g722mix2recording.wav" } )
+
+    /* Now, when we send UDP on endpointb it  passes through our mix then arrives at endpointa */
+    for( let i = 0;  50 > i; i ++ ) {
+      sendpk( i, i, channela.local.port, endpointa )
+    }
+
+    await new Promise( ( resolve ) => { setTimeout( () => resolve(), 1500 ) } )
+
+    channela.close()
+    endpointa.close()
+    endpointb.close()
+
+    expect( endpointapkcount ).to.be.above( 30 )
+    expect( endpointbpkcount ).to.be.above( 30 )
+
+    await finished
+
+  } )
+
   it( "mix 3 channels - 1 writer 3 readers", async function() {
 
     this.timeout( 3000 )

package/test/interface/projectrtprecord.js

@@ -470,7 +470,7 @@ describe( "record", function() {
     server.close()
 
     let stats = fs.statSync( "/tmp/dualrecordingpower.wav" )
-    expect( stats.size ).to.be.within( 30000 , 40000 )
+    expect( stats.size ).to.be.within( 30000 , 41000 )
 
     stats = fs.statSync( "/tmp/dualrecording.wav" )
     expect( stats.size ).to.be.within( 110000, 190000 )