ASR/TTS Functions

Collaboration diagram for ASR/TTS Functions:

Functions
switch_status_t	switch_core_speech_open (_In_ switch_speech_handle_t *sh, const char *module_name, const char *voice_name, _In_ unsigned int rate, _In_ unsigned int interval, _In_ unsigned int channels, switch_speech_flag_t *flags, _In_opt_ switch_memory_pool_t *pool)
	Open a speech handle. More...
switch_status_t	switch_core_speech_feed_tts (switch_speech_handle_t *sh, char *text, switch_speech_flag_t *flags)
	Feed text to the TTS module. More...
void	switch_core_speech_flush_tts (switch_speech_handle_t *sh)
	Flush TTS audio on a given handle. More...
void	switch_core_speech_text_param_tts (switch_speech_handle_t *sh, char *param, const char *val)
	Set a text parameter on a TTS handle. More...
void	switch_core_speech_numeric_param_tts (switch_speech_handle_t *sh, char *param, int val)
	Set a numeric parameter on a TTS handle. More...
void	switch_core_speech_float_param_tts (switch_speech_handle_t *sh, char *param, double val)
	Set a float parameter on a TTS handle. More...
switch_status_t	switch_core_speech_read_tts (switch_speech_handle_t *sh, void *data, switch_size_t *datalen, switch_speech_flag_t *flags)
	Read rendered audio from the TTS module. More...
switch_status_t	switch_core_speech_close (switch_speech_handle_t *sh, switch_speech_flag_t *flags)
	Close an open speech handle. More...
switch_status_t	switch_core_asr_open (switch_asr_handle_t *ah, const char *module_name, const char *codec, int rate, const char *dest, switch_asr_flag_t *flags, switch_memory_pool_t *pool)
	Open an asr handle. More...
switch_status_t	switch_core_asr_close (switch_asr_handle_t *ah, switch_asr_flag_t *flags)
	Close an asr handle. More...
switch_status_t	switch_core_asr_feed (switch_asr_handle_t *ah, void *data, unsigned int len, switch_asr_flag_t *flags)
	Feed audio data to an asr handle. More...
switch_status_t	switch_core_asr_feed_dtmf (switch_asr_handle_t *ah, const switch_dtmf_t *dtmf, switch_asr_flag_t *flags)
	Feed DTMF to an asr handle. More...
switch_status_t	switch_core_asr_check_results (switch_asr_handle_t *ah, switch_asr_flag_t *flags)
	Check an asr handle for results. More...
switch_status_t	switch_core_asr_get_results (switch_asr_handle_t *ah, char **xmlstr, switch_asr_flag_t *flags)
	Get results from an asr handle. More...
switch_status_t	switch_core_asr_get_result_headers (switch_asr_handle_t *ah, switch_event_t **headers, switch_asr_flag_t *flags)
	Get result headers from an asr handle. More...
switch_status_t	switch_core_asr_load_grammar (switch_asr_handle_t *ah, const char *grammar, const char *name)
	Load a grammar to an asr handle. More...
switch_status_t	switch_core_asr_unload_grammar (switch_asr_handle_t *ah, const char *name)
	Unload a grammar from an asr handle. More...
switch_status_t	switch_core_asr_enable_grammar (switch_asr_handle_t *ah, const char *name)
	Enable a grammar from an asr handle. More...
switch_status_t	switch_core_asr_disable_grammar (switch_asr_handle_t *ah, const char *name)
	Disable a grammar from an asr handle. More...
switch_status_t	switch_core_asr_disable_all_grammars (switch_asr_handle_t *ah)
	Disable all grammars from an asr handle. More...
switch_status_t	switch_core_asr_pause (switch_asr_handle_t *ah)
	Pause detection on an asr handle. More...
switch_status_t	switch_core_asr_resume (switch_asr_handle_t *ah)
	Resume detection on an asr handle. More...
switch_status_t	switch_core_asr_start_input_timers (switch_asr_handle_t *ah)
	Start input timers on an asr handle. More...
