ASR/TTS Functions
[Core Library]

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, switch_speech_flag_t *flags, _In_opt_ switch_memory_pool_t *pool)
	Open a speech handle.
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.
void	switch_core_speech_flush_tts (switch_speech_handle_t *sh)
	Flush TTS audio on a given handle.
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.
void	switch_core_speech_numeric_param_tts (switch_speech_handle_t *sh, char *param, int val)
	Set a numeric parameter on a TTS handle.
void	switch_core_speech_float_param_tts (switch_speech_handle_t *sh, char *param, double val)
	Set a float parameter on a TTS handle.
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.
switch_status_t	switch_core_speech_close (switch_speech_handle_t *sh, switch_speech_flag_t *flags)
	Close an open speech handle.
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.
switch_status_t	switch_core_asr_close (switch_asr_handle_t *ah, switch_asr_flag_t *flags)
	Close an asr handle.
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.
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.
switch_status_t	switch_core_asr_check_results (switch_asr_handle_t *ah, switch_asr_flag_t *flags)
	Check an asr handle for 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.
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.
switch_status_t	switch_core_asr_unload_grammar (switch_asr_handle_t *ah, const char *name)
	Unload a grammar from an asr handle.
switch_status_t	switch_core_asr_enable_grammar (switch_asr_handle_t *ah, const char *name)
	Enable a grammar from an asr handle.
switch_status_t	switch_core_asr_disable_grammar (switch_asr_handle_t *ah, const char *name)
	Disable a grammar from an asr handle.
switch_status_t	switch_core_asr_disable_all_grammars (switch_asr_handle_t *ah)
	Disable all grammars from an asr handle.
switch_status_t	switch_core_asr_pause (switch_asr_handle_t *ah)
	Pause detection on an asr handle.
switch_status_t	switch_core_asr_resume (switch_asr_handle_t *ah)
	Resume detection on an asr handle.
switch_status_t	switch_core_asr_start_input_timers (switch_asr_handle_t *ah)
	Start input timers on an asr handle.
void	switch_core_asr_text_param (switch_asr_handle_t *ah, char *param, const char *val)
	Set a text parameter on an asr handle.
void	switch_core_asr_numeric_param (switch_asr_handle_t *ah, char *param, int val)
	Set a numeric parameter on an asr handle.
void	switch_core_asr_float_param (switch_asr_handle_t *ah, char *param, double val)
	Set a float parameter on an asr handle.

---

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

References SWITCH_ASR_FLAG_CLOSED, SWITCH_ASR_FLAG_FREE_POOL, switch_assert, switch_core_destroy_memory_pool, switch_set_flag, switch_test_flag, and UNPROTECT_INTERFACE.

Referenced by speech_callback(), and switch_ivr_detect_speech().

{
        switch_status_t status;

        switch_assert(ah != NULL);

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

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

References switch_assert.

Referenced by speech_callback().

{
        switch_assert(ah != NULL);

        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 242 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 300 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_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 262 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 91 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 291 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_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().

{
        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);

        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 203 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 210 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 269 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 282 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 154 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 269 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 96 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 186 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 159 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 177 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,
		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 195 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_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))) {
                        return SWITCH_STATUS_SUCCESS;
                }
        }

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

  more:

        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, 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, *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;
                }
        }

        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 168 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);
        }
}

---