switch_ivr_play_say.c File Reference

#include <switch.h>

Include dependency graph for switch_ivr_play_say.c:

Go to the source code of this file.

Data Structures
struct	cached_speech_handle
Defines
#define	FILE_STARTSAMPLES   1024 * 32
#define	FILE_BLOCKSIZE   1024 * 8
#define	FILE_BUFSIZE   1024 * 64
Typedefs
typedef cached_speech_handle	cached_speech_handle_t
Functions
switch_status_t	switch_ivr_phrase_macro_event (switch_core_session_t *session, const char *macro_name, const char *data, switch_event_t *event, const char *lang, switch_input_args_t *args)
switch_status_t	switch_ivr_record_file (switch_core_session_t *session, switch_file_handle_t *fh, const char *file, switch_input_args_t *args, uint32_t limit)
static int	teletone_handler (teletone_generation_session_t *ts, teletone_tone_map_t *map)
switch_status_t	switch_ivr_gentones (switch_core_session_t *session, const char *script, int32_t loops, switch_input_args_t *args)
switch_status_t	switch_ivr_get_file_handle (switch_core_session_t *session, switch_file_handle_t **fh)
switch_status_t	switch_ivr_release_file_handle (switch_core_session_t *session, switch_file_handle_t **fh)
static void	add_playback_vars_to_event (switch_core_session_t *session, switch_event_t *event, char *vars)
switch_status_t	switch_ivr_play_file (switch_core_session_t *session, switch_file_handle_t *fh, const char *file, switch_input_args_t *args)
	play a file from the disk to the session
switch_status_t	switch_ivr_wait_for_silence (switch_core_session_t *session, uint32_t thresh, uint32_t silence_hits, uint32_t listen_hits, uint32_t timeout_ms, const char *file)
switch_status_t	switch_ivr_read (switch_core_session_t *session, uint32_t min_digits, uint32_t max_digits, const char *prompt_audio_file, const char *var_name, char *digit_buffer, switch_size_t digit_buffer_length, uint32_t timeout, const char *valid_terminators, uint32_t digit_timeout)
switch_status_t	switch_play_and_get_digits (switch_core_session_t *session, uint32_t min_digits, uint32_t max_digits, uint32_t max_tries, uint32_t timeout, const char *valid_terminators, const char *prompt_audio_file, const char *bad_input_audio_file, const char *var_name, char *digit_buffer, uint32_t digit_buffer_length, const char *digits_regex, uint32_t digit_timeout, const char *transfer_on_failure)
	Play a sound and gather digits with the number of retries specified if the user doesn't give digits in the set time.
switch_status_t	switch_ivr_speak_text_handle (switch_core_session_t *session, switch_speech_handle_t *sh, switch_codec_t *codec, switch_timer_t *timer, char *text, switch_input_args_t *args)
void	switch_ivr_clear_speech_cache (switch_core_session_t *session)
switch_status_t	switch_ivr_speak_text (switch_core_session_t *session, const char *tts_name, const char *voice_name, char *text, switch_input_args_t *args)
	Speak given text with given tts engine.
static switch_status_t	hold_on_dtmf (switch_core_session_t *session, void *input, switch_input_type_t itype, void *buf, unsigned int buflen)
switch_status_t	switch_ivr_soft_hold (switch_core_session_t *session, const char *unhold_key, const char *moh_a, const char *moh_b)

---

Define Documentation

#define FILE_BLOCKSIZE   1024 * 8

Definition at line 979 of file switch_ivr_play_say.c.

Referenced by switch_ivr_play_file().

#define FILE_BUFSIZE   1024 * 64

Definition at line 980 of file switch_ivr_play_say.c.

Referenced by switch_ivr_play_file().

#define FILE_STARTSAMPLES   1024 * 32

Definition at line 978 of file switch_ivr_play_say.c.

Referenced by switch_ivr_play_file().

---

Typedef Documentation

typedef struct cached_speech_handle cached_speech_handle_t

Definition at line 2375 of file switch_ivr_play_say.c.

---

Function Documentation

static void add_playback_vars_to_event	(	switch_core_session_t *	session,
		switch_event_t *	event,
		char *	vars
	)			[static]

Definition at line 982 of file switch_ivr_play_say.c.