void	switch_core_asr_text_param (switch_asr_handle_t *ah, char *param, const char *val)
	Set a text parameter on an asr handle. More...
void	switch_core_asr_numeric_param (switch_asr_handle_t *ah, char *param, int val)
	Set a numeric parameter on an asr handle. More...
void	switch_core_asr_float_param (switch_asr_handle_t *ah, char *param, double val)
	Set a float parameter on an asr handle. More...

Detailed Description

Function Documentation

switch_status_t switch_core_asr_check_results	(	switch_asr_handle_t *	ah,
		switch_asr_flag_t *	flags
	)

Check an asr handle for results.

Parameters

ah	the handle to check
flags	flags to influence behaviour

Returns

SWITCH_STATUS_SUCCESS

Definition at line 288 of file switch_core_asr.c.

References switch_assert.

Referenced by speech_callback(), and speech_thread().

{
        switch_assert(ah != NULL);

        return ah->asr_interface->asr_check_results(ah, flags);
}

switch_status_t switch_core_asr_close	(	switch_asr_handle_t *	ah,
		switch_asr_flag_t *	flags
	)

Close an asr handle.

Parameters

ah	the handle to close
flags	flags to influence behaviour

Returns

SWITCH_STATUS_SUCCESS

Definition at line 219 of file switch_core_asr.c.

References SWITCH_ASR_FLAG_CLOSED, SWITCH_ASR_FLAG_FREE_POOL, switch_assert, switch_core_destroy_memory_pool, switch_resample_destroy(), switch_set_flag, switch_test_flag, and UNPROTECT_INTERFACE.

Referenced by speech_callback(), and switch_ivr_detect_speech_init().

{
        switch_status_t status;

        switch_assert(ah != NULL);

        status = ah->asr_interface->asr_close(ah, flags);
        switch_set_flag(ah, SWITCH_ASR_FLAG_CLOSED);

        switch_resample_destroy(&ah->resampler);

        UNPROTECT_INTERFACE(ah->asr_interface);

        if (switch_test_flag(ah, SWITCH_ASR_FLAG_FREE_POOL)) {
                switch_core_destroy_memory_pool(&ah->memory_pool);
        }

        return status;
}

switch_status_t switch_core_asr_disable_all_grammars

(

switch_asr_handle_t *

ah

)

Disable all grammars from an asr handle.

Parameters

ah	the handle to disable the grammars from

Returns

SWITCH_STATUS_SUCCESS

Definition at line 192 of file switch_core_asr.c.

References switch_assert, and SWITCH_STATUS_FALSE.

Referenced by switch_ivr_detect_speech_disable_all_grammars().

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        switch_assert(ah != NULL);

        if (ah->asr_interface->asr_disable_all_grammars) {
                status = ah->asr_interface->asr_disable_all_grammars(ah);
        }

        return status;
}

switch_status_t switch_core_asr_disable_grammar	(	switch_asr_handle_t *	ah,
		const char *	name
	)

Disable a grammar from an asr handle.

Parameters

ah	the handle to disable the grammar from
name	the name of the grammar to disable

Returns

SWITCH_STATUS_SUCCESS

Definition at line 179 of file switch_core_asr.c.

References switch_assert, and SWITCH_STATUS_FALSE.

Referenced by switch_ivr_detect_speech_disable_grammar().

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        switch_assert(ah != NULL);

        if (ah->asr_interface->asr_disable_grammar) {
                status = ah->asr_interface->asr_disable_grammar(ah, name);
        }

        return status;
}

switch_status_t switch_core_asr_enable_grammar	(	switch_asr_handle_t *	ah,
		const char *	name
	)

Enable a grammar from an asr handle.

Parameters

ah	the handle to enable the grammar from
name	the name of the grammar to enable

Returns

SWITCH_STATUS_SUCCESS

Definition at line 166 of file switch_core_asr.c.

References switch_assert, and SWITCH_STATUS_FALSE.

