sip-lab 1.22.0 → 1.23.0

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

@@ -5,18 +5,24 @@
 
 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,
-				void (*cb)(pjmedia_port*, 
-					void *user_data, 
-					int result), 
-				void *user_data,
 				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);

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

@@ -53,26 +53,62 @@ static struct {
 
 struct flite_t {
     struct pjmedia_port base;
-	void (*flite_cb)(pjmedia_port*, void*, int);
-	void *flite_cb_user_data;
+    unsigned         options;
+
 	cst_voice *v;
-    int written_samples;
+    unsigned written_samples;
 	cst_wave *w;
-	char *buffer;
+
+    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,
-				void (*cb)(pjmedia_port*, 
-					void *user_data, 
-					int result), 
-				void *user_data,
 				const char *voice,
 				pjmedia_port **p_port)
 {
@@ -122,9 +158,6 @@ PJ_DEF(pj_status_t) pjmedia_flite_port_create( pj_pool_t *pool,
         return 0;
 	}
 
-    flite->flite_cb = cb;
-    flite->flite_cb_user_data = user_data;
-
     TRACE_((THIS_FILE, "flite_device created: %u/%u/%u/%u", clock_rate, 
 	    channel_count, samples_per_frame, bits_per_sample));
 
@@ -140,9 +173,12 @@ PJ_DEF(pj_status_t) pjmedia_flite_port_speak( pjmedia_port *port,
         free_wave(flite->w);
     }
     
+    flite->options = options;
+
     flite->w = flite_text_to_wave(text, flite->v);
-    if (flite->w->sample_rate != PJMEDIA_PIA_SRATE(&port->info)) {
-		cst_wave_resample(flite->w, PJMEDIA_PIA_SRATE(&port->info));
+    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;
 
@@ -164,11 +200,36 @@ static pj_status_t flite_get_frame(pjmedia_port *port,
     }
 
     printf("written_samples=%i num_samples=%i\n", flite->written_samples, flite->w->num_samples);
-    if (flite->written_samples + PJMEDIA_PIA_SPF(&port->info) > flite->w->num_samples) {
-        printf("flite no more data\n");
-        free_wave(flite->w);
-        frame->type = PJMEDIA_FRAME_TYPE_NONE;
-        return PJ_SUCCESS;
+    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);
@@ -187,8 +248,16 @@ 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;
 }
 

package/src/pjmedia/src/pjmedia/pocketsphinx_port.c

@@ -0,0 +1,150 @@
+/* $Id: pocketsphinx_port.c 0000 2024-03-09 mayamatakeshi $ */
+/* 
+ * Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
+ * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
+ */
+
+#include <pjmedia/pocketsphinx.h>
+#include <pjmedia/errno.h>
+#include <pjmedia/port.h>
+#include <pj/assert.h>
+#include <pj/pool.h>
+#include <pj/string.h>
+
+#include <pocketsphinx.h>
+
+#define SIGNATURE   PJMEDIA_SIGNATURE('p', 'i', 'n', 'x')
+#define THIS_FILE   "pocketsphinx_port.c"
+
+#if 0
+#   define TRACE_(expr)	PJ_LOG(4,expr)
+#else
+#   define TRACE_(expr)
+#endif
+
+static pj_status_t pocketsphinx_put_frame(pjmedia_port *this_port, 
+				  pjmedia_frame *frame);
+static pj_status_t pocketsphinx_on_destroy(pjmedia_port *this_port);
+
+struct pocketsphinx_t
+{
+    struct pjmedia_port	base;
+
+    pj_bool_t        subscribed;
+    void           (*cb)(pjmedia_port*, void*, char*);
+};
+
+/*
+ * Register a callback to be called when we get translation
+ */
+PJ_DEF(pj_status_t) pjmedia_pocketsphinx_port_set_speech_cb(pjmedia_port *port,
+                               void *user_data,
+                               void (*cb)(pjmedia_port *port,
+                                          void *usr_data, char *transcript))
+{
+    struct pocketsphinx_t *flite;
+
+    /* Sanity check */
+    PJ_ASSERT_RETURN(port, -PJ_EINVAL);
+
+    /* Check that this is really a pocketsphinx port */
+    PJ_ASSERT_RETURN(port->info.signature == SIGNATURE, -PJ_EINVALIDOP);
+
+    pocketsphinx = (struct pocketsphinx_t*) port;
+
+    pocketsphinx->base.port_data.pdata = user_data;
+    pocketsphinx->cb = cb;
+
+    return PJ_SUCCESS;
+}
+
+
+static pj_status_t speech_on_event(pjmedia_event *event,
+                                 void *user_data)
+{
+    struct pocketsphinx_t *pocketsphinx = (struct pocketsphinx_t*)user_data;
+
+    if (event->type == PJMEDIA_EVENT_CALLBACK) {
+        if (pocketsphinx->cb)
+            (*pocketsphinx->cb)(&flite->base, flite->base.port_data.pdata, "transcript");
+    }
+    
+    return PJ_SUCCESS;
+}
+
+PJ_DEF(pj_status_t) pjmedia_pocketsphinx_port_create( pj_pool_t *pool,
+				unsigned clock_rate,
+				unsigned channel_count,
+				unsigned samples_per_frame,
+				unsigned bits_per_sample,
+				pjmedia_port **p_port)
+{
+    struct pocketsphinx *pocketsphinx;
+    const pj_str_t name = pj_str("pocketsphinx");
+
+    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);
+
+    pocketsphinx = PJ_POOL_ZALLOC_T(pool, struct pocketsphinx);
+    PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
+
+    pjmedia_port_info_init(&pocketsphinx->base.info, &name, SIGNATURE, clock_rate,
+			   channel_count, bits_per_sample, samples_per_frame);
+
+    pocketsphinx->base.put_frame = &pocketsphinx_put_frame;
+    pocketsphinx->base.on_destroy = &pocketsphinx_on_destroy;
+
+    pocketsphinx->dtmf_cb = cb;
+    pocketsphinx->dtmf_cb_user_data = user_data;
+
+    dtmf_rx_init(&pocketsphinx->state, NULL, NULL);
+    dtmf_rx_set_realtime_callback(&pocketsphinx->state,
+					&pocketsphinx_digit_callback,
+					(void*)pocketsphinx);	 
+
+    TRACE_((THIS_FILE, "pocketsphinx created: %u/%u/%u/%u", clock_rate, 
+	    channel_count, samples_per_frame, bits_per_sample));
+
+    *p_port = &pocketsphinx->base; 
+    return PJ_SUCCESS;
+}
+
+static pj_status_t pocketsphinx_put_frame(pjmedia_port *this_port, 
+				  pjmedia_frame *frame)
+{
+    if(frame->type != PJMEDIA_FRAME_TYPE_AUDIO) return PJ_SUCCESS;
+
+    struct pocketsphinx *dport = (struct pocketsphinx*) this_port;
+    dtmf_rx(&dport->state, (const pj_int16_t*)frame->buf,
+		PJMEDIA_PIA_SPF(&dport->base.info));
+
+    return PJ_SUCCESS;
+
+}
+
+/*
+ * Destroy port.
+ */
+static pj_status_t pocketsphinx_on_destroy(pjmedia_port *this_port)
+{
+    return PJ_SUCCESS;
+}
+
+