References switch_core_session_sprintf(), switch_core_session_strdup, switch_event_add_header_string(), switch_separate_string(), and SWITCH_STACK_BOTTOM.

Referenced by switch_ivr_play_file().

{
        char *tmp;

        if (!session || !event || !vars)
                return;

        if ((tmp = switch_core_session_strdup(session, vars))) {
                char *argv[128] = { 0 };
                int argc, i;

                if (!(argc = switch_separate_string(tmp, ',', argv, (sizeof(argv) / sizeof(argv[0])))))
                        return;

                for (i = 0; i < argc; i++) {
                        char *var, *val;

                        if ((var = strchr(argv[i], '='))) {
                                *var = '\0';
                                val = var+1;
                                var = argv[i];

                                if (var && *var && val && *val) {
                                        if ((var = switch_core_session_sprintf(session, "playback_variable_%s", var))) {
                                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, var, val);
                                        }
                                }
                        }
                }
        }
}

static switch_status_t hold_on_dtmf	(	switch_core_session_t *	session,
		void *	input,
		switch_input_type_t	itype,
		void *	buf,
		unsigned int	buflen
	)			[static]

Definition at line 2538 of file switch_ivr_play_say.c.

References switch_dtmf_t::digit, SWITCH_INPUT_TYPE_DTMF, SWITCH_STATUS_BREAK, and SWITCH_STATUS_SUCCESS.

Referenced by switch_ivr_soft_hold().