Referenced by switch_ivr_detect_speech_enable_grammar().

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        switch_assert(ah != NULL);

        if (ah->asr_interface->asr_enable_grammar) {
                status = ah->asr_interface->asr_enable_grammar(ah, name);
        }

        return status;
}

switch_status_t switch_core_asr_feed	(	switch_asr_handle_t *	ah,
		void *	data,
		unsigned int	len,
		switch_asr_flag_t *	flags
	)

Feed audio data to an asr handle.

Parameters

ah	the handle to feed data to
data	a pointer to the data
len	the size in bytes of the data
flags	flags to influence behaviour

Returns

SWITCH_STATUS_SUCCESS

Definition at line 239 of file switch_core_asr.c.

References switch_assert, SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, switch_log_printf(), switch_resample_create, switch_resample_process(), SWITCH_RESAMPLE_QUALITY, SWITCH_STATUS_GENERR, and SWITCH_STATUS_SUCCESS.

Referenced by speech_callback().

{
        switch_size_t orig_len = len;
        switch_assert(ah != NULL);

        if (ah->native_rate && ah->samplerate && ah->native_rate != ah->samplerate) {
                if (!ah->resampler) {
                        if (switch_resample_create(&ah->resampler,
                                                                           ah->samplerate, ah->native_rate, (uint32_t) orig_len, SWITCH_RESAMPLE_QUALITY, 1) != SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Unable to create resampler!\n");
                                return SWITCH_STATUS_GENERR;
                        }
                }

                switch_resample_process(ah->resampler, data, len / 2);
                if (ah->resampler->to_len > orig_len) {
                        if (!ah->dbuf) {
                                void *mem;
                                ah->dbuflen = ah->resampler->to_len * 2;
                                mem = realloc(ah->dbuf, ah->dbuflen);
                                switch_assert(mem);
                                ah->dbuf = mem;
                        }
                        switch_assert(ah->resampler->to_len * 2 <= ah->dbuflen);
                        memcpy(ah->dbuf, ah->resampler->to, ah->resampler->to_len * 2);
                        data = ah->dbuf;
                } else {
                        memcpy(data, ah->resampler->to, ah->resampler->to_len * 2);
                }

                len = ah->resampler->to_len;
        }

        return ah->asr_interface->asr_feed(ah, data, len, flags);
}

switch_status_t switch_core_asr_feed_dtmf	(	switch_asr_handle_t *	ah,
		const switch_dtmf_t *	dtmf,
		switch_asr_flag_t *	flags
	)

Feed DTMF to an asr handle.

Parameters

ah	the handle to feed data to
dtmf	a string of DTMF digits
flags	flags to influence behaviour

Returns

SWITCH_STATUS_SUCCESS

Definition at line 275 of file switch_core_asr.c.

References switch_assert, and SWITCH_STATUS_SUCCESS.

Referenced by speech_on_dtmf().

{
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        switch_assert(ah != NULL);

        if (ah->asr_interface->asr_feed_dtmf) {
                status = ah->asr_interface->asr_feed_dtmf(ah, dtmf, flags);
        }

        return status;
}

void switch_core_asr_float_param	(	switch_asr_handle_t *	ah,
		char *	param,
		double	val
	)

Set a float parameter on an asr handle.

Parameters

sh	the asr handle
param	the parameter
val	the value

Definition at line 345 of file switch_core_asr.c.

References switch_assert.

{
        switch_assert(ah != NULL);

        if (ah->asr_interface->asr_float_param) {
                ah->asr_interface->asr_float_param(ah, param, val);
        }
}

switch_status_t switch_core_asr_get_result_headers	(	switch_asr_handle_t *	ah,
		switch_event_t **	headers,
		switch_asr_flag_t *	flags
	)

Get result headers from an asr handle.

Parameters

ah	the handle to get results from
headers	a pointer to dynamically allocate an switch_event_t result to
flags	flags to influence behaviour

Returns

SWITCH_STATUS_SUCCESS

Definition at line 302 of file switch_core_asr.c.

References switch_assert, and SWITCH_STATUS_SUCCESS.

