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, const 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_core_asr_check_results()

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 297 of file switch_core_asr.c.

References switch_asr_interface::asr_check_results, switch_asr_handle::asr_interface, and switch_assert.

Referenced by speech_callback(), and speech_thread().

{
        switch_assert(ah != NULL);

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

switch_core_asr_close()

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 227 of file switch_core_asr.c.

References switch_asr_interface::asr_close, switch_asr_handle::asr_interface, switch_asr_handle::dbuf, switch_asr_handle::memory_pool, switch_asr_handle::resampler, SWITCH_ASR_FLAG_CLOSED, SWITCH_ASR_FLAG_FREE_POOL, switch_assert, switch_core_destroy_memory_pool, switch_resample_destroy(), switch_safe_free, 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_safe_free(ah->dbuf);
        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_core_asr_disable_all_grammars()

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 200 of file switch_core_asr.c.

References switch_asr_interface::asr_disable_all_grammars, switch_asr_handle::asr_interface, 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_core_asr_disable_grammar()

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 187 of file switch_core_asr.c.

References switch_asr_interface::asr_disable_grammar, switch_asr_handle::asr_interface, 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_core_asr_enable_grammar()

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 174 of file switch_core_asr.c.

References switch_asr_interface::asr_enable_grammar, switch_asr_handle::asr_interface, 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_core_asr_feed()

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 248 of file switch_core_asr.c.

References switch_asr_interface::asr_feed, switch_asr_handle::asr_interface, switch_asr_handle::dbuf, switch_asr_handle::dbuflen, switch_asr_handle::native_rate, switch_asr_handle::resampler, switch_asr_handle::samplerate, switch_assert, SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, switch_log_printf(), switch_resample_create, switch_resample_process(), SWITCH_RESAMPLE_QUALITY, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, switch_audio_resampler_t::to, and switch_audio_resampler_t::to_len.

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 * 2 > orig_len) {
                        if (ah->dbuflen < ah->resampler->to_len * 2) {
                                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 * 2;
        }

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

switch_core_asr_feed_dtmf()

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 284 of file switch_core_asr.c.

References switch_asr_interface::asr_feed_dtmf, switch_asr_handle::asr_interface, 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;
}

switch_core_asr_float_param()

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 354 of file switch_core_asr.c.

References switch_asr_interface::asr_float_param, switch_asr_handle::asr_interface, and switch_assert.

{
        switch_assert(ah != NULL);

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

switch_core_asr_get_result_headers()

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 311 of file switch_core_asr.c.

References switch_asr_interface::asr_get_result_headers, switch_asr_handle::asr_interface, 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_core_asr_get_results()

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 304 of file switch_core_asr.c.

References switch_asr_interface::asr_get_results, switch_asr_handle::asr_interface, and switch_assert.

Referenced by speech_thread().

{
        switch_assert(ah != NULL);

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

switch_core_asr_load_grammar()

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 101 of file switch_core_asr.c.

References switch_asr_handle::asr_interface, switch_asr_interface::asr_load_grammar, 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;
}

switch_core_asr_numeric_param()

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 345 of file switch_core_asr.c.

References switch_asr_handle::asr_interface, switch_asr_interface::asr_numeric_param, and switch_assert.

{
        switch_assert(ah != NULL);

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

switch_core_asr_open()

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 switch_asr_handle::asr_interface, switch_asr_interface::asr_open, switch_cache_db_handle::flags, switch_asr_handle::flags, switch_asr_handle::memory_pool, switch_asr_handle::name, switch_asr_handle::native_rate, switch_asr_handle::param, pool, switch_asr_handle::rate, switch_asr_handle::samplerate, SWITCH_ASR_FLAG_FREE_POOL, switch_assert, SWITCH_CHANNEL_LOG, switch_core_destroy_memory_pool, switch_core_new_memory_pool, switch_core_strdup, switch_loadable_module_get_asr_interface(), SWITCH_LOG_ERROR, switch_log_printf(), switch_set_flag, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, switch_test_flag, and UNPROTECT_INTERFACE.

Referenced by switch_ivr_detect_speech_init().

{
        switch_status_t status;
        char *module_name_dup = NULL;
        char *param = NULL;
        int free_pool = 0;

        if (!pool) {
                if ((status = switch_core_new_memory_pool(&pool)) != SWITCH_STATUS_SUCCESS) {
                        return status;
                }
                free_pool = 1;
        }

        if (strchr(module_name, ':')) {
                module_name_dup = switch_core_strdup(pool, module_name);
                if ((param = strchr(module_name_dup, ':'))) {
                        *param++ = '\0';
                        module_name = module_name_dup;
                }
        }

        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);
                if (free_pool) {
                        switch_core_destroy_memory_pool(&pool);
                }
                return SWITCH_STATUS_GENERR;
        }

        ah->flags = *flags;

        ah->memory_pool = pool;
        if (free_pool) {
                switch_set_flag(ah, SWITCH_ASR_FLAG_FREE_POOL);
        }
        if (param) {
                ah->param = 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) {
                if (switch_test_flag(ah, SWITCH_ASR_FLAG_FREE_POOL)) {
                        switch_core_destroy_memory_pool(&ah->memory_pool);
                }
                UNPROTECT_INTERFACE(ah->asr_interface);
        }

        return status;

}

