sip-lab 1.22.0 → 1.24.0

package/src/addon.cpp

@@ -603,6 +603,41 @@ Napi::Value call_start_speech_synth(const Napi::CallbackInfo &info) {
   return env.Null();
 }
 
+Napi::Value call_start_speech_recog(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_recog(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();
 
@@ -704,6 +739,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();
 
@@ -1302,11 +1371,14 @@ Napi::Object init(Napi::Env env, Napi::Object exports) {
 
   exports.Set("call_start_speech_synth", Napi::Function::New(env, call_start_speech_synth));
 
+  exports.Set("call_start_speech_recog", Napi::Function::New(env, call_start_speech_recog));
+
   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,24 @@ 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_speech_transcript(char *dest, int size, long call_id, char* transcript) {
+  return snprintf(
+      dest, size,
+      "{\"event\": \"speech_transcript\", \"call_id\": %ld, \"transcript\": \"%s\"}", call_id, transcript);
+}
+
 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,12 @@ 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_speech_transcript(char *dest, int size, long call_id, char* transcript);
+
 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/include/pjmedia/pocketsphinx_port.h

@@ -0,0 +1,19 @@
+#ifndef __POCKETSPHINX_PORT_H__
+#define __POCKETSPHINX_PORT_H__
+
+#include <pjmedia/port.h>
+
+PJ_BEGIN_DECL
+
+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,
+                void (*cb)(pjmedia_port*, void *user_data, char *transcript),
+                void *cb_user_data,
+				pjmedia_port **p_port);
+
+PJ_END_DECL
+
+#endif	/* __POCKETSPHINX_PORT_H__ */

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)
 {
@@ -107,10 +143,7 @@ PJ_DEF(pj_status_t) pjmedia_flite_port_create( pj_pool_t *pool,
 	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;
+		flite->v = globals.kal; // this uses SamplingRate of 8000. All others use 16000
 	} else if (!strcasecmp(voice, "rms")) {
 		flite->v = globals.rms;
 	} else if (!strcasecmp(voice, "slt")) {
@@ -122,9 +155,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 +170,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;
 
@@ -158,23 +191,48 @@ static pj_status_t flite_get_frame(pjmedia_port *port,
     struct flite_t *flite = (struct flite_t*)port;
 
     if(!flite->w) {
-        printf("flite no data\n");
+        //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) > flite->w->num_samples) {
-        printf("flite no more data\n");
-        free_wave(flite->w);
-        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));
+    //printf("flite data written samples=%i\n", PJMEDIA_PIA_SPF(&port->info));
 
     return PJ_SUCCESS;
 }
@@ -187,8 +245,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,273 @@
+/* $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 <pocketsphinx_port.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;
+
+    ps_decoder_t *decoder;
+    ps_config_t *config;
+    ps_endpointer_t *ep;
+
+    unsigned in_spf;
+    unsigned out_spf;
+
+    short *samples;
+    unsigned sample_count;
+
+    pj_bool_t subscribed;
+    void (*cb)(pjmedia_port*, void*, char*);
+    void *cb_user_data;
+
+    char transcript[4096];
+};
+
+static pj_status_t speech_on_event(pjmedia_event *event,
+                                 void *user_data)
+{
+    struct pocketsphinx_t *port = (struct pocketsphinx_t*)user_data;
+
+    if (event->type == PJMEDIA_EVENT_CALLBACK) {
+        if (port->cb)
+            (*port->cb)(&port->base, port->cb_user_data, port->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,
+                void (*cb)(pjmedia_port*, void *user_data, char *transcript),
+                void *cb_user_data,
+				pjmedia_port **p_port)
+{
+    struct pocketsphinx_t *port;
+    const pj_str_t name = pj_str("pocketsphinx");
+
+    PJ_ASSERT_RETURN(pool && clock_rate && channel_count == 1 && 
+		     samples_per_frame && bits_per_sample == 16 && 
+		     p_port != NULL, PJ_EINVAL);
+
+    PJ_ASSERT_RETURN(pool && p_port, PJ_EINVAL);
+
+    port = PJ_POOL_ZALLOC_T(pool, struct pocketsphinx_t);
+    PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
+
+    pjmedia_port_info_init(&port->base.info, &name, SIGNATURE, clock_rate,
+			   channel_count, bits_per_sample, samples_per_frame);
+
+    port->base.put_frame = &pocketsphinx_put_frame;
+    port->base.on_destroy = &pocketsphinx_on_destroy;
+
+    port->cb = cb;
+    port->cb_user_data = cb_user_data;
+
+    port->config = ps_config_init(NULL);
+    ps_default_search_args(port->config);
+    
+    if ((port->decoder = ps_init(port->config)) == NULL) {
+        TRACE_((THIS_FILE, "pocketsphinx port: decoder init failed\n"));
+        return !PJ_SUCCESS;
+    }
+
+    if ((port->ep = ps_endpointer_init(0, 0.0, 0, clock_rate, 0)) == NULL) {
+        TRACE_((THIS_FILE, "pocketsphinx port: endpointer init failed\n"));
+        return !PJ_SUCCESS;
+    }
+
+    port->in_spf = samples_per_frame;
+    port->out_spf = ps_endpointer_frame_size(port->ep);
+
+    port->samples = (short*) pj_pool_alloc(pool, port->out_spf * sizeof(short));
+    if (port->samples == NULL) {
+        TRACE_(("Failed to allocate buffer for samples\n"));
+        return !PJ_SUCCESS;
+    }
+
+    TRACE_((THIS_FILE, "pocketsphinx port created: %u/%u/%u/%u", clock_rate, 
+	    channel_count, samples_per_frame, bits_per_sample));
+
+    printf("pocketsphinx_create in_spf=%i out_spf=%i\n", port->in_spf, port->out_spf);
+    *p_port = &port->base; 
+    return PJ_SUCCESS;
+}
+
+void feed(struct pocketsphinx_t *port, short *frame) {
+    const int16 *speech;
+    int prev_in_speech = ps_endpointer_in_speech(port->ep);
+    speech = ps_endpointer_process(port->ep, frame);
+    if (speech != NULL) {
+        const char *hyp;
+        if (!prev_in_speech) {
+            printf("pocketsphinx speech start at %.2f\n", ps_endpointer_speech_start(port->ep));
+            ps_start_utt(port->decoder);
+        }
+        if (ps_process_raw(port->decoder, speech, port->out_spf, FALSE, FALSE) < 0) {
+            printf("pocketsphinx ps_process_raw() failed\n");
+            return;
+        }
+        if ((hyp = ps_get_hyp(port->decoder, NULL)) != NULL) {
+            //printf("pocketsphinx partial result: %s\n", hyp);
+        }
+        if (!ps_endpointer_in_speech(port->ep)) {
+            printf("Speech end at %.2f\n", ps_endpointer_speech_end(port->ep));
+            ps_end_utt(port->decoder);
+            if ((hyp = ps_get_hyp(port->decoder, NULL)) != NULL) {
+                printf("pocketsphinx speech: %s\n", hyp);
+                if(strlen(hyp) == 0) return;
+
+                strncpy(port->transcript, hyp, sizeof(port->transcript) - 1);
+
+                // Ensure the destination string is null-terminated
+                port->transcript[sizeof(port->transcript) - 1] = '\0';
+
+                if(port->cb) {
+                    if (!port->subscribed) {
+                        pj_status_t status = pjmedia_event_subscribe(NULL, &speech_on_event,
+                                                         port, port);
+                        port->subscribed = (status == PJ_SUCCESS)? PJ_TRUE:
+                                            PJ_FALSE;
+                    }
+
+                    if (port->subscribed) {
+                        pjmedia_event event;
+
+                        pjmedia_event_init(&event, PJMEDIA_EVENT_CALLBACK,
+                                           NULL, port);
+                        pjmedia_event_publish(NULL, port, &event,
+                                              PJMEDIA_EVENT_PUBLISH_POST_EVENT);
+                    }
+                }
+            }
+        }
+    }
+}
+
+unsigned feed_one(struct pocketsphinx_t *port, pjmedia_frame *frame){
+    unsigned used_samples = port->out_spf - port->sample_count;
+    memcpy((short*)port->samples + port->sample_count, frame->buf, used_samples * sizeof(short));
+    feed(port, port->samples);
+    port->sample_count = 0;
+    return used_samples;
+}
+
+void feed_all(struct pocketsphinx_t *port, pjmedia_frame *frame) {
+    unsigned samples = frame->size / 2;
+    unsigned used_samples = 0;
+   if(port->sample_count > 0) {
+       used_samples = feed_one(port, frame); 
+    }
+
+    short *out_frame = frame->buf + used_samples;
+    samples -= used_samples;
+    unsigned count = 0;
+    while(samples >= port->out_spf) {
+        feed(port, out_frame);
+        count++;
+        out_frame += (count * port->out_spf);
+        samples -= port->out_spf;
+    }
+
+    if(samples) {
+        memcpy(port->samples, out_frame, samples * sizeof(short));
+        port->sample_count = samples;
+    }
+}
+
+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_t *port = (struct pocketsphinx_t*) this_port;
+
+    if(port->in_spf == port->out_spf) {
+        //printf("feed\n");
+        feed(port, (short*)frame->buf);
+        return;
+    }
+
+    if(port->in_spf > port->out_spf) {
+        //printf("feed_all\n");
+        feed_all(port, frame);
+        return;
+    }
+
+    unsigned samples = frame->size / 2;
+    if(samples + port->sample_count >= port->out_spf) {
+        // enough to feed once
+        //printf("feed_one\n");
+        feed_one(port, frame);
+        return;
+    }
+            
+    // not enough to feed. 
+    //printf("not enough to feed\n");
+    memcpy((short*)port->samples + port->sample_count, frame->buf, samples * sizeof(short));
+    port->sample_count += samples;
+
+    return PJ_SUCCESS;
+}
+
+/*
+ * Destroy port.
+ */
+static pj_status_t pocketsphinx_on_destroy(pjmedia_port *this_port)
+{
+    struct pocketsphinx_t *port = (struct pocketsphinx_t*) this_port;
+
+    ps_endpointer_free(port->ep);
+    ps_free(port->decoder);
+    ps_config_free(port->config);
+ 
+    if (port->subscribed) {
+        pjmedia_event_unsubscribe(NULL, &speech_on_event, port, port);
+        port->subscribed = PJ_FALSE;
+    }
+
+    return PJ_SUCCESS;
+}
+
+