Referenced by speech_thread().

{
        switch_assert(ah != NULL);

        if (ah->asr_interface->asr_get_result_headers) {
                return ah->asr_interface->asr_get_result_headers(ah, headers, flags);
        } else {
                /* Since this is not always implemented, return success if the function can't be called */
                return SWITCH_STATUS_SUCCESS;
        }
}

switch_status_t switch_core_asr_get_results	(	switch_asr_handle_t *	ah,
		char **	xmlstr,
		switch_asr_flag_t *	flags
	)

Get results from an asr handle.

Parameters

ah	the handle to get results from
xmlstr	a pointer to dynamically allocate an xml result string to
flags	flags to influence behaviour

Returns

SWITCH_STATUS_SUCCESS

Definition at line 295 of file switch_core_asr.c.

References switch_assert.

Referenced by speech_thread().

{
        switch_assert(ah != NULL);

        return ah->asr_interface->asr_get_results(ah, xmlstr, flags);
}

switch_status_t switch_core_asr_load_grammar	(	switch_asr_handle_t *	ah,
		const char *	grammar,
		const char *	name
	)

Load a grammar to an asr handle.

Parameters

ah	the handle to load to
grammar	the grammar text, file path, or URI
name	the grammar name

Returns

SWITCH_STATUS_SUCCESS

Definition at line 93 of file switch_core_asr.c.

References switch_assert, switch_core_asr_text_param(), switch_find_end_paren(), switch_safe_free, switch_separate_string(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and zstr.

Referenced by switch_ivr_detect_speech(), and switch_ivr_detect_speech_load_grammar().

{
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        char *param_string = NULL;
        char *data = NULL;
        char *lgrammar = NULL;

        switch_assert(ah != NULL);

        if (zstr(grammar)) {
                status = SWITCH_STATUS_FALSE;
                goto done;
        }

        /* Set ASR parameters from params in the grammar string
         * Params are defined as follows {name1=val1,name2=val2,name3=val3}grammar text
         */
        lgrammar = strdup(grammar);
        data = lgrammar;

        /* strip leading spaces */
        while (data && *data == ' ') {
                data++;
        }
        if (zstr(data)) {
                status = SWITCH_STATUS_FALSE;
                goto done;
        }

        /* extract params */
        if (*data == '{') {
                param_string = data + 1;
                data = switch_find_end_paren(data, '{', '}');
                if (zstr(data)) {
                        status = SWITCH_STATUS_FALSE;
                        goto done;
                } else {
                        *data = '\0';
                        data++;
                }
        }

        /* set ASR params */
        if (!zstr(param_string)) {
                char *param[256] = { 0 };
                int i;
                int argc = switch_separate_string(param_string, ',', param, (sizeof(param) / sizeof(param[0])));
                for (i = 0; i < argc && param[i]; ++i) {
                        char *param_pair[2] = { 0 };
                        if (switch_separate_string(param[i], '=', param_pair, (sizeof(param_pair) / sizeof(param_pair[0]))) == 2) {
                                switch_core_asr_text_param(ah, param_pair[0], param_pair[1]);
                        }
                }
        }

        status = ah->asr_interface->asr_load_grammar(ah, data, name);

  done:

        switch_safe_free(lgrammar);
        return status;
}

void switch_core_asr_numeric_param	(	switch_asr_handle_t *	ah,
		char *	param,
		int	val
	)

Set a numeric parameter on an asr handle.

Parameters

sh	the asr handle
param	the parameter
val	the value

Definition at line 336 of file switch_core_asr.c.

References switch_assert.

{
        switch_assert(ah != NULL);

        if (ah->asr_interface->asr_numeric_param) {
                ah->asr_interface->asr_numeric_param(ah, param, val);
        }
}

switch_status_t switch_core_asr_open	(	switch_asr_handle_t *	ah,
		const char *	module_name,
		const char *	codec,
		int	rate,
		const char *	dest,
		switch_asr_flag_t *	flags,
		switch_memory_pool_t *	pool
	)

Open an asr handle.

Parameters

ah	the asr handle to open
module_name	the name of the asr module
codec	the preferred codec
rate	the preferred rate
dest	the destination address
flags	flags to influence behaviour
pool	the pool to use (NULL for new pool)

Returns

SWITCH_STATUS_SUCCESS if the asr handle was opened

Definition at line 40 of file switch_core_asr.c.

References buf, switch_cache_db_handle::flags, pool, SWITCH_ASR_FLAG_FREE_POOL, switch_assert, SWITCH_CHANNEL_LOG, switch_core_new_memory_pool, switch_core_strdup, switch_loadable_module_get_asr_interface(), SWITCH_LOG_ERROR, switch_log_printf(), switch_set_flag, switch_set_string, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, and UNPROTECT_INTERFACE.

Referenced by switch_ivr_detect_speech_init().

{
        switch_status_t status;
        char buf[256] = "";
        char *param = NULL;

        if (strchr(module_name, ':')) {
                switch_set_string(buf, module_name);
                if ((param = strchr(buf, ':'))) {
                        *param++ = '\0';
                        module_name = buf;
                }
        }

        switch_assert(ah != NULL);

        if ((ah->asr_interface = switch_loadable_module_get_asr_interface(module_name)) == 0) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid ASR module [%s]!\n", module_name);
                return SWITCH_STATUS_GENERR;
        }

        ah->flags = *flags;

        if (pool) {
                ah->memory_pool = pool;
        } else {
                if ((status = switch_core_new_memory_pool(&ah->memory_pool)) != SWITCH_STATUS_SUCCESS) {
                        UNPROTECT_INTERFACE(ah->asr_interface);
                        return status;
                }
                switch_set_flag(ah, SWITCH_ASR_FLAG_FREE_POOL);
        }

        if (param) {
                ah->param = switch_core_strdup(ah->memory_pool, param);
        }
        ah->rate = rate;
        ah->name = switch_core_strdup(ah->memory_pool, module_name);
        ah->samplerate = rate;
        ah->native_rate = rate;

        status = ah->asr_interface->asr_open(ah, codec, rate, dest, flags);

        if (status != SWITCH_STATUS_SUCCESS) {
                UNPROTECT_INTERFACE(ah->asr_interface);
        }

        return status;

}