switch_core_asr_pause()

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 213 of file switch_core_asr.c.

References switch_asr_handle::asr_interface, switch_asr_interface::asr_pause, and switch_assert.

Referenced by switch_ivr_pause_detect_speech().

{
        switch_assert(ah != NULL);

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

switch_core_asr_resume()

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 220 of file switch_core_asr.c.

References switch_asr_handle::asr_interface, switch_asr_interface::asr_resume, and switch_assert.

Referenced by switch_ivr_resume_detect_speech().

{
        switch_assert(ah != NULL);

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

switch_core_asr_start_input_timers()

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 323 of file switch_core_asr.c.

References switch_asr_handle::asr_interface, switch_asr_interface::asr_start_input_timers, 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;
}

switch_core_asr_text_param()

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 336 of file switch_core_asr.c.

References switch_asr_handle::asr_interface, switch_asr_interface::asr_text_param, and switch_assert.

Referenced by asr_set_json_text_params(), 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_core_asr_unload_grammar()

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 164 of file switch_core_asr.c.

References switch_asr_handle::asr_interface, switch_asr_interface::asr_unload_grammar, and 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_core_speech_close()

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_speech_handle::buffer, switch_speech_handle::memory_pool, switch_speech_handle::resampler, switch_speech_interface::speech_close, switch_speech_handle::speech_interface, 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_core_speech_feed_tts()

switch_status_t switch_core_speech_feed_tts	(	switch_speech_handle_t *	sh,
		const 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_speech_interface::speech_feed_tts, switch_speech_handle::speech_interface, 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;
}

switch_core_speech_float_param_tts()

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_speech_interface::speech_float_param_tts, switch_speech_handle::speech_interface, and switch_assert.

{
        switch_assert(sh != NULL);

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

switch_core_speech_flush_tts()

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_speech_interface::speech_flush_tts, switch_speech_handle::speech_interface, and 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);
        }
}

switch_core_speech_numeric_param_tts()

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_speech_handle::speech_interface, switch_speech_interface::speech_numeric_param_tts, and 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_core_speech_open()

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_core_speech_read_tts()

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_speech_handle::buffer, switch_speech_handle::channels, switch_speech_handle::dbuf, switch_speech_handle::dbuflen, switch_speech_handle::memory_pool, switch_speech_handle::native_rate, switch_speech_handle::real_channels, switch_speech_handle::resampler, switch_speech_handle::samplerate, switch_speech_handle::speech_interface, switch_speech_interface::speech_read_tts, 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, switch_test_flag, switch_audio_resampler_t::to, and switch_audio_resampler_t::to_len.

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;

}

switch_core_speech_text_param_tts()

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_speech_handle::speech_interface, switch_speech_interface::speech_text_param_tts, and 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);
        }
}