sip-lab 1.21.0 → 1.23.0

package/samples/text_to_speech.js

@@ -0,0 +1,195 @@
+var sip = require ('../index.js')
+var Zeq = require('@mayama/zeq')
+var z = new Zeq()
+var m = require('data-matching')
+var sip_msg = require('sip-matching')
+var sdp = require('sdp-matching')
+
+async function test() {
+    //sip.set_log_level(6)
+    sip.dtmf_aggregation_on(500)
+
+    z.trap_events(sip.event_source, 'event', (evt) => {
+        var e = evt.args[0]
+        return e
+    })
+
+    console.log(sip.start((data) => { console.log(data)} ))
+
+    t1 = sip.transport.create({address: "127.0.0.1", type: 'tcp'})
+    t2 = sip.transport.create({address: "127.0.0.1", type: 'tcp'})
+
+    console.log("t1", t1)
+    console.log("t2", t2)
+
+    oc = sip.call.create(t1.id, {
+        from_uri: '"abc"<sip:alice@test.com>',
+        to_uri: `sip:bob@${t2.address}:${t2.port}`,
+        headers: {
+            'X-MyHeader1': 'abc',
+            'X-MyHeader2': 'def',
+        },
+    })
+
+    await z.wait([
+        {
+            event: "incoming_call",
+            call_id: m.collect("call_id"),
+            msg: sip_msg({
+                $rm: 'INVITE',
+                $fU: 'alice',
+                $fd: 'test.com',
+                $tU: 'bob',
+                '$hdr(X-MyHeader1)': 'abc',
+                'hdr_x_myheader2': 'def',
+            }),
+        },
+        {
+            event: 'response',
+            call_id: oc.id,
+            method: 'INVITE',
+            msg: sip_msg({
+                $rs: '100',
+                $rr: 'Trying',
+                '$(hdrcnt(via))': 1,
+                'hdr_call_id': m.collect('sip_call_id'),
+                $fU: 'alice',
+                $fd: 'test.com',
+                $tU: 'bob',
+                '$hdr(l)': '0',
+            }),
+        },
+    ], 1000)
+
+    ic = {
+        id: z.store.call_id,
+        sip_call_id: z.store.sip_call_id,
+    }
+
+    sip.call.respond(ic.id, {
+        code: 200,
+        reason:'OK',
+        headers: {
+            'X-MyHeader3': 'ghi',
+            'X-MyHeader4': 'jkl',
+        },
+    })
+
+    await z.wait([
+        {
+            event: 'media_update',
+            call_id: oc.id,
+            status: 'ok',
+        },
+        {
+            event: 'media_update',
+            call_id: ic.id,
+            status: 'ok',
+        },
+        {
+            event: 'response',
+            call_id: oc.id,
+            method: 'INVITE',
+            msg: sip_msg({
+                $rs: '200',
+                $rr: 'OK',
+                '$(hdrcnt(v))': 1,
+                $fU: 'alice',
+                $fd: 'test.com',
+                $tU: 'bob',
+                '$hdr(content-type)': 'application/sdp',
+                $rb: '!{_}a=sendrecv',
+                '$hdr(X-MyHeader3)': 'ghi',
+                '$hdr(X-MyHeader4)': 'jkl',
+            }),
+        },
+    ], 1000)
+
+    await z.sleep(500)
+
+    sip.call.start_record_wav(oc.id, {file: './oc.wav'})
+    sip.call.start_record_wav(ic.id, {file: './ic.wav'})
+
+    sip.call.send_dtmf(oc.id, {digits: '1234', mode: 1})
+    sip.call.send_dtmf(ic.id, {digits: '1234', mode: 1})
+
+    await z.wait([
+	{
+		event: 'dtmf',
+		call_id: ic.id,
+		digits: '1234',
+		mode: 1,
+		media_id: 0
+	},
+	{
+		event: 'dtmf',
+		call_id: oc.id,
+		digits: '1234',
+		mode: 1,
+		media_id: 0
+	},
+    ], 3000)
+
+    sip.call.start_speech_synth(oc.id, {voice: 'slt', text: 'Hello World.', end_of_speech_event: true})
+    sip.call.start_speech_synth(ic.id, {voice: 'kal', text: 'How are you?', end_of_speech_event: true, no_loop: true})
+
+    await z.wait([
+        {
+            event: 'end_of_speech',
+            call_id: ic.id,
+        },
+        {
+            event: 'end_of_speech',
+            call_id: oc.id,
+        },
+    ], 2000)
+
+    await z.wait([
+        {
+            event: 'end_of_speech',
+            call_id: oc.id,
+        },
+    ], 2000)
+
+    sip.call.stop_speech_synth(oc.id) // this is not actually necessary. It is used just to confirm the command works
+    sip.call.stop_speech_synth(ic.id) // this is not actually necessary. It is used just to confirm the command works
+
+    sip.call.stop_record_wav(oc.id)
+    sip.call.stop_record_wav(ic.id)
+
+    sip.call.terminate(oc.id)
+
+    await z.wait([
+        {
+            event: 'call_ended',
+            call_id: oc.id,
+        },
+        {
+            event: 'call_ended',
+            call_id: ic.id,
+        },
+        {
+            event: 'response',
+            call_id: oc.id,
+            method: 'BYE',
+            msg: sip_msg({
+                $rs: '200',
+                $rr: 'OK',
+            }),
+        },
+    ], 1000)
+
+    await z.sleep(1000)
+
+    console.log("Success")
+
+    sip.stop()
+}
+
+
+test()
+.catch(e => {
+    console.error(e)
+    process.exit(1)
+})
+