switch_status_t switch_core_asr_pause

(

switch_asr_handle_t *

ah

)

Pause detection on an asr handle.

Parameters

ah	the handle to pause

Returns

SWITCH_STATUS_SUCCESS

Definition at line 205 of file switch_core_asr.c.

References switch_assert.

Referenced by switch_ivr_pause_detect_speech().

{
        switch_assert(ah != NULL);

        return ah->asr_interface->asr_pause(ah);
}

switch_status_t switch_core_asr_resume

(

switch_asr_handle_t *

ah

)

Resume detection on an asr handle.

Parameters

ah	the handle to resume

Returns

SWITCH_STATUS_SUCCESS

Definition at line 212 of file switch_core_asr.c.

References switch_assert.

Referenced by switch_ivr_resume_detect_speech().

{
        switch_assert(ah != NULL);

        return ah->asr_interface->asr_resume(ah);
}

switch_status_t switch_core_asr_start_input_timers

(

switch_asr_handle_t *

ah

)

Start input timers on an asr handle.

Parameters

ah	the handle to start timers on

Returns

SWITCH_STATUS_SUCCESS

Definition at line 314 of file switch_core_asr.c.

References switch_assert, and SWITCH_STATUS_SUCCESS.

Referenced by switch_ivr_detect_speech_start_input_timers().

{
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        switch_assert(ah != NULL);

        if (ah->asr_interface->asr_start_input_timers) {
                status = ah->asr_interface->asr_start_input_timers(ah);
        }

        return status;
}

void switch_core_asr_text_param	(	switch_asr_handle_t *	ah,
		char *	param,
		const char *	val
	)

Set a text parameter on an asr handle.

Parameters