{
        char *stop_key = (char *) buf;

        switch (itype) {
        case SWITCH_INPUT_TYPE_DTMF:
                {
                        switch_dtmf_t *dtmf = (switch_dtmf_t *) input;
                        if (dtmf->digit == *stop_key) {
                                return SWITCH_STATUS_BREAK;
                        }
                }
                break;
        default:
                break;
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_ivr_record_file	(	switch_core_session_t *	session,
		switch_file_handle_t *	fh,
		const char *	file,
		switch_input_args_t *	args,
		uint32_t	limit
	)

Definition at line 356 of file switch_ivr_play_say.c.

References switch_codec_implementation::actual_samples_per_second, switch_frame::buflen, CF_BREAK, switch_file_handle::channels, switch_frame::codec, switch_stream_handle::data, switch_frame::data, switch_frame::datalen, switch_codec_implementation::decoded_bytes_per_packet, switch_dtmf_t::digit, switch_codec_implementation::iananame, switch_codec_implementation::microseconds_per_packet, switch_codec_implementation::number_of_channels, switch_frame::samples, switch_codec_implementation::samples_per_packet, SFF_CNG, switch_directories::sounds_dir, switch_api_execute(), SWITCH_AUDIO_COL_STR_ARTIST, SWITCH_AUDIO_COL_STR_COMMENT, SWITCH_AUDIO_COL_STR_COPYRIGHT, SWITCH_AUDIO_COL_STR_DATE, SWITCH_AUDIO_COL_STR_SOFTWARE, SWITCH_AUDIO_COL_STR_TITLE, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER, switch_channel_answer, switch_channel_clear_flag(), switch_channel_dequeue_dtmf(), switch_channel_event_set_data(), switch_channel_expand_variables, switch_channel_get_variable, switch_channel_hangup, switch_channel_has_dtmf(), switch_channel_media_ready, switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_channel_set_variable_printf(), switch_channel_test_flag(), switch_clear_flag, SWITCH_CODEC_FLAG_DECODE, SWITCH_CODEC_FLAG_ENCODE, switch_core_codec_destroy(), switch_core_codec_init, switch_core_file_close(), switch_core_file_open, switch_core_file_seek(), switch_core_file_set_string(), switch_core_file_write(), switch_core_session_dequeue_event(), switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_impl(), switch_core_session_read_frame(), switch_core_session_reset(), switch_core_session_set_read_codec(), switch_core_session_sprintf(), switch_core_session_strdup, switch_core_session_write_frame(), SWITCH_DEFAULT_FILE_BUFFER_LEN, switch_epoch_time_now(), switch_event_add_header_string(), switch_event_create, switch_event_destroy(), switch_event_fire, SWITCH_EVENT_RECORD_START, SWITCH_EVENT_RECORD_STOP, SWITCH_FALSE, SWITCH_FILE_DATA_SHORT, SWITCH_FILE_FLAG_WRITE, SWITCH_FILE_NATIVE, SWITCH_FILE_PAUSE, SWITCH_FILE_SEEK, SWITCH_FILE_WRITE_APPEND, SWITCH_FILE_WRITE_OVER, switch_find_end_paren(), switch_generate_sln_silence(), SWITCH_GLOBAL_dirs, SWITCH_INPUT_TYPE_DTMF, SWITCH_INPUT_TYPE_EVENT, SWITCH_IO_FLAG_NONE, switch_is_file_path(), switch_is_valid_rate, switch_ivr_dmachine_feed(), switch_ivr_dmachine_ping(), switch_ivr_parse_all_events(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_PATH_SEPARATOR, SWITCH_READ_ACCEPTABLE, SWITCH_RECOMMENDED_BUFFER_SIZE, switch_safe_free, SWITCH_STACK_BOTTOM, SWITCH_STANDARD_STREAM, SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, switch_str_nil, switch_test_flag, SWITCH_TRUE, switch_true(), SWITCH_URL_SEPARATOR, and write_buf().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_dtmf_t dtmf = { 0 };
        switch_file_handle_t lfh = { 0 };
        switch_frame_t *read_frame;
        switch_codec_t codec, write_codec = { 0 };
        char *codec_name;
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        const char *p;
        const char *vval;
        time_t start = 0;
        uint32_t org_silence_hits = 0;
        int asis = 0;
        int32_t sample_start = 0;
        int waste_resources = 0, fill_cng = 0;
        switch_codec_implementation_t read_impl = { 0 };
        switch_frame_t write_frame = { 0 };
        unsigned char write_buf[SWITCH_RECOMMENDED_BUFFER_SIZE] = { 0 };
        switch_event_t *event;
        int divisor = 0;
        int file_flags = SWITCH_FILE_FLAG_WRITE | SWITCH_FILE_DATA_SHORT;
        int restart_limit_on_dtmf = 0;
        const char *prefix, *var;

        prefix = switch_channel_get_variable(channel, "sound_prefix");

        if (!prefix) {
                prefix = SWITCH_GLOBAL_dirs.sounds_dir;
        }

        switch_core_session_get_read_impl(session, &read_impl);

        if (!(divisor = read_impl.actual_samples_per_second / 8000)) {
                divisor = 1;
        }


        if (!switch_channel_ready(channel)) {
                return SWITCH_STATUS_FALSE;
        }

        if (switch_channel_answer(channel) != SWITCH_STATUS_SUCCESS) {
                return SWITCH_STATUS_FALSE;
        }

        if (!switch_channel_media_ready(channel)) {
                return SWITCH_STATUS_FALSE;
        }

        if (!fh) {
                fh = &lfh;
        }

        fh->channels = read_impl.number_of_channels;
        fh->native_rate = read_impl.actual_samples_per_second;

        if (fh->samples > 0) {
                sample_start = fh->samples;
                fh->samples = 0;
        }

        if ((vval = switch_channel_get_variable(channel, "record_sample_rate"))) {
                int tmp = 0;

                tmp = atoi(vval);

                if (switch_is_valid_rate(tmp)) {
                        fh->samplerate = tmp;
                }
        }

        
        if ((vval = switch_channel_get_variable(channel, "record_fill_cng"))) {

                if (!strcasecmp(vval, "true")) {
                        fill_cng = 1400;
                } else {
                        if ((fill_cng = atoi(vval)) < 0) {
                                fill_cng = 0;
                        }
                }
        }
        

        if ((vval = switch_channel_get_variable(channel, "record_waste_resources"))) {

                if (!strcasecmp(vval, "true")) {
                        waste_resources = 1400;
                } else {
                        if ((waste_resources = atoi(vval)) < 0) {
                                waste_resources = 0;
                        }
                }
        }


        if (fill_cng || waste_resources) {
                if (switch_core_codec_init(&write_codec,
                                                                   "L16",
                                                                   NULL,
                                                                   read_impl.actual_samples_per_second,
                                                                   read_impl.microseconds_per_packet / 1000,
                                                                   read_impl.number_of_channels,
                                                                   SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL,
                                                                   switch_core_session_get_pool(session)) == SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Raw Codec Activated, ready to waste resources!\n");
                        write_frame.data = write_buf;
                        write_frame.buflen = sizeof(write_buf);
                        write_frame.datalen = read_impl.decoded_bytes_per_packet;
                        write_frame.samples = write_frame.datalen / 2;
                        write_frame.codec = &write_codec;
                } else {
                        return SWITCH_STATUS_FALSE;
                }
        }

        if (!strstr(file, SWITCH_URL_SEPARATOR)) {
                char *ext;

                if (!switch_is_file_path(file)) {
                        char *tfile = NULL;
                        char *e;

                        if (*file == '[') {
                                tfile = switch_core_session_strdup(session, file);
                                if ((e = switch_find_end_paren(tfile, '[', ']'))) {
                                        *e = '\0';
                                        file = e + 1;
                                } else {
                                        tfile = NULL;
                                }
                        }

                        file = switch_core_session_sprintf(session, "%s%s%s%s%s", switch_str_nil(tfile), tfile ? "]" : "", prefix, SWITCH_PATH_SEPARATOR, file);
                }
                if ((ext = strrchr(file, '.'))) {
                        ext++;
                } else {
                        ext = read_impl.iananame;
                        file = switch_core_session_sprintf(session, "%s.%s", file, ext);
                        asis = 1;
                }
        }

        vval = switch_channel_get_variable(channel, "enable_file_write_buffering");
        if (!vval || switch_true(vval)) {
                fh->pre_buffer_datalen = SWITCH_DEFAULT_FILE_BUFFER_LEN;
        }

        if (switch_test_flag(fh, SWITCH_FILE_WRITE_APPEND) || ((p = switch_channel_get_variable(channel, "RECORD_APPEND")) && switch_true(p))) {
                file_flags |= SWITCH_FILE_WRITE_APPEND;
        }

        if (switch_test_flag(fh, SWITCH_FILE_WRITE_OVER) || ((p = switch_channel_get_variable(channel, "RECORD_WRITE_OVER")) && switch_true(p))) {
                file_flags |= SWITCH_FILE_WRITE_OVER;
        }

        if (!fh->prefix) {
                fh->prefix = prefix;
        }

        if (switch_core_file_open(fh, file, fh->channels, read_impl.actual_samples_per_second, file_flags, NULL) != SWITCH_STATUS_SUCCESS) {
                switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
                return SWITCH_STATUS_GENERR;
        }

        if (sample_start > 0) {
                uint32_t pos = 0;
                switch_core_file_seek(fh, &pos, sample_start, SEEK_SET);
                switch_clear_flag(fh, SWITCH_FILE_SEEK);        
                fh->samples = 0;
        }


        if (switch_test_flag(fh, SWITCH_FILE_NATIVE)) {
                asis = 1;
        }
        
        restart_limit_on_dtmf = switch_true(switch_channel_get_variable(channel, "record_restart_limit_on_dtmf"));

        if ((p = switch_channel_get_variable(channel, "RECORD_TITLE"))) {
                vval = switch_core_session_strdup(session, p);
                switch_core_file_set_string(fh, SWITCH_AUDIO_COL_STR_TITLE, vval);
                switch_channel_set_variable(channel, "RECORD_TITLE", NULL);
        }

        if ((p = switch_channel_get_variable(channel, "RECORD_COPYRIGHT"))) {
                vval = switch_core_session_strdup(session, p);
                switch_core_file_set_string(fh, SWITCH_AUDIO_COL_STR_COPYRIGHT, vval);
                switch_channel_set_variable(channel, "RECORD_COPYRIGHT", NULL);
        }

        if ((p = switch_channel_get_variable(channel, "RECORD_SOFTWARE"))) {
                vval = switch_core_session_strdup(session, p);
                switch_core_file_set_string(fh, SWITCH_AUDIO_COL_STR_SOFTWARE, vval);
                switch_channel_set_variable(channel, "RECORD_SOFTWARE", NULL);
        }

        if ((p = switch_channel_get_variable(channel, "RECORD_ARTIST"))) {
                vval = switch_core_session_strdup(session, p);
                switch_core_file_set_string(fh, SWITCH_AUDIO_COL_STR_ARTIST, vval);
                switch_channel_set_variable(channel, "RECORD_ARTIST", NULL);
        }

        if ((p = switch_channel_get_variable(channel, "RECORD_COMMENT"))) {
                vval = switch_core_session_strdup(session, p);
                switch_core_file_set_string(fh, SWITCH_AUDIO_COL_STR_COMMENT, vval);
                switch_channel_set_variable(channel, "RECORD_COMMENT", NULL);
        }

        if ((p = switch_channel_get_variable(channel, "RECORD_DATE"))) {
                vval = switch_core_session_strdup(session, p);
                switch_core_file_set_string(fh, SWITCH_AUDIO_COL_STR_DATE, vval);
                switch_channel_set_variable(channel, "RECORD_DATE", NULL);
        }

        if (!asis) {
                codec_name = "L16";
                if (switch_core_codec_init(&codec,
                                                                   codec_name,
                                                                   NULL,
                                                                   read_impl.actual_samples_per_second,
                                                                   read_impl.microseconds_per_packet / 1000,
                                                                   read_impl.number_of_channels,
                                                                   SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL,
                                                                   switch_core_session_get_pool(session)) == SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Raw Codec Activated\n");
                        switch_core_session_set_read_codec(session, &codec);
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,
                                                          "Raw Codec Activation Failed %s@%uhz %u channels %dms\n", codec_name, fh->samplerate,
                                                          fh->channels, read_impl.microseconds_per_packet / 1000);
                        switch_core_file_close(fh);
                        switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
                        return SWITCH_STATUS_GENERR;
                }
        }

        if (limit) {
                start = switch_epoch_time_now(NULL);
        }

        if (fh->thresh) {
                if (asis) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Can't detect silence on a native recording.\n");
                } else {
                        if (fh->silence_hits) {
                                fh->silence_hits = fh->samplerate * fh->silence_hits / read_impl.samples_per_packet;
                        } else {
                                fh->silence_hits = fh->samplerate * 3 / read_impl.samples_per_packet;
                        }
                        org_silence_hits = fh->silence_hits;
                }
        }


        if (switch_event_create(&event, SWITCH_EVENT_RECORD_START) == SWITCH_STATUS_SUCCESS) {
                switch_channel_event_set_data(channel, event);
                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Record-File-Path", file);
                switch_event_fire(&event);
        }

        for (;;) {
                switch_size_t len;

                if (!switch_channel_ready(channel)) {
                        status = SWITCH_STATUS_FALSE;
                        break;
                }

                if (switch_channel_test_flag(channel, CF_BREAK)) {
                        switch_channel_clear_flag(channel, CF_BREAK);
                        status = SWITCH_STATUS_BREAK;
                        break;
                }

                switch_ivr_parse_all_events(session);

                if (start && (switch_epoch_time_now(NULL) - start) > limit) {
                        break;
                }

                if (args) {
                        /*
                           dtmf handler function you can hook up to be executed when a digit is dialed during playback 
                           if you return anything but SWITCH_STATUS_SUCCESS the playback will stop.
                         */
                        if (switch_channel_has_dtmf(channel)) {

                                if (limit && restart_limit_on_dtmf) {
                                        start = switch_epoch_time_now(NULL);
                                }

                                if (!args->input_callback && !args->buf && !args->dmachine) {
                                        status = SWITCH_STATUS_BREAK;
                                        break;
                                }
                                switch_channel_dequeue_dtmf(channel, &dtmf);

                                if (args->dmachine) {
                                        char ds[2] = {dtmf.digit, '\0'};
                                        if ((status = switch_ivr_dmachine_feed(args->dmachine, ds, NULL)) != SWITCH_STATUS_SUCCESS) {
                                                break;
                                        }
                                } 

                                if (args->input_callback) {
                                        status = args->input_callback(session, (void *) &dtmf, SWITCH_INPUT_TYPE_DTMF, args->buf, args->buflen);
                                } else if (args->buf) {
                                        *((char *) args->buf) = dtmf.digit;
                                        status = SWITCH_STATUS_BREAK;
                                }
                        }

                        if (args->input_callback) {
                                switch_event_t *event = NULL;

                                if (switch_core_session_dequeue_event(session, &event, SWITCH_FALSE) == SWITCH_STATUS_SUCCESS) {
                                        status = args->input_callback(session, event, SWITCH_INPUT_TYPE_EVENT, args->buf, args->buflen);
                                        switch_event_destroy(&event);
                                }
                        }

                        if (status != SWITCH_STATUS_SUCCESS) {
                                break;
                        }
                }

                status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
                if (!SWITCH_READ_ACCEPTABLE(status)) {
                        break;
                }

                if (args && args->dmachine) {
                        if ((status = switch_ivr_dmachine_ping(args->dmachine, NULL)) != SWITCH_STATUS_SUCCESS) {
                                break;
                        }
                }

                if (args && (args->read_frame_callback)) {
                        if ((status = args->read_frame_callback(session, read_frame, args->user_data)) != SWITCH_STATUS_SUCCESS) {
                                break;
                        }
                }

                if (!asis && fh->thresh) {
                        int16_t *fdata = (int16_t *) read_frame->data;
                        uint32_t samples = read_frame->datalen / sizeof(*fdata);
                        uint32_t score, count = 0, j = 0;
                        double energy = 0;


                        for (count = 0; count < samples; count++) {
                                energy += abs(fdata[j]);
                                j += read_impl.number_of_channels;
                        }

                        score = (uint32_t) (energy / (samples / divisor));

                        if (score < fh->thresh) {
                                if (!--fh->silence_hits) {
                                        break;
                                }
                        } else {
                                fh->silence_hits = org_silence_hits;
                        }
                }

                if (fill_cng) {
                        switch_generate_sln_silence((int16_t *) write_frame.data, write_frame.samples, fill_cng);
                } else if (waste_resources) {
                        switch_generate_sln_silence((int16_t *) write_frame.data, write_frame.samples, waste_resources);
                }

                if (!switch_test_flag(fh, SWITCH_FILE_PAUSE) && !switch_test_flag(read_frame, SFF_CNG)) {
                        int16_t *data = read_frame->data;
                        len = (switch_size_t) asis ? read_frame->datalen : read_frame->datalen / 2;

                        if (switch_core_file_write(fh, data, &len) != SWITCH_STATUS_SUCCESS) {
                                break;
                        }
                } else if (switch_test_flag(read_frame, SFF_CNG) && fill_cng) {
                        len = write_frame.datalen / 2;
                        if (switch_core_file_write(fh, write_frame.data, &len) != SWITCH_STATUS_SUCCESS) {
                                break;
                        }                       
                }

                if (waste_resources) {
                        if (switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0) != SWITCH_STATUS_SUCCESS) {
                                break;
                        }
                }

        }

        if (fill_cng || waste_resources) {
                switch_core_codec_destroy(&write_codec);
        }

        switch_core_file_close(fh);


        if ((var = switch_channel_get_variable(channel, "record_post_process_exec_api"))) {
                char *cmd = switch_core_session_strdup(session, var);
                char *data, *expanded = NULL;
                switch_stream_handle_t stream = { 0 };
                
                SWITCH_STANDARD_STREAM(stream);
                
                if ((data = strchr(cmd, ':'))) {
                        *data++ = '\0';
                        expanded = switch_channel_expand_variables(channel, data);
                }
                
                switch_api_execute(cmd, expanded, session, &stream);
                
                if (expanded && expanded != data) {
                        free(expanded);
                }
                
                switch_safe_free(stream.data);
                
        }

        if (read_impl.actual_samples_per_second) {
                switch_channel_set_variable_printf(channel, "record_seconds", "%d", fh->samples_out / read_impl.actual_samples_per_second);
                switch_channel_set_variable_printf(channel, "record_ms", "%d", fh->samples_out / (read_impl.actual_samples_per_second / 1000));

        }

        switch_channel_set_variable_printf(channel, "record_samples", "%d", fh->samples_out);

        if (switch_event_create(&event, SWITCH_EVENT_RECORD_STOP) == SWITCH_STATUS_SUCCESS) {
                switch_channel_event_set_data(channel, event);
                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Record-File-Path", file);
                switch_event_fire(&event);
        }

        switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
        return status;
}

static int teletone_handler	(	teletone_generation_session_t *	ts,
		teletone_tone_map_t *	map
	)			[static]

Definition at line 802 of file switch_ivr_play_say.c.

References teletone_generation_session::buffer, switch_buffer_write(), teletone_mux_tones(), and teletone_generation_session::user_data.

{
        switch_buffer_t *audio_buffer = ts->user_data;
        int wrote;

        if (!audio_buffer) {
                return -1;
        }

        wrote = teletone_mux_tones(ts, map);
        switch_buffer_write(audio_buffer, ts->buffer, wrote * 2);

        return 0;
}

---