package/src/addon.cpp

@@ -569,6 +569,40 @@ Napi::Value call_start_fax(const Napi::CallbackInfo &info) {
   return env.Null();
 }
 
+Napi::Value call_start_speech_synth(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() != 2) {
+    Napi::Error::New(env,
+                     "Wrong number of arguments. Expected: call_id, params.")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (!info[0].IsNumber()) {
+    Napi::TypeError::New(env, "call_id must be number.")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  int call_id = info[0].As<Napi::Number>().Int32Value();
+
+  if (!info[1].IsString()) {
+    Napi::TypeError::New(env, "params must be a JSON string.")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  const string json = info[1].As<Napi::String>().Utf8Value();
+
+  int res = pjw_call_start_speech_synth(call_id, json.c_str());
+
+  if (res != 0) {
+    Napi::Error::New(env, pjw_get_error()).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  return env.Null();
+}
+
 Napi::Value call_stop_record_wav(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
 
@@ -670,6 +704,40 @@ Napi::Value call_stop_fax(const Napi::CallbackInfo &info) {
   return env.Null();
 }
 
+Napi::Value call_stop_speech_synth(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() != 2) {
+    Napi::Error::New(env, "Wrong number of arguments. Expected: call_id")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (!info[0].IsNumber()) {
+    Napi::TypeError::New(env, "call_id must be number.")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  int call_id = info[0].As<Napi::Number>().Int32Value();
+
+  if (!info[1].IsString()) {
+    Napi::TypeError::New(env, "params must be a JSON string.")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  const string json = info[1].As<Napi::String>().Utf8Value();
+
+  int res = pjw_call_stop_speech_synth(call_id, json.c_str());
+
+  if (res != 0) {
+    Napi::Error::New(env, pjw_get_error()).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  return env.Null();
+}
+
+
 Napi::Value call_get_stream_stat(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
 
@@ -1265,11 +1333,15 @@ Napi::Object init(Napi::Env env, Napi::Object exports) {
   exports.Set("call_start_play_wav",
               Napi::Function::New(env, call_start_play_wav));
   exports.Set("call_start_fax", Napi::Function::New(env, call_start_fax));
+
+  exports.Set("call_start_speech_synth", Napi::Function::New(env, call_start_speech_synth));
+
   exports.Set("call_stop_record_wav",
               Napi::Function::New(env, call_stop_record_wav));
   exports.Set("call_stop_play_wav",
               Napi::Function::New(env, call_stop_play_wav));
   exports.Set("call_stop_fax", Napi::Function::New(env, call_stop_fax));
+  exports.Set("call_stop_speech_synth", Napi::Function::New(env, call_stop_speech_synth));
   exports.Set("call_get_stream_stat",
               Napi::Function::New(env, call_get_stream_stat));
   // exports.Set("call_refer", Napi::Function::New(env, call_refer));

package/src/event_templates.cpp

@@ -49,14 +49,9 @@ int make_evt_dtmf(char *dest, int size, long call_id, int digits_len,
 
 int make_evt_call_ended(char *dest, int size, long call_id, int sip_msg_len,
                         const char *sip_msg) {
-  printf("make_evt_call_ended sip_msg_len=%i sip_msg=%s\n", sip_msg_len,
+  printf("make_evt_call_ended sip_msg_len=%i sip_msg=%p\n", sip_msg_len,
          sip_msg);
-  if (!sip_msg || sip_msg == (char *)0xc000000000000) {
-    // received invalid pointer to sip_msg so do not add the message to the
-    // event
-    return snprintf(dest, size, "{\"event\": \"call_ended\", \"call_id\": %ld}",
-                    call_id);
-  } else if (sip_msg_len > 500 && sip_msg_len < 2000 && sip_msg) {
+  if (sip_msg_len > 500 && sip_msg_len < 2000 && sip_msg) {
     /* sip_msg_len sometimes show up as a large value like sip_msg_len=11560297
      * which seems to be a bug in pjsip */
     return snprintf(dest, size,
@@ -104,6 +99,18 @@ int make_evt_fax_result(char *dest, int size, long call_id, int result) {
       result);
 }
 
+int make_evt_end_of_file(char *dest, int size, long call_id) {
+  return snprintf(
+      dest, size,
+      "{\"event\": \"end_of_file\", \"call_id\": %ld}", call_id);
+}
+
+int make_evt_end_of_speech(char *dest, int size, long call_id) {
+  return snprintf(
+      dest, size,
+      "{\"event\": \"end_of_speech\", \"call_id\": %ld}", call_id);
+}
+
 int make_evt_tcp_msg(char *dest, int size, long call_id, const char *protocol, char *data, int data_len) {
   return snprintf(
       dest, size,

package/src/event_templates.hpp

@@ -34,6 +34,10 @@ int make_evt_registration_status(char *dest, int size, long account_id,
 
 int make_evt_fax_result(char *dest, int size, long call_id, int result);
 
+int make_evt_end_of_file(char *dest, int size, long call_id);
+
+int make_evt_end_of_speech(char *dest, int size, long call_id);
+
 int make_evt_tcp_msg(char *dest, int size, long call_id, const char *protocol, char *data, int data_len);
 
 #endif

package/src/pjmedia/include/pjmedia/flite_port.h

@@ -0,0 +1,32 @@
+#ifndef __FLITE_PORT_H__
+#define __FLITE_PORT_H__
+
+#include <pjmedia/port.h>
+
+PJ_BEGIN_DECL
+
+enum pjmedia_filte_option
+{
+  PJMEDIA_SPEECH_NO_LOOP = 1
+};
+
+PJ_DEF(pj_status_t) pjmedia_flite_port_create( pj_pool_t *pool,
+				unsigned clock_rate,
+				unsigned channel_count,
+				unsigned samples_per_frame,
+				unsigned bits_per_sample,
+				const char *voice,
+				pjmedia_port **p_port);
+
+PJ_DEF(pj_status_t) pjmedia_flite_port_set_eof_cb(pjmedia_port *port,
+                               void *user_data,
+                               void (*cb)(pjmedia_port *port,
+                                          void *usr_data));
+
+PJ_DEF(pj_status_t) pjmedia_flite_port_speak( pjmedia_port *port,
+                                          const char *text,
+                                          unsigned options);
+
+PJ_END_DECL
+
+#endif	/* __FLITE_PORT_H__ */

package/src/pjmedia/src/pjmedia/flite_port.c

@@ -0,0 +1,263 @@
+/* adapted from https://github.com/signalwire/freeswitch/blob/master/src/mod/asr_tts/mod_flite/mod_flite.c */
+
+#include "flite_port.h"
+#include <pjmedia/errno.h>
+#include <pjmedia/port.h>
+#include <pj/assert.h>
+#include <pj/lock.h>
+#include <pj/pool.h>
+#include <pj/string.h>
+
+#include "siplab_constants.h"
+
+#include <flite/flite.h>
+
+#define SIGNATURE   PJMEDIA_SIGNATURE('f', 'l', 'i', 't')
+#define THIS_FILE   "flite_port.c"
+
+#if 0
+#   define TRACE_(expr)	PJ_LOG(4,expr)
+#else
+#   define TRACE_(expr)
+#endif
+
+static pj_status_t flite_get_frame(pjmedia_port *port, 
+					pjmedia_frame *frame);
+static pj_status_t flite_on_destroy(pjmedia_port *port);
+
+
+cst_voice *register_cmu_us_awb(void);
+void unregister_cmu_us_awb(cst_voice * v);
+
+cst_voice *register_cmu_us_kal(void);
+void unregister_cmu_us_kal(cst_voice * v);
+
+cst_voice *register_cmu_us_rms(void);
+void unregister_cmu_us_rms(cst_voice * v);
+
+cst_voice *register_cmu_us_slt(void);
+void unregister_cmu_us_slt(cst_voice * v);
+
+cst_voice *register_cmu_us_kal16(void);
+void unregister_cmu_us_kal16(cst_voice * v);
+
+static int initialized = 0;
+
+static struct {
+	cst_voice *awb;
+	cst_voice *kal;
+	cst_voice *rms;
+	cst_voice *slt;
+	cst_voice *kal16;
+} globals;
+
+struct flite_t {
+    struct pjmedia_port base;
+    unsigned         options;
+
+	cst_voice *v;
+    unsigned written_samples;
+	cst_wave *w;
+
+    pj_bool_t        subscribed;
+    void           (*cb)(pjmedia_port*, void*);
+};
+
+#define free_wave(w) if (w) {delete_wave(w) ; w = NULL; }
+#define FLITE_BLOCK_SIZE 1024 * 32
+
+/*
+ * Register a callback to be called when we reach the end of speech
+ */
+PJ_DEF(pj_status_t) pjmedia_flite_port_set_eof_cb(pjmedia_port *port,
+                               void *user_data,
+                               void (*cb)(pjmedia_port *port,
+                                          void *usr_data))
+{
+    struct flite_t *flite;
+
+    /* Sanity check */
+    PJ_ASSERT_RETURN(port, -PJ_EINVAL);
+
+    /* Check that this is really a flite port */
+    PJ_ASSERT_RETURN(port->info.signature == SIGNATURE, -PJ_EINVALIDOP);
+
+    flite = (struct flite_t*) port;
+
+    flite->base.port_data.pdata = user_data;
+    flite->cb = cb;
+
+    return PJ_SUCCESS;
+}
+
+
+static pj_status_t speech_on_event(pjmedia_event *event,
+                                 void *user_data)
+{
+    struct flite_t *flite = (struct flite_t*)user_data;
+
+    if (event->type == PJMEDIA_EVENT_CALLBACK) {
+        if (flite->cb)
+            (*flite->cb)(&flite->base, flite->base.port_data.pdata);
+    }
+    
+    return PJ_SUCCESS;
+}
+
+PJ_DEF(pj_status_t) pjmedia_flite_port_create( pj_pool_t *pool,
+				unsigned clock_rate,
+				unsigned channel_count,
+				unsigned samples_per_frame,
+				unsigned bits_per_sample,
+				const char *voice,
+				pjmedia_port **p_port)
+{
+    struct flite_t *flite;
+    const pj_str_t name = pj_str("flite_data");
+
+    if(!initialized) {
+        flite_init();
+        globals.awb = register_cmu_us_awb();
+        globals.kal = register_cmu_us_kal();
+        globals.rms = register_cmu_us_rms();
+        globals.slt = register_cmu_us_slt();
+        globals.kal16 = register_cmu_us_kal16();
+        initialized = 1;
+    }
+
+    PJ_ASSERT_RETURN(pool && clock_rate && channel_count && 
+		     samples_per_frame && bits_per_sample == 16 && 
+		     p_port != NULL, PJ_EINVAL);
+
+    PJ_ASSERT_RETURN(pool && p_port, PJ_EINVAL);
+
+    flite = PJ_POOL_ZALLOC_T(pool, struct flite_t);
+    PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
+
+    pjmedia_port_info_init(&flite->base.info, &name, SIGNATURE, clock_rate,
+			   channel_count, bits_per_sample, samples_per_frame);
+
+    flite->base.get_frame = &flite_get_frame;
+    flite->base.on_destroy = &flite_on_destroy;
+
+	if (!strcasecmp(voice, "awb")) {
+		flite->v = globals.awb;
+	} else if (!strcasecmp(voice, "kal")) {
+/*  "kal" is 8kHz and the native rate is set to 16kHz
+ *  so kal talks a little bit too fast ...
+ *  for now: "symlink" kal to kal16
+ */		flite->v = globals.kal16;
+	} else if (!strcasecmp(voice, "rms")) {
+		flite->v = globals.rms;
+	} else if (!strcasecmp(voice, "slt")) {
+		flite->v = globals.slt;
+	} else if (!strcasecmp(voice, "kal16")) {
+		flite->v = globals.kal16;
+	} else {
+		TRACE_((THIS_FILE, "Invalid voice"));
+        return 0;
+	}
+
+    TRACE_((THIS_FILE, "flite_device created: %u/%u/%u/%u", clock_rate, 
+	    channel_count, samples_per_frame, bits_per_sample));
+
+    *p_port = &flite->base; 
+    return PJ_SUCCESS;
+}
+
+PJ_DEF(pj_status_t) pjmedia_flite_port_speak( pjmedia_port *port,
+                                          const char *text,
+                                          unsigned options) {
+    struct flite_t *flite = (struct flite_t*)port;
+    if(flite->w) {
+        free_wave(flite->w);
+    }
+    
+    flite->options = options;
+
+    flite->w = flite_text_to_wave(text, flite->v);
+    if ((unsigned)flite->w->sample_rate != PJMEDIA_PIA_SRATE(&port->info)) {
+        printf("resampling from %i to %i\n", flite->w->sample_rate, PJMEDIA_PIA_SRATE(&port->info));
+        cst_wave_resample(flite->w, PJMEDIA_PIA_SRATE(&port->info));
+    }
+    flite->written_samples = 0;
+
+    return PJ_SUCCESS;
+}
+
+// called when pjmedia needs data to be sent out
+static pj_status_t flite_get_frame(pjmedia_port *port,
+					pjmedia_frame *frame) {
+
+	PJ_ASSERT_RETURN(port && frame, PJ_EINVAL);
+
+    struct flite_t *flite = (struct flite_t*)port;
+
+    if(!flite->w) {
+        printf("flite no data\n");
+        frame->type = PJMEDIA_FRAME_TYPE_NONE;
+        return PJ_SUCCESS;
+    }
+
+    printf("written_samples=%i num_samples=%i\n", flite->written_samples, flite->w->num_samples);
+    if (flite->written_samples + PJMEDIA_PIA_SPF(&port->info) > (unsigned)flite->w->num_samples) {
+        printf("flite end of speech\n");
+
+        if(flite->cb) {
+            if (!flite->subscribed) {
+                pj_status_t status = pjmedia_event_subscribe(NULL, &speech_on_event,
+                                                 flite, flite);
+                flite->subscribed = (status == PJ_SUCCESS)? PJ_TRUE:
+                                    PJ_FALSE;
+            }
+
+            if (flite->subscribed) {
+                pjmedia_event event;
+
+                pjmedia_event_init(&event, PJMEDIA_EVENT_CALLBACK,
+                                   NULL, flite);
+                pjmedia_event_publish(NULL, flite, &event,
+                                      PJMEDIA_EVENT_PUBLISH_POST_EVENT);
+            }
+        }
+
+        pj_bool_t no_loop = (flite->options & PJMEDIA_SPEECH_NO_LOOP);
+
+        if(no_loop) {
+            free_wave(flite->w);
+            frame->type = PJMEDIA_FRAME_TYPE_NONE;
+            return PJ_SUCCESS;
+        } else {
+            flite->written_samples = 0;
+        }
+    }
+
+    memcpy(frame->buf, flite->w->samples + flite->written_samples, PJMEDIA_PIA_SPF(&port->info)*2);
+    flite->written_samples += PJMEDIA_PIA_SPF(&port->info);
+    frame->type = PJMEDIA_FRAME_TYPE_AUDIO;
+    printf("flite data written samples=%i\n", PJMEDIA_PIA_SPF(&port->info));
+
+    return PJ_SUCCESS;
+}
+
+/*
+ * Destroy port.
+ */
+static pj_status_t flite_on_destroy(pjmedia_port *port)
+{
+	printf("flite_on_destroy\n");
+
+    struct flite_t *flite = (struct flite_t*)port;
+
+    pj_assert(port->info.signature == SIGNATURE);
+
+    free_wave(flite->w);
+
+    if (flite->subscribed) {
+        pjmedia_event_unsubscribe(NULL, &speech_on_event, flite, flite);
+        flite->subscribed = PJ_FALSE;
+    }
+
+    return PJ_SUCCESS;
+}
+