sh	the asr handle
param	the parameter
val	the value

Definition at line 327 of file switch_core_asr.c.

References switch_assert.

Referenced by switch_core_asr_load_grammar(), and switch_ivr_set_param_detect_speech().

{
        switch_assert(ah != NULL);

        if (ah->asr_interface->asr_text_param) {
                ah->asr_interface->asr_text_param(ah, param, val);
        }
}

switch_status_t switch_core_asr_unload_grammar	(	switch_asr_handle_t *	ah,
		const char *	name
	)

Unload a grammar from an asr handle.

Parameters

ah	the handle to unload the grammar from
name	the name of the grammar to unload

Returns

SWITCH_STATUS_SUCCESS

Definition at line 156 of file switch_core_asr.c.

References switch_assert.

Referenced by switch_ivr_detect_speech_unload_grammar().

{
        switch_status_t status;

        switch_assert(ah != NULL);
        status = ah->asr_interface->asr_unload_grammar(ah, name);

        return status;
}

switch_status_t switch_core_speech_close	(	switch_speech_handle_t *	sh,
		switch_speech_flag_t *	flags
	)

Close an open speech handle.

Parameters

sh	the speech handle to close
flags	flags in/out for fine tuning

Returns

SWITCH_STATUS_SUCCESS if the file handle was closed

Definition at line 283 of file switch_core_speech.c.

References switch_buffer_destroy(), switch_clear_flag, switch_core_destroy_memory_pool, switch_resample_destroy(), SWITCH_SPEECH_FLAG_FREE_POOL, SWITCH_SPEECH_FLAG_OPEN, SWITCH_STATUS_FALSE, switch_test_flag, and UNPROTECT_INTERFACE.

Referenced by switch_ivr_clear_speech_cache(), and switch_ivr_speak_text().

{
        switch_status_t status = sh->speech_interface->speech_close(sh, flags);

        if (!switch_test_flag(sh, SWITCH_SPEECH_FLAG_OPEN)) {
                return SWITCH_STATUS_FALSE;
        }

        if (sh->buffer) {
                switch_buffer_destroy(&sh->buffer);
        }

        switch_resample_destroy(&sh->resampler);

        UNPROTECT_INTERFACE(sh->speech_interface);

        if (switch_test_flag(sh, SWITCH_SPEECH_FLAG_FREE_POOL)) {
                switch_core_destroy_memory_pool(&sh->memory_pool);
        }

        switch_clear_flag(sh, SWITCH_SPEECH_FLAG_OPEN);

        return status;
}

switch_status_t switch_core_speech_feed_tts	(	switch_speech_handle_t *	sh,
		char *	text,
		switch_speech_flag_t *	flags
	)

Feed text to the TTS module.

Parameters

sh	the speech handle to feed
text	the buffer to write
flags	flags in/out for fine tuning

Returns

SWITCH_STATUS_SUCCESS with len adjusted to the bytes written if successful

Definition at line 99 of file switch_core_speech.c.

