commit dbea6143d6b63765f2d0eba26728c3903d3d2606
Author: achaloyan <achaloyan@f001bc3a-424a-0410-80a0-a715b8f413a8>
Date: Wed Jul 8 17:37:24 2009 +0000
Added yet another buffer of media frames mpf_frame_buffer.
There are a number of similar buffers (mpf_jitter_buffer, mpf_buffer, mpf_frame_buffer). All of them produce mpf_frames as output, but input is somewhat dif
ferent. Input is RTP payload in case of mpf_jitter_buffer, synthesized chunks of voice in case of mpf_buffer, and mpf_frame in case of mpf_frame_buffer
git-svn-id: https://unimrcp.googlecode.com/svn/trunk@1043 f001bc3a-424a-0410-80a0-a715b8f413a8
commit 1bf7a66012180649bd1f01fd72e483a9e5de3495
Author: achaloyan <achaloyan@f001bc3a-424a-0410-80a0-a715b8f413a8>
Date: Wed Jul 8 16:33:36 2009 +0000
Fixed termination of client and server stacks (Issue-28)
Network client/server stacks generated double TERMINATE_COMPLETE event, while mpf engine generated no TERMINATE_COMPLETE event.
git-svn-id: https://unimrcp.googlecode.com/svn/trunk@1042 f001bc3a-424a-0410-80a0-a715b8f413a8
commit 0327cf17779430b51290d22cc7d51130f997f2f2
Author: achaloyan <achaloyan@f001bc3a-424a-0410-80a0-a715b8f413a8>
Date: Sun Jul 5 19:22:31 2009 +0000
Enhanced flite plugin to
- support more than one SPEAK requests in a session (SPEAK -> STOP -> SPEAK or SPEAK-> SPEAK-COMPLETE->SPEAK), task is created upon channel creation and is
waiting for consecutive SPEAK requests to process
- properly handle race between STOP request and SPEAK-COMPLETE event
- respond with IN-PROGRESS, when all the required parameters are checked to be valid and synthesizing is due to start
git-svn-id: https://unimrcp.googlecode.com/svn/trunk@1037 f001bc3a-424a-0410-80a0-a715b8f413a8
commit e2f73f9279e54ef3a40cb637a38ab1ff485ea5d3
Author: achaloyan <achaloyan@f001bc3a-424a-0410-80a0-a715b8f413a8>
Date: Sun Jul 5 03:46:13 2009 +0000
Separated flite voices (unified voice register/unregister routine, select voice by name)
git-svn-id: https://unimrcp.googlecode.com/svn/trunk@1036 f001bc3a-424a-0410-80a0-a715b8f413a8
commit 694783a527cb795ca45982c2388895da06dd6009
Author: achaloyan <achaloyan@f001bc3a-424a-0410-80a0-a715b8f413a8>
Date: Sat Jul 4 05:06:17 2009 +0000
Checked content-type to be "text/plain" as flite doesn't support SSML yet.
git-svn-id: https://unimrcp.googlecode.com/svn/trunk@1035 f001bc3a-424a-0410-80a0-a715b8f413a8
commit aafdc6e30e77c40e5470cce844f48ec28a254786
Author: achaloyan <achaloyan@f001bc3a-424a-0410-80a0-a715b8f413a8>
Date: Fri Jul 3 14:55:10 2009 +0000
Enhanced float value generation to use the precision (digits after decimal sign) user provides by removing optional trailing 0s (if any)
Issue-35
git-svn-id: https://unimrcp.googlecode.com/svn/trunk@1034 f001bc3a-424a-0410-80a0-a715b8f413a8
commit bcc2f137956f5c532c0256b064c8a3d1015a46d0
Author: achaloyan <achaloyan@f001bc3a-424a-0410-80a0-a715b8f413a8>
Date: Fri Jul 3 07:04:07 2009 +0000
Enhanced RTP port management (Issue-34, Thanks cpsoares)
git-svn-id: https://unimrcp.googlecode.com/svn/trunk@1033 f001bc3a-424a-0410-80a0-a715b8f413a8
--- freeswitch/trunk/libs/unimrcp/.update 2009-07-09 09:29:32 UTC (rev 14165)
+++ freeswitch/trunk/libs/unimrcp/.update 2009-07-09 15:19:27 UTC (rev 14166)
@@ -1 +1 @@
-Wed Jul 1 19:53:07 CDT 2009
+Thu Jul 9 10:17:26 CDT 2009
--- freeswitch/trunk/libs/unimrcp/libs/apr-toolkit/include/apt_text_stream.h 2009-07-09 09:29:32 UTC (rev 14165)
+++ freeswitch/trunk/libs/unimrcp/libs/apr-toolkit/include/apt_text_stream.h 2009-07-09 15:19:27 UTC (rev 14166)
@@ -22,8 +22,6 @@
* @brief Text Stream Parse/Generate Routine
*/
-#include <stdlib.h>
-#include <stdio.h>
#include "apt_string.h"
#include "apt_pair.h"
@@ -95,40 +93,17 @@
/** Generate boolean-value */
APT_DECLARE(apt_bool_t) apt_boolean_value_generate(apt_bool_t value, apt_text_stream_t *str);
-
/** Parse size_t value */
-static APR_INLINE apr_size_t apt_size_value_parse(const apt_str_t *str)
-{
- return str->buf ? atol(str->buf) : 0;
-}
+APT_DECLARE(apr_size_t) apt_size_value_parse(const apt_str_t *str);
/** Generate apr_size_t value */
-static APR_INLINE apt_bool_t apt_size_value_generate(apr_size_t value, apt_text_stream_t *stream)
-{
- int length = sprintf(stream->pos, "%"APR_SIZE_T_FMT, value);
- if(length <= 0) {
- return FALSE;
- }
- stream->pos += length;
- return TRUE;
-}
+APT_DECLARE(apt_bool_t) apt_size_value_generate(apr_size_t value, apt_text_stream_t *stream);
/** Parse float value */
-static APR_INLINE float apt_float_value_parse(const apt_str_t *str)
-{
- return str->buf ? (float)atof(str->buf) : 0;
-}
+APT_DECLARE(float) apt_float_value_parse(const apt_str_t *str);
/** Generate float value */
-static APR_INLINE apt_bool_t apt_float_value_generate(float value, apt_text_stream_t *stream)
-{
- int length = sprintf(stream->pos,"%.2f",value);
- if(length <= 0) {
- return FALSE;
- }
- stream->pos += length;
- return TRUE;
-}
+APT_DECLARE(apt_bool_t) apt_float_value_generate(float value, apt_text_stream_t *stream);
/** Generate string value */
static APR_INLINE apt_bool_t apt_string_value_generate(const apt_str_t *str, apt_text_stream_t *stream)
--- freeswitch/trunk/libs/unimrcp/libs/apr-toolkit/src/apt_net_client_task.c 2009-07-09 09:29:32 UTC (rev 14165)
+++ freeswitch/trunk/libs/unimrcp/libs/apr-toolkit/src/apt_net_client_task.c 2009-07-09 15:19:27 UTC (rev 14166)
@@ -300,8 +300,6 @@
}
apt_net_client_task_pollset_destroy(task);
-
- apt_task_child_terminate(task->base);
return TRUE;
}
--- freeswitch/trunk/libs/unimrcp/libs/apr-toolkit/src/apt_net_server_task.c 2009-07-09 09:29:32 UTC (rev 14165)
+++ freeswitch/trunk/libs/unimrcp/libs/apr-toolkit/src/apt_net_server_task.c 2009-07-09 15:19:27 UTC (rev 14166)
@@ -350,8 +350,6 @@
}
apt_net_server_task_pollset_destroy(task);
-
- apt_task_child_terminate(task->base);
return TRUE;
}
--- freeswitch/trunk/libs/unimrcp/libs/apr-toolkit/src/apt_text_stream.c 2009-07-09 09:29:32 UTC (rev 14165)
+++ freeswitch/trunk/libs/unimrcp/libs/apr-toolkit/src/apt_text_stream.c 2009-07-09 15:19:27 UTC (rev 14166)
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#include <stdlib.h>
+#include <stdio.h>
#include <apr_uuid.h>
#include "apt_text_stream.h"
@@ -307,7 +309,46 @@
return TRUE;
}
+/** Parse size_t value */
+APT_DECLARE(apr_size_t) apt_size_value_parse(const apt_str_t *str)
+{
+ return str->buf ? atol(str->buf) : 0;
+}
+/** Generate apr_size_t value */
+APT_DECLARE(apt_bool_t) apt_size_value_generate(apr_size_t value, apt_text_stream_t *stream)
+{
+ int length = sprintf(stream->pos, "%"APR_SIZE_T_FMT, value);
+ if(length <= 0) {
+ return FALSE;
+ }
+ stream->pos += length;
+ return TRUE;
+}
+
+/** Parse float value */
+APT_DECLARE(float) apt_float_value_parse(const apt_str_t *str)
+{
+ return str->buf ? (float)atof(str->buf) : 0;
+}
+
+/** Generate float value */
+APT_DECLARE(apt_bool_t) apt_float_value_generate(float value, apt_text_stream_t *stream)
+{
+ char *end;
+ int length = sprintf(stream->pos,"%f",value);
+ if(length <= 0) {
+ return FALSE;
+ }
+
+ /* remove trailing 0s (if any) */
+ end = stream->pos + length -1;
+ while(*end == 0x30 && end != stream->pos) end--;
+
+ stream->pos = end + 1;
+ return TRUE;
+}
+
/** Generate value plus the length (number of digits) of the value itself. */
APT_DECLARE(apt_bool_t) apt_var_length_value_generate(apr_size_t *value, apr_size_t max_count, apt_str_t *str)
{
--- freeswitch/trunk/libs/unimrcp/libs/mpf/Makefile.am 2009-07-09 09:29:32 UTC (rev 14165)
+++ freeswitch/trunk/libs/unimrcp/libs/mpf/Makefile.am 2009-07-09 15:19:27 UTC (rev 14166)
@@ -20,6 +20,7 @@
include/mpf_context.h \
include/mpf_engine.h \
include/mpf_frame.h \
+ include/mpf_frame_buffer.h \
include/mpf_message.h \
include/mpf_object.h \
include/mpf_stream.h \
@@ -55,6 +56,7 @@
src/mpf_termination.c \
src/mpf_rtp_termination_factory.c \
src/mpf_file_termination_factory.c \
+ src/mpf_frame_buffer.c \
src/mpf_timer.c \
src/mpf_encoder.c \
src/mpf_decoder.c \
--- freeswitch/trunk/libs/unimrcp/libs/mpf/include/mpf_frame_buffer.h (rev 0)
+++ freeswitch/trunk/libs/unimrcp/libs/mpf/include/mpf_frame_buffer.h 2009-07-09 15:19:27 UTC (rev 14166)
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2008 Arsen Chaloyan
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __MPF_FRAME_BUFFER_H__
+#define __MPF_FRAME_BUFFER_H__
+
+/**
+ * @file mpf_frame_buffer.h
+ * @brief Buffer of Media Frames
+ */
+
+#include "mpf_frame.h"
+
+APT_BEGIN_EXTERN_C
+
+/** Opaque frame buffer declaration */
+typedef struct mpf_frame_buffer_t mpf_frame_buffer_t;
+
+
+/** Create frame buffer */
+mpf_frame_buffer_t* mpf_frame_buffer_create(apr_size_t frame_size, apr_size_t frame_count, apr_pool_t *pool);
+
+/** Destroy frame buffer */
+void mpf_frame_buffer_destroy(mpf_frame_buffer_t *buffer);
+
+/** Restart frame buffer */
+apt_bool_t mpf_frame_buffer_restart(mpf_frame_buffer_t *buffer);
+
+/** Write frame to buffer */
+apt_bool_t mpf_frame_buffer_write(mpf_frame_buffer_t *buffer, const mpf_frame_t *frame);
+
+/** Read frame from buffer */
+apt_bool_t mpf_frame_buffer_read(mpf_frame_buffer_t *buffer, mpf_frame_t *frame);
+
+APT_END_EXTERN_C
+
+#endif /*__MPF_FRAME_BUFFER_H__*/
--- freeswitch/trunk/libs/unimrcp/libs/mpf/mpf.vcproj 2009-07-09 09:29:32 UTC (rev 14165)
+++ freeswitch/trunk/libs/unimrcp/libs/mpf/mpf.vcproj 2009-07-09 15:19:27 UTC (rev 14166)
@@ -208,6 +208,10 @@
>
</File>
<File
+ RelativePath=".\include\mpf_frame_buffer.h"
+ >
+ </File>
+ <File
RelativePath=".\include\mpf_jitter_buffer.h"
>
</File>
@@ -333,6 +337,10 @@
>
</File>
<File
+ RelativePath=".\src\mpf_frame_buffer.c"
+ >
+ </File>
+ <File
RelativePath=".\src\mpf_jitter_buffer.c"
>
</File>
--- freeswitch/trunk/libs/unimrcp/libs/mpf/src/mpf_engine.c 2009-07-09 09:29:32 UTC (rev 14165)
+++ freeswitch/trunk/libs/unimrcp/libs/mpf/src/mpf_engine.c 2009-07-09 15:19:27 UTC (rev 14166)
@@ -128,6 +128,7 @@
mpf_timer_stop(engine->timer);
mpf_engine_contexts_destroy(engine);
+ apt_task_child_terminate(task);
return TRUE;
}
--- freeswitch/trunk/libs/unimrcp/libs/mpf/src/mpf_frame_buffer.c (rev 0)
+++ freeswitch/trunk/libs/unimrcp/libs/mpf/src/mpf_frame_buffer.c 2009-07-09 15:19:27 UTC (rev 14166)
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2009 Arsen Chaloyan
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "mpf_frame_buffer.h"
+
+struct mpf_frame_buffer_t {
+ apr_byte_t *raw_data;
+ mpf_frame_t *frames;
+ apr_size_t frame_count;
+ apr_size_t frame_size;
+
+ apr_size_t write_pos;
+ apr_size_t read_pos;
+
+ apr_thread_mutex_t *guard;
+ apr_pool_t *pool;
+};
+
+
+mpf_frame_buffer_t* mpf_frame_buffer_create(apr_size_t frame_size, apr_size_t frame_count, apr_pool_t *pool)
+{
+ apr_size_t i;
+ mpf_frame_buffer_t *buffer = apr_palloc(pool,sizeof(mpf_frame_buffer_t));
+
+ buffer->frame_size = frame_size;
+ buffer->frame_count = frame_count;
+ buffer->raw_data = apr_palloc(pool,buffer->frame_size*buffer->frame_count);
+ buffer->frames = apr_palloc(pool,sizeof(mpf_frame_t)*buffer->frame_count);
+ for(i=0; i<buffer->frame_count; i++) {
+ buffer->frames[i].type = MEDIA_FRAME_TYPE_NONE;
+ buffer->frames[i].codec_frame.buffer = buffer->raw_data + i*buffer->frame_size;
+ }
+
+ buffer->write_pos = buffer->read_pos = 0;
+ apr_thread_mutex_create(&buffer->guard,APR_THREAD_MUTEX_UNNESTED,pool);
+ return buffer;
+}
+
+void mpf_frame_buffer_destroy(mpf_frame_buffer_t *buffer)
+{
+ if(buffer->guard) {
+ apr_thread_mutex_destroy(buffer->guard);
+ buffer->guard = NULL;
+ }
+}
+
+apt_bool_t mpf_frame_buffer_restart(mpf_frame_buffer_t *buffer)
+{
+ buffer->write_pos = buffer->read_pos;
+ return TRUE;
+}
+
+static APR_INLINE mpf_frame_t* mpf_frame_buffer_frame_get(mpf_frame_buffer_t *buffer, apr_size_t pos)
+{
+ apr_size_t index = pos % buffer->frame_count;
+ return &buffer->frames[index];
+}
+
+apt_bool_t mpf_frame_buffer_write(mpf_frame_buffer_t *buffer, const mpf_frame_t *frame)
+{
+ mpf_frame_t *write_frame;
+ void *data = frame->codec_frame.buffer;
+ apr_size_t size = frame->codec_frame.size;
+
+ apr_thread_mutex_lock(buffer->guard);
+ while(buffer->write_pos - buffer->read_pos < buffer->frame_count && size >= buffer->frame_size) {
+ write_frame = mpf_frame_buffer_frame_get(buffer,buffer->write_pos);
+ write_frame->type = frame->type;
+ write_frame->codec_frame.size = buffer->frame_size;
+ memcpy(
+ write_frame->codec_frame.buffer,
+ data,
+ write_frame->codec_frame.size);
+
+ data = (char*)data + buffer->frame_size;
+ size -= buffer->frame_size;
+ buffer->write_pos ++;
+ }
+
+ apr_thread_mutex_unlock(buffer->guard);
+ /* if size != 0 => non frame alligned or buffer is full */
+ return size == 0 ? TRUE : FALSE;
+}
+
+apt_bool_t mpf_frame_buffer_read(mpf_frame_buffer_t *buffer, mpf_frame_t *media_frame)
+{
+ apr_thread_mutex_lock(buffer->guard);
+ if(buffer->write_pos > buffer->read_pos) {
+ /* normal read */
+ mpf_frame_t *src_media_frame = mpf_frame_buffer_frame_get(buffer,buffer->read_pos);
+ media_frame->type = src_media_frame->type;
+ if(media_frame->type & MEDIA_FRAME_TYPE_AUDIO) {
+ media_frame->codec_frame.size = src_media_frame->codec_frame.size;
+ memcpy(
+ media_frame->codec_frame.buffer,
+ src_media_frame->codec_frame.buffer,
+ media_frame->codec_frame.size);
+ }
+ if(media_frame->type & MEDIA_FRAME_TYPE_EVENT) {
+ media_frame->event_frame = src_media_frame->event_frame;
+ }
+ src_media_frame->type = MEDIA_FRAME_TYPE_NONE;
+ buffer->read_pos ++;
+ }
+ else {
+ /* underflow */
+ media_frame->type = MEDIA_FRAME_TYPE_NONE;
+ }
+ apr_thread_mutex_unlock(buffer->guard);
+ return TRUE;
+}
--- freeswitch/trunk/libs/unimrcp/libs/mpf/src/mpf_rtp_stream.c 2009-07-09 09:29:32 UTC (rev 14165)
+++ freeswitch/trunk/libs/unimrcp/libs/mpf/src/mpf_rtp_stream.c 2009-07-09 15:19:27 UTC (rev 14166)
@@ -83,21 +83,6 @@
return rtp_stream->base;
}
-static void mpf_rtp_stream_ip_port_set(mpf_rtp_media_descriptor_t *media, mpf_rtp_config_t *config)
-{
- if(media->base.ip.length == 0) {
- media->base.ip = config->ip;
- media->base.ext_ip = config->ext_ip;
- }
- if(media->base.port == 0) {
- media->base.port = config->rtp_port_cur;
- config->rtp_port_cur += 2;
- if(config->rtp_port_cur == config->rtp_port_max) {
- config->rtp_port_cur = config->rtp_port_min;
- }
- }
-}
-
static apt_bool_t mpf_rtp_stream_local_media_create(mpf_rtp_stream_t *rtp_stream, mpf_rtp_media_descriptor_t *local_media, mpf_rtp_media_descriptor_t *remote_media)
{
apt_bool_t status = TRUE;
@@ -111,9 +96,31 @@
if(remote_media) {
local_media->base.id = remote_media->base.id;
}
+ if(local_media->base.ip.length == 0) {
+ local_media->base.ip = rtp_stream->config->ip;
+ local_media->base.ext_ip = rtp_stream->config->ext_ip;
+ }
+ if(local_media->base.port == 0) {
+ /* RTP port management */
+ apr_port_t first_port_in_search = rtp_stream->config->rtp_port_cur;
+ apt_bool_t is_port_ok = FALSE;
- mpf_rtp_stream_ip_port_set(local_media,rtp_stream->config);
- if(mpf_rtp_socket_create(rtp_stream,local_media) == FALSE) {
+ do {
+ local_media->base.port = rtp_stream->config->rtp_port_cur;
+ rtp_stream->config->rtp_port_cur += 2;
+ if(rtp_stream->config->rtp_port_cur == rtp_stream->config->rtp_port_max) {
+ rtp_stream->config->rtp_port_cur = rtp_stream->config->rtp_port_min;
+ }
+ if(mpf_rtp_socket_create(rtp_stream,local_media) == TRUE) {
+ is_port_ok = TRUE;
+ }
+ } while((is_port_ok == FALSE) && (first_port_in_search != rtp_stream->config->rtp_port_cur));
+ if(is_port_ok == FALSE) {
+ local_media->base.state = MPF_MEDIA_DISABLED;
+ status = FALSE;
+ }
+ }
+ else if(mpf_rtp_socket_create(rtp_stream,local_media) == FALSE) {
local_media->base.state = MPF_MEDIA_DISABLED;
status = FALSE;
}
--- freeswitch/trunk/libs/unimrcp/plugins/mrcp-flite/Makefile.am 2009-07-09 09:29:32 UTC (rev 14165)
+++ freeswitch/trunk/libs/unimrcp/plugins/mrcp-flite/Makefile.am 2009-07-09 15:19:27 UTC (rev 14166)
@@ -14,6 +14,6 @@
plugin_LTLIBRARIES = mrcpflite.la
-mrcpflite_la_SOURCES = src/mrcp_flite.c
+mrcpflite_la_SOURCES = src/mrcp_flite.c src/flite_voices.c
mrcpflite_la_LDFLAGS = -module $(PLUGIN_LT_VERSION)
mrcpflite_la_LIBADD = $(UNIMRCP_FLITE_LIBS) -lm
--- freeswitch/trunk/libs/unimrcp/plugins/mrcp-flite/include/flite_voices.h (rev 0)
+++ freeswitch/trunk/libs/unimrcp/plugins/mrcp-flite/include/flite_voices.h 2009-07-09 15:19:27 UTC (rev 14166)
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2008 Arsen Chaloyan
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __FLITE_VOICES_H__
+#define __FLITE_VOICES_H__
+
+/**
+ * @file flite_voices.h
+ * @brief Flite Voices
+ */
+
+#include <flite.h>
+#include <apr_hash.h>
+#include "mrcp_message.h"
+
+APT_BEGIN_EXTERN_C
+
+
+typedef struct flite_voices_t flite_voices_t;
+
+flite_voices_t* flite_voices_load(apr_pool_t *pool);
+void flite_voices_unload(flite_voices_t *voices);
+
+cst_voice* flite_voices_best_match_get(flite_voices_t *voices, mrcp_message_t *message);
+
+APT_END_EXTERN_C
+
+#endif /*__FLITE_VOICES_H__*/
--- freeswitch/trunk/libs/unimrcp/plugins/mrcp-flite/mrcpflite.vcproj 2009-07-09 09:29:32 UTC (rev 14165)
+++ freeswitch/trunk/libs/unimrcp/plugins/mrcp-flite/mrcpflite.vcproj 2009-07-09 15:19:27 UTC (rev 14166)
@@ -149,12 +149,20 @@
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
+ <File
+ RelativePath=".\include\flite_voices.h"
+ >
+ </File>
</Filter>
<Filter
Name="src"
Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
>
<File
+ RelativePath=".\src\flite_voices.c"
+ >
+ </File>
+ <File
RelativePath=".\src\mrcp_flite.c"
>
</File>
--- freeswitch/trunk/libs/unimrcp/plugins/mrcp-flite/src/flite_voices.c (rev 0)
+++ freeswitch/trunk/libs/unimrcp/plugins/mrcp-flite/src/flite_voices.c 2009-07-09 15:19:27 UTC (rev 14166)
@@ -0,0 +1,160 @@
+/*
+ * Copyright 2008 Arsen Chaloyan
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "flite_voices.h"
+#include "mrcp_synth_header.h"
+
+typedef struct flite_voice_t flite_voice_t;
+
+/** Declaration of flite voice */
+struct flite_voice_t {
+ const char *name;
+ cst_voice *self;
+ cst_voice* (*register_voice)(void);
+ void (*unregister_voice)(cst_voice *);
+};
+
+struct flite_voices_t {
+ apr_hash_t *table;
+ apr_pool_t *pool;
+};
+
+
+/* declarations for flite voices */
+cst_voice *register_cmu_us_awb(void);
+cst_voice *register_cmu_us_kal(void);
+cst_voice *register_cmu_us_rms(void);
+cst_voice *register_cmu_us_slt(void);
+void unregister_cmu_us_awb(cst_voice * v);
+void unregister_cmu_us_kal(cst_voice * v);
+void unregister_cmu_us_rms(cst_voice * v);
+void unregister_cmu_us_slt(cst_voice * v);
+
+
+static apt_bool_t flite_voices_init(flite_voices_t *voices, apr_pool_t *pool)
+{
+ flite_voice_t *voice;
+
+ voice = apr_palloc(pool,sizeof(flite_voice_t));
+ voice->name = "awb";
+ voice->self = NULL;
+ voice->register_voice = register_cmu_us_awb;
+ voice->unregister_voice = unregister_cmu_us_awb;
+ apr_hash_set(voices->table,voice->name,APR_HASH_KEY_STRING,voice);
+
+ voice = apr_palloc(pool,sizeof(flite_voice_t));
+ voice->name = "kal";
+ voice->self = NULL;
+ voice->register_voice = register_cmu_us_kal;
+ voice->unregister_voice = unregister_cmu_us_kal;
+ apr_hash_set(voices->table,voice->name,APR_HASH_KEY_STRING,voice);
+
+ voice = apr_palloc(pool,sizeof(flite_voice_t));
+ voice->name = "rms";
+ voice->self = NULL;
+ voice->register_voice = register_cmu_us_rms;
+ voice->unregister_voice = unregister_cmu_us_rms;
+ apr_hash_set(voices->table,voice->name,APR_HASH_KEY_STRING,voice);
+
+ voice = apr_palloc(pool,sizeof(flite_voice_t));
+ voice->name = "slt";
+ voice->self = NULL;
+ voice->register_voice = register_cmu_us_slt;
+ voice->unregister_voice = unregister_cmu_us_slt;
+ apr_hash_set(voices->table,voice->name,APR_HASH_KEY_STRING,voice);
+
+ return TRUE;
+}
+
+
+flite_voices_t* flite_voices_load(apr_pool_t *pool)
+{
+ flite_voice_t *voice;
+ apr_hash_index_t *it;
+ void *val;
+
+ flite_voices_t *voices = apr_palloc(pool,sizeof(flite_voices_t));
+ voices->pool = pool;
+ voices->table = apr_hash_make(pool);
+
+ /* init voices */
+ flite_voices_init(voices,pool);
+
+ /* register voices */
+ it = apr_hash_first(pool,voices->table);
+ /* walk through the voices and register them */
+ for(; it; it = apr_hash_next(it)) {
+ apr_hash_this(it,NULL,NULL,&val);
+ voice = val;
+ if(voice) {
+ voice->self = voice->register_voice();
+ }
+ }
+
+ return voices;
+}
+
+void flite_voices_unload(flite_voices_t *voices)
+{
+ flite_voice_t *voice;
+ apr_hash_index_t *it;
+ void *val;
+
+ /* unregister voices */
+ it = apr_hash_first(voices->pool,voices->table);
+ /* walk through the voices and register them */
+ for(; it; it = apr_hash_next(it)) {
+ apr_hash_this(it,NULL,NULL,&val);
+ voice = val;
+ if(voice && voice->self) {
+ voice->unregister_voice(voice->self);
+ }
+ }
+}
+
+cst_voice* flite_voices_best_match_get(flite_voices_t *voices, mrcp_message_t *message)
+{
+ cst_voice *voice = NULL;
+ const char *voice_name = NULL;
+ mrcp_synth_header_t *synth_header = mrcp_resource_header_get(message);
+ if(synth_header) {
+ if(mrcp_resource_header_property_check(message,SYNTHESIZER_HEADER_VOICE_NAME) == TRUE) {
+ voice_name = synth_header->voice_param.name.buf;
+ }
+ }
+
+ if(voice_name) {
+ /* get voice by name */
+ flite_voice_t *flite_voice;
+ flite_voice = apr_hash_get(voices->table,voice_name,APR_HASH_KEY_STRING);
+ if(flite_voice) {
+ voice = flite_voice->self;
+ }
+ }
+
+ if(!voice) {
+ /* still no voice found, get the default one */
+ flite_voice_t *flite_voice = NULL;
+ void *val;
+ apr_hash_index_t *it = apr_hash_first(voices->pool,voices->table);
+ apr_hash_this(it,NULL,NULL,&val);
+ if(val) {
+ flite_voice = val;
+ voice = flite_voice->self;
+ }
+ }
+ return voice;
+}
--- freeswitch/trunk/libs/unimrcp/plugins/mrcp-flite/src/mrcp_flite.c 2009-07-09 09:29:32 UTC (rev 14165)
+++ freeswitch/trunk/libs/unimrcp/plugins/mrcp-flite/src/mrcp_flite.c 2009-07-09 15:19:27 UTC (rev 14166)
@@ -24,6 +24,7 @@
* 4. Methods (callbacks) of the MPF engine stream MUST not block.
*/
+#include "flite_voices.h"
#include "mrcp_resource_engine.h"
#include "mrcp_synth_resource.h"
#include "mrcp_synth_header.h"
@@ -33,7 +34,6 @@
#include "apr_time.h"
#include "apt_consumer_task.h"
#include "apt_log.h"
-#include "flite.h"
typedef struct flite_synth_engine_t flite_synth_engine_t;
typedef struct flite_synth_channel_t flite_synth_channel_t;
@@ -57,8 +57,6 @@
static apt_bool_t flite_synth_channel_close(mrcp_engine_channel_t *channel);
static apt_bool_t flite_synth_channel_request_process(mrcp_engine_channel_t *channel, mrcp_message_t *request);
-static apt_bool_t flite_synth_channel_close_t(mrcp_engine_channel_t *channel); // wait for speak thread
-
/** flite channel methods for processing MRCP channel request **/
static apt_bool_t flite_synth_channel_speak(mrcp_engine_channel_t *channel, mrcp_message_t *request, mrcp_message_t *response);
static apt_bool_t flite_synth_channel_stop(mrcp_engine_channel_t *channel, mrcp_message_t *request, mrcp_message_t *response);
@@ -75,15 +73,12 @@
};
/** Declaration of synthesizer audio stream methods */
-static apt_bool_t flite_synth_stream_destroy(mpf_audio_stream_t *stream);
-static apt_bool_t flite_synth_stream_open(mpf_audio_stream_t *stream);
-static apt_bool_t flite_synth_stream_close(mpf_audio_stream_t *stream);
static apt_bool_t flite_synth_stream_read(mpf_audio_stream_t *stream, mpf_frame_t *frame);
static const mpf_audio_stream_vtable_t audio_stream_vtable = {
- flite_synth_stream_destroy,
- flite_synth_stream_open,
- flite_synth_stream_close,
+ NULL,
+ NULL,
+ NULL,
flite_synth_stream_read,
NULL,
NULL,
@@ -92,39 +87,25 @@
/** Declaration of flite synthesizer engine */
struct flite_synth_engine_t {
- int iChannels;
- struct {
- cst_voice *awb;
- cst_voice *kal;
- cst_voice *rms;
- cst_voice *slt;
- } voices;
+ /** Table of flite voices */
+ flite_voices_t *voices;
+ int iChannels;
};
-/** declarations for flite voices **/
-cst_voice *register_cmu_us_awb(void);
-cst_voice *register_cmu_us_kal(void);
-cst_voice *register_cmu_us_rms(void);
-cst_voice *register_cmu_us_slt(void);
-void unregister_cmu_us_awb(cst_voice * v);
-void unregister_cmu_us_kal(cst_voice * v);
-void unregister_cmu_us_rms(cst_voice * v);
-void unregister_cmu_us_slt(cst_voice * v);
-
-
/** Declaration of flite synthesizer channel */
struct flite_synth_channel_t {
- flite_synth_engine_t *flite_engine; // Back pointer to engine
- mrcp_engine_channel_t *channel; // Engine channel base
- mrcp_message_t *speak_request; // Active (in-progress) speak request
- mrcp_message_t *stop_response; // Pending stop response
- apt_bool_t paused; // Is paused
- mpf_buffer_t *audio_buffer; // Audio buffer
- int iId; // Synth channel simultaneous reference count
- cst_voice *voice;
- apr_pool_t *pool;
- apt_consumer_task_t *task;
- apr_thread_mutex_t *channel_guard;
+ flite_synth_engine_t *flite_engine; /* Back pointer to engine */
+ mrcp_engine_channel_t *channel; /* Engine channel base */
+ mrcp_message_t *speak_request; /* Active (in-progress) speak request */
+ mrcp_message_t *speak_response;/* Pending speak response */
+ mrcp_message_t *stop_response; /* Pending stop response */
+ apt_bool_t synthesizing; /* Is synthesizer task processing speak request */
+ apt_bool_t paused; /* Is paused */
+ mpf_buffer_t *audio_buffer; /* Audio buffer */
+ int iId; /* Synth channel simultaneous reference count */
+ apr_pool_t *pool;
+ apt_task_t *task;
+ apt_task_msg_pool_t *msg_pool;
};
/** Declaration of flite synthesizer task message */
@@ -135,8 +116,8 @@
typedef struct flite_speak_msg_t flite_speak_msg_t;
-// we have a special task for the actual synthesis -
-// the task is created when a mrcp speak message is received
+/* we have a special task for the actual synthesis -
+ the task is created when a mrcp speak message is received */
static apt_bool_t flite_speak(apt_task_t *task, apt_task_msg_t *msg);
/** Declare this macro to use log routine of the server where the plugin is loaded from */
@@ -147,7 +128,6 @@
{
/* create flite engine */
flite_synth_engine_t *flite_engine = (flite_synth_engine_t *) apr_palloc(pool,sizeof(flite_synth_engine_t));
-
flite_engine->iChannels = 0;
/* create resource engine base */
@@ -172,13 +152,10 @@
apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "flite_synth_engine_open");
flite_init();
- flite_engine->voices.awb = register_cmu_us_awb();
- flite_engine->voices.kal = register_cmu_us_kal();
- flite_engine->voices.rms = register_cmu_us_rms();
- flite_engine->voices.slt = register_cmu_us_slt();
- apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "flite init success");
+ flite_engine->voices = flite_voices_load(engine->pool);
+ apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "flite init success");
return TRUE;
}
@@ -188,14 +165,36 @@
flite_synth_engine_t *flite_engine = (flite_synth_engine_t *) engine->obj;
apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "flite_synth_engine_close");
- unregister_cmu_us_awb(flite_engine->voices.awb);
- unregister_cmu_us_kal(flite_engine->voices.kal);
- unregister_cmu_us_rms(flite_engine->voices.rms);
- unregister_cmu_us_slt(flite_engine->voices.slt);
+ flite_voices_unload(flite_engine->voices);
return TRUE;
}
+static apt_bool_t flite_synth_task_create(flite_synth_channel_t *synth_channel)
+{
+ apt_task_msg_pool_t *msg_pool = apt_task_msg_pool_create_dynamic( sizeof(flite_speak_msg_t),synth_channel->pool);
+ apt_task_vtable_t *task_vtable = 0;
+ apt_consumer_task_t *consumer_task = 0;
+
+ /* create task/thread to run flite synthesizer in */
+ consumer_task = apt_consumer_task_create(synth_channel, msg_pool, synth_channel->pool);
+ if(!consumer_task) {
+ apt_log(APT_LOG_MARK,APT_PRIO_ERROR, "flite_synth_channel_speak failed to create flite speak task - channel:%d", synth_channel->iId);
+ return FALSE;
+ }
+
+ task_vtable = apt_consumer_task_vtable_get(consumer_task);
+ if(!task_vtable) {
+ apt_log(APT_LOG_MARK,APT_PRIO_ERROR, "flite_synth_channel_speak cannot use flite speak task vtable - channel:%d", synth_channel->iId);
+ return FALSE;
+ }
+
+ task_vtable->process_msg = flite_speak;
+ synth_channel->msg_pool = msg_pool;
+ synth_channel->task = apt_consumer_task_base_get(consumer_task);
+ return TRUE;
+}
+
/** Create flite synthesizer channel derived from engine channel base */
static mrcp_engine_channel_t* flite_synth_engine_channel_create(mrcp_resource_engine_t *engine, apr_pool_t *pool)
{
@@ -204,30 +203,31 @@
mpf_codec_descriptor_t *codec_descriptor = NULL;
apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "flite_synth_engine_channel_create");
+#if 0
+ codec_descriptor = (mpf_codec_descriptor_t *) apr_palloc(pool,sizeof(mpf_codec_descriptor_t));
+ mpf_codec_descriptor_init(codec_descriptor);
+ codec_descriptor->channel_count = 1;
+ codec_descriptor->payload_type = 96;
+ apt_string_set(&codec_descriptor->name,"LPCM");
+ codec_descriptor->sampling_rate = 16000;
+#endif
-// codec_descriptor = (mpf_codec_descriptor_t *) apr_palloc(pool,sizeof(mpf_codec_descriptor_t));
-// mpf_codec_descriptor_init(codec_descriptor);
-// codec_descriptor->channel_count = 1;
-// codec_descriptor->payload_type = 96;
-// apt_string_set(&codec_descriptor->name,"LPCM");
-// codec_descriptor->sampling_rate = 16000;
-
synth_channel->flite_engine = (flite_synth_engine_t *) engine->obj;
synth_channel->speak_request = NULL; // no active speak request in progress
+ synth_channel->speak_response = NULL;
synth_channel->stop_response = NULL;
+ synth_channel->synthesizing = FALSE;
synth_channel->paused = FALSE;
synth_channel->pool = pool;
synth_channel->audio_buffer = NULL;
- synth_channel->voice = NULL;
synth_channel->iId = 0;
-
- if (apr_thread_mutex_create(&synth_channel->channel_guard,APR_THREAD_MUTEX_DEFAULT,pool) != APR_SUCCESS)
- {
- apt_log(APT_LOG_MARK, APT_PRIO_ERROR, "Failed to create channel guard");
+ synth_channel->task = NULL;
+ synth_channel->msg_pool = NULL;
+ if(flite_synth_task_create(synth_channel) != TRUE) {
+ apt_log(APT_LOG_MARK, APT_PRIO_WARNING, "flite_synth_task_create failed");
return NULL;
}
-
/* create engine channel base */
synth_channel->channel = mrcp_engine_source_channel_create(
engine, /* resource engine */
@@ -237,9 +237,9 @@
codec_descriptor, /* codec descriptor might be NULL by default */
pool); /* pool to allocate memory from */
- if (!synth_channel->channel)
- {
+ if(!synth_channel->channel) {
apt_log(APT_LOG_MARK, APT_PRIO_WARNING, "flite_synth_engine_channel_create failed");
+ apt_task_destroy(synth_channel->task);
return NULL;
}
@@ -247,7 +247,6 @@
synth_channel->iId = ++synth_channel->flite_engine->iChannels;
apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "flite_synth_engine_channel_create created channel %d", synth_channel->iId);
-
return synth_channel->channel;
}
@@ -256,24 +255,12 @@
{
flite_synth_channel_t *synth_channel = (flite_synth_channel_t *) channel->method_obj;
apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "flite_synth_channel_destroy - channel %d", synth_channel->iId);
- if(synth_channel->task)
- {
- apt_task_t *task = apt_consumer_task_base_get(synth_channel->task);
- if (!task || !apt_task_destroy(task))
- {
- apt_log(APT_LOG_MARK, APT_PRIO_WARNING, "Speak task destroy failed - channel %d", synth_channel->iId);
- }
- else
- {
- apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "Speak task destroyed - channel %d", synth_channel->iId);
- }
+ if(synth_channel->task) {
+ apt_task_destroy(synth_channel->task);
+ synth_channel->task = NULL;
}
- synth_channel->task = NULL;
synth_channel->flite_engine->iChannels--;
-
- apr_thread_mutex_destroy(synth_channel->channel_guard);
-
return TRUE;
}
@@ -283,7 +270,15 @@
flite_synth_channel_t *synth_channel = (flite_synth_channel_t *) channel->method_obj;
apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "flite_synth_channel_open - channel %d", synth_channel->iId);
- synth_channel->voice = synth_channel->flite_engine->voices.awb;
+ if(synth_channel->task) {
+ if(apt_task_start(synth_channel->task) == TRUE) {
+ apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "Speak task started - channel %d", synth_channel->iId);
+ }
+ else {
+ apt_log(APT_LOG_MARK, APT_PRIO_WARNING, "Speak task start failed - channel %d", synth_channel->iId);
+ }
+ }
+
return mrcp_engine_channel_open_respond(channel,TRUE);
}
@@ -292,8 +287,16 @@
{
flite_synth_channel_t *synth_channel = (flite_synth_channel_t *) channel->method_obj;
apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "flite_synth_channel_close - channel %d", synth_channel->iId);
- // create thread to wait for speak thread to terminate
- flite_synth_channel_close_t(channel);
+
+ if(synth_channel->task) {
+ if(apt_task_terminate(synth_channel->task,TRUE) == TRUE) {
+ apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "Speak task terminated - channel %d", synth_channel->iId);
+ }
+ else {
+ apt_log(APT_LOG_MARK, APT_PRIO_WARNING, "Speak task terminate failed - channel %d", synth_channel->iId);
+ }
+ }
+ mrcp_engine_channel_close_respond(channel);
return TRUE;
}
@@ -308,18 +311,6 @@
switch(request->start_line.method_id) {
case SYNTHESIZER_SET_PARAMS:
- // TODO set voices
- // if (!strcasecmp(voice_name, "awb")) {
- // synth_channel->voice = voices.awb;
- // } else if (!strcasecmp(voice_name, "kal")) {
- // synth_channel->voice = voices.kal;
- // } else if (!strcasecmp(voice_name, "rms")) {
- // synth_channel->voice = voices.rms;
- // } else if (!strcasecmp(voice_name, "slt")) {
- // synth_channel->voice = voices.slt;
- // } else {
- // apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "Valid voice names are awb, kal, rms or slt");
- // }
break;
case SYNTHESIZER_GET_PARAMS:
break;
@@ -350,92 +341,67 @@
mrcp_engine_channel_message_send(channel,response);
}
return TRUE;
-
}
-static apt_bool_t flite_synth_channel_close_t(mrcp_engine_channel_t *channel)
+/** Process SPEAK request */
+static apt_bool_t synth_response_construct(mrcp_message_t *response, mrcp_status_code_e status_code, mrcp_synth_completion_cause_e completion_cause)
{
- flite_synth_channel_t *synth_channel = (flite_synth_channel_t *) channel->method_obj;
- apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "flite_synth_channel_close_t - channel %d", synth_channel->iId);
-
- if (synth_channel->task)
- {
- apt_task_t *task = apt_consumer_task_base_get(synth_channel->task);
- if (!apt_task_terminate(task,TRUE))
- {
- apt_log(APT_LOG_MARK, APT_PRIO_WARNING, "Speak task terminate failed - channel %d", synth_channel->iId);
- }
- else
- {
- apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "Speak task terminated - channel %d", synth_channel->iId);
- apt_task_destroy(task);
- synth_channel->task = 0;
- }
+ mrcp_synth_header_t *synth_header = mrcp_resource_header_prepare(response);
+ if(!synth_header) {
+ return FALSE;
}
- mrcp_engine_channel_close_respond(channel);
+
+ response->start_line.status_code = status_code;
+ synth_header->completion_cause = completion_cause;
+ mrcp_resource_header_property_add(response,SYNTHESIZER_HEADER_COMPLETION_CAUSE);
return TRUE;
}
-
/** Process SPEAK request */
static apt_bool_t flite_synth_channel_speak(mrcp_engine_channel_t *channel, mrcp_message_t *request, mrcp_message_t *response)
{
+ mrcp_generic_header_t *generic_header;
+ const char *content_type = NULL;
flite_synth_channel_t *synth_channel = (flite_synth_channel_t *) channel->method_obj;
+ apt_task_msg_t *msg = 0;
+ flite_speak_msg_t *flite_msg = 0;
apt_log(APT_LOG_MARK, APT_PRIO_INFO, "flite_synth_channel_speak - channel %d", synth_channel->iId);
- if (!synth_channel->speak_request)
- {
- apt_task_msg_pool_t *msg_pool = apt_task_msg_pool_create_dynamic( sizeof(flite_speak_msg_t),synth_channel->pool);
- apt_task_vtable_t *task_vtable = 0;
- apt_task_t * task = 0;
- apt_task_msg_t *msg = 0;
- flite_speak_msg_t *flite_msg = 0;
-
- /* create task/thread to run flite so this function is not blocking */
- apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "Create flite speak task - channel: %d", synth_channel->iId);
- synth_channel->task = apt_consumer_task_create(synth_channel, msg_pool, synth_channel->pool);
- if (!synth_channel->task)
- {
- apt_log(APT_LOG_MARK,APT_PRIO_ERROR, "flite_synth_channel_speak failed to create flite speak task - channel:%d", synth_channel->iId);
- return FALSE;
+ generic_header = mrcp_generic_header_get(request);
+ if(generic_header) {
+ /* content-type must be specified */
+ if(mrcp_generic_header_property_check(request,GENERIC_HEADER_CONTENT_TYPE) == TRUE) {
+ content_type = generic_header->content_type.buf;
}
+ }
+ if(!content_type) {
+ apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Missing Content-Type");
+ synth_response_construct(response,MRCP_STATUS_CODE_MISSING_PARAM,SYNTHESIZER_COMPLETION_CAUSE_ERROR);
+ return FALSE;
+ }
- task_vtable = apt_consumer_task_vtable_get(synth_channel->task);
- if (!task_vtable)
- {
- apt_log(APT_LOG_MARK,APT_PRIO_ERROR, "flite_synth_channel_speak cannot use flite speak task vtable - channel:%d", synth_channel->iId);
- return FALSE;
- }
+ /* Flite currently supports only text/plain (no SSML) */
+ if(strstr(content_type,"text") == NULL) {
+ apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Not Supported Content-Type [%s]",content_type);
+ synth_response_construct(response,MRCP_STATUS_CODE_UNSUPPORTED_PARAM_VALUE,SYNTHESIZER_COMPLETION_CAUSE_ERROR);
+ return FALSE;
+ }
- task_vtable->process_msg = flite_speak;
- synth_channel->speak_request = request;
-
- apt_log(APT_LOG_MARK,APT_PRIO_DEBUG, "Start task - channel %d", synth_channel->iId);
- task = apt_consumer_task_base_get(synth_channel->task);
- if (apt_task_start(task) == FALSE)
- {
- apt_log(APT_LOG_MARK,APT_PRIO_ERROR, "flite_synth_channel_speak failed to start task - channel: %d", synth_channel->iId);
- apt_task_destroy(task);
- return FALSE;
- }
+ synth_channel->speak_request = request;
+ synth_channel->speak_response = response;
- msg = apt_task_msg_acquire(msg_pool);
- msg->type = TASK_MSG_USER;
- flite_msg = (flite_speak_msg_t*) msg->data;
- flite_msg->channel = synth_channel;
- flite_msg->request = request;
- apt_log(APT_LOG_MARK,APT_PRIO_DEBUG, "Send signal to start speech synthesis - channel:%d", synth_channel->iId);
- if (apt_task_msg_signal(task,msg))
- {
- response->start_line.request_state = MRCP_REQUEST_STATE_INPROGRESS;
- mrcp_engine_channel_message_send(channel,response);
- }
- else
- {
- apt_log(APT_LOG_MARK,APT_PRIO_WARNING, "Failed to send signal to start speech synthesis - channel:%d", synth_channel->iId);
- apt_task_destroy(task);
- return FALSE;
- }
+ msg = apt_task_msg_acquire(synth_channel->msg_pool);
+ msg->type = TASK_MSG_USER;
+ flite_msg = (flite_speak_msg_t*) msg->data;
+ flite_msg->channel = synth_channel;
+ flite_msg->request = request;
+ apt_log(APT_LOG_MARK,APT_PRIO_DEBUG, "Send signal to start speech synthesis - channel:%d", synth_channel->iId);
+ if(apt_task_msg_signal(synth_channel->task,msg) != TRUE) {
+ apt_log(APT_LOG_MARK,APT_PRIO_WARNING, "Failed to send signal to start speech synthesis - channel:%d", synth_channel->iId);
+ synth_channel->speak_request = NULL;
+ synth_channel->speak_response = NULL;
+ synth_response_construct(response,MRCP_STATUS_CODE_METHOD_FAILED,SYNTHESIZER_COMPLETION_CAUSE_ERROR);
+ return FALSE;
}
return TRUE;
}
@@ -444,62 +410,80 @@
{
flite_speak_msg_t *flite_msg = (flite_speak_msg_t*)msg->data;
flite_synth_channel_t *synth_channel = (flite_synth_channel_t *) flite_msg->channel;
+ cst_wave *wave = NULL;
+ cst_voice *voice = NULL;
apr_time_t start = 0;
apr_time_t elapsed = 0;
apr_time_t stamp = 0;
+ apt_str_t *body;
+ mrcp_message_t *response;
- mrcp_message_t *stop_response = 0;
mpf_codec_t * codec = mrcp_engine_source_stream_codec_get(synth_channel->channel);
- apr_uint16_t rate = codec->descriptor->sampling_rate;
+ apr_uint16_t rate = codec->descriptor->sampling_rate;
+ body = &synth_channel->speak_request->body;
+ response = synth_channel->speak_response;
+ synth_channel->speak_response = NULL;
+
apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "< flite_speak_msg_process speak - channel %d", synth_channel->iId);
- // just sequential stuff
+ /* just sequential stuff */
start = apr_time_now(); // in microsec
- if (synth_channel->speak_request->body.length)
- {
- // TODO
- // create small units of text from synth_channel->speak_request->body.buf ( , . ? ! but ...
- // synthesize small unit and store in audio_buffer
- // check for stop
- // pause resume state could improve performance
- // you can "pause" generating new speech from a unit of text
- // by checking the (decreasing) size of the audio_buffer
- // no need to generate more speech samples than can be listened to...
- cst_wave *wave = 0;
- wave = flite_text_to_wave(synth_channel->speak_request->body.buf, synth_channel->voice);
- if (wave && cst_wave_num_samples(wave))
- {
- int generated = (cst_wave_num_samples(wave)/cst_wave_sample_rate(wave)*1000);
- stamp = apr_time_now();
- elapsed = (stamp - start)/1000;
- apt_log(APT_LOG_MARK, APT_PRIO_INFO, "TTS (chan %d) took %"APR_TIME_T_FMT" to generate %d of speech (in millisec)", synth_channel->iId, elapsed, generated);
+ if(!body->length) {
+ synth_channel->speak_request = NULL;
+ synth_response_construct(response,MRCP_STATUS_CODE_MISSING_PARAM,SYNTHESIZER_COMPLETION_CAUSE_ERROR);
+ mrcp_engine_channel_message_send(synth_channel->channel,response);
+ return FALSE;
+ }
- if (rate != 16000)
- {
- cst_wave_resample(wave, rate);
- elapsed = (apr_time_now() - stamp)/1000;
- apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "TTS resampling to %d on (chan %d) took %"APR_TIME_T_FMT" millisec", rate, synth_channel->iId, elapsed);
- }
- mpf_buffer_audio_write(synth_channel->audio_buffer, cst_wave_samples(wave), cst_wave_num_samples(wave) * 2);
- delete_wave(wave);
- }
+ voice = flite_voices_best_match_get(
+ synth_channel->flite_engine->voices,
+ synth_channel->speak_request);
+ if(!voice) {
+ /* error case: no voice found, appropriate respond must be sent */
+ synth_channel->speak_request = NULL;
+ synth_response_construct(response,MRCP_STATUS_CODE_METHOD_FAILED,SYNTHESIZER_COMPLETION_CAUSE_ERROR);
+ mrcp_engine_channel_message_send(synth_channel->channel,response);
+ return FALSE;
}
- apr_thread_mutex_lock(synth_channel->channel_guard);
- stop_response = synth_channel->stop_response;
- apr_thread_mutex_unlock(synth_channel->channel_guard);
+ /*
+ TODO
+ create small units of text from synth_channel->speak_request->body.buf ( , . ? ! but ...
+ synthesize small unit and store in audio_buffer
+ check for stop
+ pause resume state could improve performance
+ you can "pause" generating new speech from a unit of text
+ by checking the (decreasing) size of the audio_buffer
+ no need to generate more speech samples than can be listened to...
+ */
- if (!stop_response)
- {
- // this will notify the callback that feeds the client that synthesis is complete
- mpf_buffer_event_write(synth_channel->audio_buffer, MEDIA_FRAME_TYPE_EVENT);
- apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "> flite_speak_msg_process speak - end of TTS - %d", synth_channel->iId);
+ /* send in-progress response and start synthesizing */
+ response->start_line.request_state = MRCP_REQUEST_STATE_INPROGRESS;
+ mrcp_engine_channel_message_send(synth_channel->channel,response);
+
+ synth_channel->synthesizing = TRUE;
+ wave = flite_text_to_wave(body->buf, voice);
+ if(wave && cst_wave_num_samples(wave)) {
+ int generated = (cst_wave_num_samples(wave)/cst_wave_sample_rate(wave)*1000);
+ stamp = apr_time_now();
+ elapsed = (stamp - start)/1000;
+ apt_log(APT_LOG_MARK, APT_PRIO_INFO, "TTS (chan %d) took %"APR_TIME_T_FMT" to generate %d of speech (in millisec)", synth_channel->iId, elapsed, generated);
+
+ if(rate != 16000) {
+ cst_wave_resample(wave, rate);
+ elapsed = (apr_time_now() - stamp)/1000;
+ apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "TTS resampling to %d on (chan %d) took %"APR_TIME_T_FMT" millisec", rate, synth_channel->iId, elapsed);
+ }
+ mpf_buffer_audio_write(synth_channel->audio_buffer, cst_wave_samples(wave), cst_wave_num_samples(wave) * 2);
+ delete_wave(wave);
}
- else
- {
- apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "> flite_speak_msg_process speak - channel %d", synth_channel->iId);
- }
+
+ // this will notify the callback that feeds the client that synthesis is complete
+ mpf_buffer_event_write(synth_channel->audio_buffer, MEDIA_FRAME_TYPE_EVENT);
+ synth_channel->synthesizing = FALSE;
+
+ apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "> flite_speak_msg_process speak - end of TTS - %d", synth_channel->iId);
return TRUE;
}
@@ -510,10 +494,7 @@
apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "flite_synth_channel_stop - channel %d", synth_channel->iId);
/* store the request, make sure there is no more activity and only then send the response */
- apr_thread_mutex_lock(synth_channel->channel_guard);
synth_channel->stop_response = response;
- apr_thread_mutex_unlock(synth_channel->channel_guard);
-
return TRUE;
}
@@ -541,29 +522,6 @@
return TRUE;
}
-/** Callback is called from MPF engine context to destroy any additional data associated with audio stream */
-static apt_bool_t flite_synth_stream_destroy(mpf_audio_stream_t *stream)
-{
- apt_log(APT_LOG_MARK, APT_PRIO_INFO, "flite_synth_stream_destroy");
- return TRUE;
-}
-
-/** Callback is called from MPF engine context to perform any action before open */
-static apt_bool_t flite_synth_stream_open(mpf_audio_stream_t *stream)
-{
-// flite_synth_channel_t *synth_channel = (flite_synth_channel_t *) stream->obj;
-// apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "flite_synth_stream_open - channel %d", synth_channel->iId);
- return TRUE;
-}
-
-/** Callback is called from MPF engine context to perform any action after close */
-static apt_bool_t flite_synth_stream_close(mpf_audio_stream_t *stream)
-{
-// flite_synth_channel_t *synth_channel = (flite_synth_channel_t *) stream->obj;
-// apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "flite_synth_stream_close - channel %d", synth_channel->iId);
- return TRUE;
-}
-
/** Raise SPEAK-COMPLETE event */
static apt_bool_t flite_synth_speak_complete_raise(flite_synth_channel_t *synth_channel)
{
@@ -602,26 +560,25 @@
static apt_bool_t flite_synth_stream_read(mpf_audio_stream_t *stream, mpf_frame_t *frame)
{
flite_synth_channel_t *synth_channel = (flite_synth_channel_t *) stream->obj;
- if (synth_channel->stop_response && synth_channel->speak_request)
- {
+ if(synth_channel->stop_response && synth_channel->synthesizing == FALSE) {
/* send asynchronous response to STOP request */
- mrcp_engine_channel_message_send(synth_channel->channel, synth_channel->stop_response);
+ mrcp_message_t *stop_response = synth_channel->stop_response;
+ synth_channel->stop_response = NULL;
synth_channel->speak_request = NULL;
synth_channel->paused = FALSE;
+ mrcp_engine_channel_message_send(synth_channel->channel,stop_response);
return TRUE;
}
/* check if there is active SPEAK request and it isn't in paused state */
- if (synth_channel->speak_request && synth_channel->paused == FALSE)
- {
+ if(synth_channel->speak_request && synth_channel->paused == FALSE) {
/* normal processing */
mpf_buffer_frame_read(synth_channel->audio_buffer,frame);
// apt_log(APT_LOG_MARK, APT_PRIO_DEBUG, "flite_synth_stream_read - channel %d - size %d", synth_channel->iId, mpf_buffer_get_size(synth_channel->audio_buffer));
- if((frame->type & MEDIA_FRAME_TYPE_EVENT) == MEDIA_FRAME_TYPE_EVENT)
- {
+ if((frame->type & MEDIA_FRAME_TYPE_EVENT) == MEDIA_FRAME_TYPE_EVENT) {
flite_synth_speak_complete_raise(synth_channel);
}
}
return TRUE;
-}
\ No newline at end of file
+}