References switch_assert, switch_core_speech_text_param_tts(), switch_find_end_paren(), switch_safe_free, switch_separate_string(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and zstr.

Referenced by switch_ivr_speak_text_handle().

{
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        char *param_string = NULL;
        char *data = NULL;
        char *ltext = NULL;

        switch_assert(sh != NULL);

        if (zstr(text)) {
                status = SWITCH_STATUS_FALSE;
                goto done;
        }

        /* Set TTS parameters from params in the text string
         * Params are defined as follows {name1=val1,name2=val2,name3=val3}text to speak
         */
        ltext = strdup(text);
        data = ltext;

        /* strip leading spaces */
        while (data && *data == ' ') {
                data++;
        }
        if (zstr(data)) {
                status = SWITCH_STATUS_FALSE;
                goto done;
        }

        /* extract params */
        if (*data == '{') {
                param_string = data + 1;
                data = switch_find_end_paren(data, '{', '}');
                if (zstr(data)) {
                        status = SWITCH_STATUS_FALSE;
                        goto done;
                } else {
                        *data = '\0';
                        data++;
                }
        }

        /* set TTS params */
        if (!zstr(param_string)) {
                char *param[256] = { 0 };
                int i;
                int argc = switch_separate_string(param_string, ',', param, (sizeof(param) / sizeof(param[0])));
                for (i = 0; i < argc && param[i]; ++i) {
                        char *param_pair[2] = { 0 };
                        if (switch_separate_string(param[i], '=', param_pair, (sizeof(param_pair) / sizeof(param_pair[0]))) == 2) {
                                switch_core_speech_text_param_tts(sh, param_pair[0], param_pair[1]);
                        }
                }
        }

        status = sh->speech_interface->speech_feed_tts(sh, data, flags);

  done:

        switch_safe_free(ltext);
        return status;
}

void switch_core_speech_float_param_tts	(	switch_speech_handle_t *	sh,
		char *	param,
		double	val
	)

Set a float parameter on a TTS handle.

Parameters

sh	the speech handle
param	the parameter
val	the value

Definition at line 189 of file switch_core_speech.c.

References switch_assert.

{
        switch_assert(sh != NULL);

        if (sh->speech_interface->speech_float_param_tts) {
                sh->speech_interface->speech_float_param_tts(sh, param, val);
        }
}

void switch_core_speech_flush_tts

(

switch_speech_handle_t *

sh

)

Flush TTS audio on a given handle.

Parameters

sh	the speech handle

Definition at line 162 of file switch_core_speech.c.

References switch_assert.

Referenced by switch_ivr_speak_text_handle().

{
        switch_assert(sh != NULL);

        if (sh->speech_interface->speech_flush_tts) {
                sh->speech_interface->speech_flush_tts(sh);
        }
}

void switch_core_speech_numeric_param_tts	(	switch_speech_handle_t *	sh,
		char *	param,
		int	val
	)

Set a numeric parameter on a TTS handle.

Parameters

sh	the speech handle
param	the parameter
val	the value

Definition at line 180 of file switch_core_speech.c.

References switch_assert.

{
        switch_assert(sh != NULL);

        if (sh->speech_interface->speech_numeric_param_tts) {
                sh->speech_interface->speech_numeric_param_tts(sh, param, val);
        }
}

switch_status_t switch_core_speech_open	(	_In_ switch_speech_handle_t *	sh,
		const char *	module_name,
		const char *	voice_name,
		_In_ unsigned int	rate,
		_In_ unsigned int	interval,
		_In_ unsigned int	channels,
		switch_speech_flag_t *	flags,
		_In_opt_ switch_memory_pool_t *	pool
	)

Open a speech handle.

Parameters

sh	a speech handle to use
module_name	the speech module to use
voice_name	the desired voice name
rate	the sampling rate
interval	the sampling interval
flags	tts flags
pool	the pool to use (NULL for new pool)

Returns

SWITCH_STATUS_SUCCESS if the handle is opened

Referenced by switch_ivr_speak_text().

switch_status_t switch_core_speech_read_tts	(	switch_speech_handle_t *	sh,
		void *	data,
		switch_size_t *	datalen,
		switch_speech_flag_t *	flags
	)

Read rendered audio from the TTS module.

Parameters

sh	the speech handle to read
data	the buffer to read to
datalen	the max size / written size of the data
rate	the rate of the read audio
flags	flags in/out for fine tuning

Returns

SWITCH_STATUS_SUCCESS with len adjusted to the bytes written if successful

Definition at line 198 of file switch_core_speech.c.

References switch_assert, switch_buffer_create_dynamic(), switch_buffer_inuse(), switch_buffer_read(), switch_buffer_write(), SWITCH_CHANNEL_LOG, switch_clear_flag, switch_core_alloc, SWITCH_LOG_CRIT, switch_log_printf(), switch_mux_channels(), switch_resample_create, switch_resample_process(), SWITCH_RESAMPLE_QUALITY, switch_set_flag, SWITCH_SPEECH_FLAG_DONE, SWITCH_STATUS_BREAK, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, and switch_test_flag.

Referenced by switch_ivr_speak_text_handle().

{
        switch_status_t status;
        switch_size_t want, orig_len = *datalen;

        switch_assert(sh != NULL);

        want = *datalen;

  top:

        if (sh->buffer && (switch_buffer_inuse(sh->buffer) >= orig_len || switch_test_flag(sh, SWITCH_SPEECH_FLAG_DONE))) {
                if ((*datalen = switch_buffer_read(sh->buffer, data, orig_len))) {
                        status = SWITCH_STATUS_SUCCESS;
                        goto done;
                }
        }

        if (switch_test_flag(sh, SWITCH_SPEECH_FLAG_DONE)) {
                switch_clear_flag(sh, SWITCH_SPEECH_FLAG_DONE);
                *datalen = 0;
                return SWITCH_STATUS_BREAK;
        }

  more:

        *datalen = orig_len / sh->channels;

        if ((status = sh->speech_interface->speech_read_tts(sh, data, datalen, flags)) != SWITCH_STATUS_SUCCESS) {
                switch_set_flag(sh, SWITCH_SPEECH_FLAG_DONE);
                goto top;
        }

        if (sh->native_rate && sh->samplerate && sh->native_rate != sh->samplerate) {
                if (!sh->resampler) {
                        if (switch_resample_create(&sh->resampler,
                                                                           sh->native_rate, sh->samplerate, (uint32_t) orig_len / sh->channels, SWITCH_RESAMPLE_QUALITY, 1) != SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Unable to create resampler!\n");
                                return SWITCH_STATUS_GENERR;
                        }
                }

                switch_resample_process(sh->resampler, data, (uint32_t)(*datalen / 2));
                if (sh->resampler->to_len < want / 2 || sh->resampler->to_len > orig_len / 2) {
                        if (!sh->buffer) {
                                int factor = sh->resampler->to_len * sh->samplerate / 1000;
                                switch_buffer_create_dynamic(&sh->buffer, factor, factor, 0);
                                switch_assert(sh->buffer);
                        }
                        if (!sh->dbuf || sh->dbuflen < sh->resampler->to_len * 2) {
                                sh->dbuflen = sh->resampler->to_len * 2;
                                sh->dbuf = switch_core_alloc(sh->memory_pool, sh->dbuflen);
                        }
                        switch_assert(sh->resampler->to_len <= sh->dbuflen);

                        memcpy((int16_t *) sh->dbuf, sh->resampler->to, sh->resampler->to_len * 2);
                        switch_buffer_write(sh->buffer, sh->dbuf, sh->resampler->to_len * 2);

                        if (switch_buffer_inuse(sh->buffer) < want) {
                                *datalen = want;
                                goto more;
                        }
                        *datalen = switch_buffer_read(sh->buffer, data, orig_len);
                        status = SWITCH_STATUS_SUCCESS;
                } else {
                        memcpy(data, sh->resampler->to, sh->resampler->to_len * 2);
                        *datalen = sh->resampler->to_len * 2;
                        status = SWITCH_STATUS_SUCCESS;
                }
        }


 done:

        if (sh->channels != sh->real_channels) {
                uint32_t rlen = *datalen / 2;
                switch_mux_channels((int16_t *) data, rlen, 1, sh->channels);
                *datalen = rlen * 2 * sh->channels;
        }
        
        return status;

}

void switch_core_speech_text_param_tts	(	switch_speech_handle_t *	sh,
		char *	param,
		const char *	val
	)

Set a text parameter on a TTS handle.

Parameters

sh	the speech handle
param	the parameter
val	the value

Definition at line 171 of file switch_core_speech.c.

References switch_assert.

Referenced by switch_core_speech_feed_tts(), and switch_ivr_speak_text().

{
        switch_assert(sh != NULL);

        if (sh->speech_interface->speech_text_param_tts) {
                sh->speech_interface->speech_text_param_tts(sh, param, val);
        }
}