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
struct	switch_collect_input_state_t

Macros
#define	FILE_STARTSAMPLES   1024 * 32
#define	FILE_BLOCKSIZE   1024 * 8
#define	FILE_BUFSIZE   1024 * 64

Typedefs
typedef struct cached_speech_handle	cached_speech_handle_t

Enumerations
enum	switch_collect_input_flags_t {   SWITCH_COLLECT_INPUT_PROMPT = (1 << 0), SWITCH_COLLECT_INPUT_SPEECH = (1 << 1), SWITCH_COLLECT_INPUT_SPEECH_DONE = (1 << 2), SWITCH_COLLECT_INPUT_DIGITS = (1 << 3),   SWITCH_COLLECT_INPUT_DIGITS_DONE = (1 << 4) }

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)
static void	merge_recording_variables (switch_event_t *vars, switch_event_t *event)
static const char *	get_recording_var (switch_channel_t *channel, switch_event_t *vars, switch_file_handle_t *fh, const char *name)
static int	recording_var_true (switch_channel_t *channel, switch_event_t *vars, switch_file_handle_t *fh, const char *name)
switch_status_t	switch_ivr_record_file_event (switch_core_session_t *session, switch_file_handle_t *fh, const char *file, switch_input_args_t *args, uint32_t limit, switch_event_t *vars)
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)
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 More...
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_detect_audio (switch_core_session_t *session, uint32_t thresh, uint32_t audio_hits, uint32_t timeout_ms, const char *file)
switch_status_t	switch_ivr_detect_silence (switch_core_session_t *session, uint32_t thresh, uint32_t silence_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. More...
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, const 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, const char *text, switch_input_args_t *args)
	Speak given text with given tts engine. More...
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)
static void	deliver_asr_event (switch_core_session_t *session, switch_event_t *event, switch_input_args_t *args)
static switch_status_t	switch_collect_input_callback (switch_core_session_t *session, void *input, switch_input_type_t input_type, void *data, unsigned int len)
switch_status_t	switch_ivr_play_and_collect_input (switch_core_session_t *session, const char *prompt, const char *recognizer_mod_name, const char *recognizer_grammar, int min_digits, int max_digits, const char *terminators, uint32_t digit_timeout, cJSON **recognition_result, char **digits_collected, char *terminator_collected, switch_input_args_t *args)
	Play prompt and collect input. More...

Macro Definition Documentation

FILE_BLOCKSIZE

#define FILE_BLOCKSIZE   1024 * 8

Definition at line 1241 of file switch_ivr_play_say.c.

Referenced by switch_ivr_play_file().

FILE_BUFSIZE

#define FILE_BUFSIZE   1024 * 64

Definition at line 1242 of file switch_ivr_play_say.c.

Referenced by switch_ivr_play_file().

FILE_STARTSAMPLES

#define FILE_STARTSAMPLES   1024 * 32

Definition at line 1240 of file switch_ivr_play_say.c.

Referenced by switch_ivr_play_file().

Typedef Documentation

cached_speech_handle_t

typedef struct cached_speech_handle cached_speech_handle_t

Definition at line 3006 of file switch_ivr_play_say.c.

Enumeration Type Documentation

switch_collect_input_flags_t

enum switch_collect_input_flags_t

Enumerator
SWITCH_COLLECT_INPUT_PROMPT	playing initial prompt - allow barge in
SWITCH_COLLECT_INPUT_SPEECH	looking for speech input
SWITCH_COLLECT_INPUT_SPEECH_DONE	finished looking for speech input
SWITCH_COLLECT_INPUT_DIGITS	looking for digits
SWITCH_COLLECT_INPUT_DIGITS_DONE	finished looking for digits

Definition at line 3263 of file switch_ivr_play_say.c.

             {
        /** playing initial prompt - allow barge in */
        SWITCH_COLLECT_INPUT_PROMPT = (1 << 0),
        /** looking for speech input */
        SWITCH_COLLECT_INPUT_SPEECH = (1 << 1),
        /** finished looking for speech input */
        SWITCH_COLLECT_INPUT_SPEECH_DONE = (1 << 2),
        /** looking for digits */
        SWITCH_COLLECT_INPUT_DIGITS = (1 << 3),
        /** finished looking for digits */
        SWITCH_COLLECT_INPUT_DIGITS_DONE = (1 << 4)
} switch_collect_input_flags_t;

Function Documentation

deliver_asr_event()

static void deliver_asr_event ( switch_core_session_t *  session, switch_event_t *  event, switch_input_args_t *  args  )

static

Definition at line 3289 of file switch_ivr_play_say.c.

References switch_input_args_t::buf, switch_input_args_t::buflen, switch_input_args_t::input_callback, and SWITCH_INPUT_TYPE_EVENT.

Referenced by switch_collect_input_callback().

{
        if (args && args->input_callback) {
                args->input_callback(session, (void *)event, SWITCH_INPUT_TYPE_EVENT, args->buf, args->buflen);
        }
}

get_recording_var()

static const char* get_recording_var ( switch_channel_t *  channel, switch_event_t *  vars, switch_file_handle_t *  fh, const char *  name  )

static

Definition at line 384 of file switch_ivr_play_say.c.

References switch_file_handle::params, switch_channel_get_variable, and switch_event_get_header.

Referenced by recording_var_true(), and switch_ivr_record_file_event().

{
        const char *val = NULL;
        if (vars) {
                val = switch_event_get_header(vars, name);
        }
        if (!val && fh && fh->params) {
                val = switch_event_get_header(fh->params, name);
        }
        if (!val) {
                val = switch_channel_get_variable(channel, name);
        }
        return val;
}

hold_on_dtmf()

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 3178 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;
}

merge_recording_variables()

static void merge_recording_variables ( switch_event_t *  vars, switch_event_t *  event  )

static

Definition at line 366 of file switch_ivr_play_say.c.

References buf, switch_event::headers, switch_event_header::name, switch_event_header::next, switch_assert, switch_event_add_header_string(), switch_snprintf(), SWITCH_STACK_BOTTOM, and switch_event_header::value.

Referenced by switch_ivr_record_file_event().

{
        switch_event_header_t *hi;
        if (vars) {
                for (hi = vars->headers; hi; hi = hi->next) {
                        char buf[1024];
                        char *vvar = NULL, *vval = NULL;

                        vvar = (char *) hi->name;
                        vval = (char *) hi->value;

                        switch_assert(vvar && vval);
                        switch_snprintf(buf, sizeof(buf), "Recording-Variable-%s", vvar);
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, buf, vval);
                }
        }
}

recording_var_true()

static int recording_var_true ( switch_channel_t *  channel, switch_event_t *  vars, switch_file_handle_t *  fh, const char *  name  )

static

Definition at line 399 of file switch_ivr_play_say.c.

References get_recording_var(), and switch_true().

Referenced by switch_ivr_record_file_event().

{
        return switch_true(get_recording_var(channel, vars, fh, name));
}

switch_collect_input_callback()

static switch_status_t switch_collect_input_callback ( switch_core_session_t *  session, void *  input, switch_input_type_t  input_type, void *  data, unsigned int  len  )

static

Definition at line 3296 of file switch_ivr_play_say.c.

References cJSON_GetObjectCstr(), deliver_asr_event(), switch_dtmf_t::digit, switch_collect_input_state_t::digits, switch_collect_input_state_t::is_speech, switch_collect_input_state_t::last_digit_time, switch_collect_input_state_t::max_digits, switch_collect_input_state_t::original_args, switch_collect_input_state_t::recognition_result, switch_channel_get_name(), SWITCH_CHANNEL_SESSION_LOG, SWITCH_COLLECT_INPUT_DIGITS, SWITCH_COLLECT_INPUT_DIGITS_DONE, SWITCH_COLLECT_INPUT_PROMPT, SWITCH_COLLECT_INPUT_SPEECH, SWITCH_COLLECT_INPUT_SPEECH_DONE, switch_core_session_get_channel(), SWITCH_EVENT_DETECTED_SPEECH, switch_event_get_body(), switch_event_get_header, SWITCH_FALSE, SWITCH_INPUT_TYPE_DTMF, SWITCH_INPUT_TYPE_EVENT, SWITCH_INT64_T_FMT, SWITCH_LOG_DEBUG, SWITCH_LOG_INFO, switch_log_printf(), switch_micro_time_now(), switch_set_flag, SWITCH_STATUS_BREAK, SWITCH_STATUS_SUCCESS, switch_test_flag, SWITCH_TRUE, switch_collect_input_state_t::terminator, switch_collect_input_state_t::terminators, and zstr.

Referenced by switch_ivr_play_and_collect_input().

{
        switch_collect_input_state_t *state = (switch_collect_input_state_t *)data;
        switch_channel_t *channel = switch_core_session_get_channel(session);

        if (switch_test_flag(state, SWITCH_COLLECT_INPUT_SPEECH) && input_type == SWITCH_INPUT_TYPE_EVENT) {
                const char *speech_type = NULL;
                switch_event_t *event = (switch_event_t *)input;

                if (event->event_id != SWITCH_EVENT_DETECTED_SPEECH) return SWITCH_STATUS_SUCCESS;

                speech_type = switch_event_get_header(event, "Speech-Type");

                if (zstr(speech_type)) return SWITCH_STATUS_SUCCESS;

                deliver_asr_event(session, event, state->original_args);

                if (!strcasecmp(speech_type, "detected-speech")) {
                        const char *result = switch_event_get_body(event);

                        /* stop waiting for speech */
                        switch_set_flag(state, SWITCH_COLLECT_INPUT_SPEECH_DONE);

                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "(%s) DETECTED SPEECH %s\n", switch_channel_get_name(channel), speech_type);

                        if (!zstr(result)) {
                                state->recognition_result = cJSON_Parse(result);

                                if (state->recognition_result) {
                                        const char *text = cJSON_GetObjectCstr(state->recognition_result, "text");

                                        if (!zstr(text)) {
                                                /* stop waiting for digits */
                                                switch_set_flag(state, SWITCH_COLLECT_INPUT_DIGITS_DONE);
                                        }
                                }
                        }
                        return SWITCH_STATUS_BREAK;
                } else if (!strcasecmp(speech_type, "detected-partial-speech")) {
                } else if (!strcasecmp("closed", speech_type)) {
                        /* stop waiting for speech */
                        switch_set_flag(state, SWITCH_COLLECT_INPUT_SPEECH_DONE);
                        return SWITCH_STATUS_BREAK;
                } else if (!strcasecmp(speech_type, "begin-speaking")) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "(%s) START OF SPEECH\n", switch_channel_get_name(channel));
                        state->is_speech = SWITCH_TRUE;

                        if (switch_test_flag(state, SWITCH_COLLECT_INPUT_PROMPT)) {
                                /* barge in on prompt */
                                return SWITCH_STATUS_BREAK;
                        }
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Unhandled Speech-Type %s\n", speech_type);
                }
        }

        if (switch_test_flag(state, SWITCH_COLLECT_INPUT_DIGITS) && input_type == SWITCH_INPUT_TYPE_DTMF) {
                switch_dtmf_t *dtmf = (switch_dtmf_t *) input;
                state->last_digit_time = switch_micro_time_now();
                state->is_speech = SWITCH_FALSE;

                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "\nis_speech = false; SWITCH_INPUT_TYPE_DTMF; last_digit_time=%" SWITCH_INT64_T_FMT "\n", state->last_digit_time);

                if (!zstr(state->terminators) && strchr(state->terminators, dtmf->digit)) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "(%s) ACCEPT TERMINATOR %c\n",
                                                          switch_channel_get_name(channel), dtmf->digit);

                        state->terminator = dtmf->digit;

                        /* stop waiting for digits */
                        switch_set_flag(state, SWITCH_COLLECT_INPUT_DIGITS_DONE);

                        if (switch_test_flag(state, SWITCH_COLLECT_INPUT_DIGITS) && !zstr(state->digits)) {
                                /* stop waiting for speech */
                                switch_set_flag(state, SWITCH_COLLECT_INPUT_SPEECH_DONE);
                        }

                        /* barge-in and break playback on terminator */
                        return SWITCH_STATUS_BREAK;
                }

                if (!switch_test_flag(state, SWITCH_COLLECT_INPUT_DIGITS_DONE)) {
                        int digits_collected = strlen(state->digits);

                        if (digits_collected < state->max_digits) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "(%s) ACCEPT DIGIT %c\n",
                                                                  switch_channel_get_name(channel), dtmf->digit);
                                state->digits[digits_collected] = dtmf->digit;
                        }

                        if (digits_collected + 1 >= state->max_digits) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "(%s) MAX DIGITS COLLECTED\n", switch_channel_get_name(channel));
                                switch_set_flag(state, SWITCH_COLLECT_INPUT_DIGITS_DONE); // stop waiting for digits
                                switch_set_flag(state, SWITCH_COLLECT_INPUT_SPEECH_DONE); // stop waiting for speech, too
                        }
                }
                return SWITCH_STATUS_BREAK; // got a digit- break for inter-digit timeout / checking results / barge-in
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_ivr_record_file()

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 1052 of file switch_ivr_play_say.c.

References switch_ivr_record_file_event().

{
        return switch_ivr_record_file_event(session, fh, file, args, limit, NULL);
}

switch_ivr_record_file_event()

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

Definition at line 404 of file switch_ivr_play_say.c.

References switch_codec_implementation::actual_samples_per_second, arg_recursion_check_start, arg_recursion_check_stop, switch_input_args_t::buf, switch_frame::buflen, switch_input_args_t::buflen, CF_BREAK, CF_VIDEO, CF_VIDEO_BLANK, CF_VIDEO_DECODED_READ, CF_VIDEO_ECHO, switch_file_handle::channels, switch_frame::codec, count, switch_frame::data, switch_stream_handle::data, switch_frame::datalen, switch_codec_implementation::decoded_bytes_per_packet, switch_dtmf_t::digit, switch_input_args_t::dmachine, switch_codec_implementation::encoded_bytes_per_packet, switch_vid_params_s::fps, switch_mm_s::fps, get_recording_var(), switch_vid_params_s::height, switch_codec_implementation::iananame, if(), switch_codec::implementation, switch_input_args_t::input_callback, memset(), merge_recording_variables(), switch_codec_implementation::microseconds_per_packet, switch_file_handle::mm, switch_file_handle::native_rate, switch_codec_implementation::number_of_channels, switch_file_handle::params, switch_file_handle::pre_buffer_datalen, switch_file_handle::prefix, switch_input_args_t::read_frame_callback, recording_var_true(), switch_file_handle::samplerate, switch_frame::samples, switch_file_handle::samples, switch_file_handle::samples_out, switch_codec_implementation::samples_per_packet, SCFC_FLUSH_AUDIO, SFF_CNG, switch_file_handle::silence_hits, 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_FILE_SIZE, SWITCH_AUDIO_COL_STR_FILE_TRIMMED, SWITCH_AUDIO_COL_STR_FILE_TRIMMED_MS, SWITCH_AUDIO_COL_STR_SOFTWARE, SWITCH_AUDIO_COL_STR_TITLE, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER, switch_channel_api_on(), switch_channel_clear_flag(), switch_channel_clear_flag_recursive(), switch_channel_dequeue_dtmf(), switch_channel_event_set_data(), switch_channel_execute_on(), switch_channel_execute_on_value(), switch_channel_expand_variables, switch_channel_get_name(), switch_channel_get_variable, switch_channel_hangup, switch_channel_has_dtmf(), switch_channel_media_ready, switch_channel_pre_answer, switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_flag_recursive(), switch_channel_set_variable, switch_channel_set_variable_printf(), switch_channel_test_flag(), switch_clear_flag_locked, SWITCH_CODEC_FLAG_DECODE, SWITCH_CODEC_FLAG_ENCODE, switch_core_codec_destroy(), switch_core_codec_init, switch_core_file_close(), switch_core_file_command(), switch_core_file_get_string(), switch_core_file_has_video(), switch_core_file_open, switch_core_file_pre_close(), switch_core_file_read(), switch_core_file_seek(), switch_core_file_set_string(), switch_core_file_write(), switch_core_media_gen_key_frame, switch_core_media_get_vid_params(), switch_core_media_lock_video_file(), switch_core_media_set_video_file(), switch_core_media_unlock_video_file(), 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_request_video_refresh, switch_core_session_reset(), switch_core_session_set_read_codec(), switch_core_session_sprintf(), switch_core_session_strdup, switch_core_session_wait_for_video_input_params(), 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_get_header, SWITCH_EVENT_RECORD_START, SWITCH_EVENT_RECORD_STOP, SWITCH_FALSE, SWITCH_FILE_DATA_SHORT, SWITCH_FILE_FLAG_READ, SWITCH_FILE_FLAG_VIDEO, SWITCH_FILE_FLAG_VIDEO_EOF, SWITCH_FILE_FLAG_WRITE, SWITCH_FILE_NATIVE, SWITCH_FILE_OPEN, 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_RW_READ, SWITCH_RW_WRITE, 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, switch_file_handle::thresh, switch_input_args_t::user_data, switch_mm_s::vh, switch_mm_s::vw, switch_vid_params_s::width, and write_buf().

Referenced by switch_ivr_record_file().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_dtmf_t dtmf = { 0 };
        switch_file_handle_t lfh = { 0 };
        switch_file_handle_t vfh = { 0 };
        switch_file_handle_t ind_fh = { 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 = 1400, 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, *video_file = NULL;
        int vid_play_file_flags = SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT | SWITCH_FILE_FLAG_VIDEO;
        int echo_on = 0;
        const char *file_trimmed_ms = NULL;
        const char *file_size = NULL;
        const char *file_trimmed = NULL;

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

        if (!file) {
                return SWITCH_STATUS_FALSE;
        }

        prefix = get_recording_var(channel, vars, fh, "sound_prefix");

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

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

        switch_core_session_get_read_impl(session, &read_impl);

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

        arg_recursion_check_start(args);

        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 ((p = get_recording_var(channel, vars, fh, "record_sample_rate"))) {
                int tmp = 0;

                tmp = atoi(p);

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

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

                                while (*file == '{') {
                                        if ((e = switch_find_end_paren(tfile, '{', '}'))) {
                                                *e = '\0';
                                                file = e + 1;
                                                while(*file == ' ') file++;
                                        } else {
                                                tfile = NULL;
                                                break;
                                        }
                                }
                        }

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

        if (asis && read_impl.encoded_bytes_per_packet == 0) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "%s cannot play or record native files with variable length data\n", switch_channel_get_name(channel));
                switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
                arg_recursion_check_stop(args);
                return SWITCH_STATUS_GENERR;
        }


        vval = get_recording_var(channel, vars, fh, "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) || recording_var_true(channel, vars, fh, "RECORD_APPEND")) {
                file_flags |= SWITCH_FILE_WRITE_APPEND;
        }

        if (switch_test_flag(fh, SWITCH_FILE_WRITE_OVER) || recording_var_true(channel, vars, fh, "RECORD_WRITE_OVER")) {
                file_flags |= SWITCH_FILE_WRITE_OVER;
        }

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

        if (switch_channel_test_flag(channel, CF_VIDEO)) {
                switch_vid_params_t vid_params = { 0 };

                file_flags |= SWITCH_FILE_FLAG_VIDEO;
                switch_channel_set_flag_recursive(channel, CF_VIDEO_DECODED_READ);
                switch_core_session_request_video_refresh(session);
                if (switch_core_session_wait_for_video_input_params(session, 10000) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Unable to establish inbound video stream\n");
                        switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
                        arg_recursion_check_stop(args);
                        file_flags &= ~SWITCH_FILE_FLAG_VIDEO;
                } else {
                        switch_core_media_get_vid_params(session, &vid_params);
                        fh->mm.vw = vid_params.width;
                        fh->mm.vh = vid_params.height;
                        fh->mm.fps = vid_params.fps;
                }
        }

        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);
                arg_recursion_check_stop(args);
                return SWITCH_STATUS_GENERR;
        }


        if ((p = get_recording_var(channel, vars, fh, "record_fill_cng"))) {
                if (!strcasecmp(p, "true")) {
                        fill_cng = 1400;
                } else {
                        if ((fill_cng = atoi(p)) < 0) {
                                fill_cng = 0;
                        }
                }
        }

        if ((p = switch_channel_get_variable(channel, "record_indication")) || (fh->params && (p = switch_event_get_header(fh->params, "record_indication")))) {
                int flags = SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT;
                waste_resources = 1400;

                if (switch_core_file_open(&ind_fh,
                                                                  p,
                                                                  read_impl.number_of_channels,
                                                                  read_impl.actual_samples_per_second, flags, NULL) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Indication file invalid\n");
                }
        }

        if ((p = get_recording_var(channel, vars, fh,  "record_waste_resources"))) {

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

        if (fill_cng || waste_resources) {
                if (switch_core_codec_init(&write_codec,
                                                                   "L16",
                                                                   NULL,
                                                                   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 {
                        arg_recursion_check_stop(args);
                        return SWITCH_STATUS_FALSE;
                }
        }



        if (switch_core_file_has_video(fh, SWITCH_TRUE)) {
                switch_core_session_request_video_refresh(session);

                if ((p = get_recording_var(channel, vars, fh, "record_play_video"))) {

                        video_file = switch_core_session_strdup(session, p);

                        if (switch_core_file_open(&vfh, video_file, fh->channels,
                                                                          read_impl.actual_samples_per_second, vid_play_file_flags, NULL) != SWITCH_STATUS_SUCCESS) {
                                memset(&vfh, 0, sizeof(vfh));
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Failure opening video playback file.\n");
                        }

                        if (switch_core_file_has_video(&vfh, SWITCH_TRUE)) {
                                switch_core_media_set_video_file(session, &vfh, SWITCH_RW_WRITE);
                                switch_core_media_gen_key_frame(session);
                        } else {
                                switch_core_file_close(&vfh);
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Video playback file does not contain video\n");
                                memset(&vfh, 0, sizeof(vfh));
                        }
                }

                if (!switch_test_flag(&vfh, SWITCH_FILE_OPEN)) {
                        echo_on = 1;
                        switch_channel_set_flag_recursive(channel, CF_VIDEO_DECODED_READ);
                        switch_channel_set_flag(channel, CF_VIDEO_ECHO);
                }

                switch_core_media_set_video_file(session, fh, SWITCH_RW_READ);
        } else if (switch_channel_test_flag(channel, CF_VIDEO)) {
                switch_channel_set_flag(channel, CF_VIDEO_BLANK);
        }

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


        if (switch_test_flag(fh, SWITCH_FILE_NATIVE)) {
                asis = 1;
        }

        restart_limit_on_dtmf = recording_var_true(channel, vars, fh, "record_restart_limit_on_dtmf");

        if ((p = get_recording_var(channel, vars, fh,  "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 = get_recording_var(channel, vars, fh, "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 = get_recording_var(channel, vars, fh, "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 = get_recording_var(channel, vars, fh,  "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 = get_recording_var(channel, vars, fh, "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 = get_recording_var(channel, vars, fh, "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);
        }


        switch_channel_set_variable(channel, "silence_hits_exhausted", "false");

        if (!asis) {
                codec_name = "L16";
                if (switch_core_codec_init(&codec,
                                                                   codec_name,
                                                                   NULL,
                                                                   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);
                        if (switch_core_file_has_video(fh, SWITCH_FALSE)) {
                                if (echo_on) {
                                        switch_channel_clear_flag(channel, CF_VIDEO_ECHO);
                                        switch_channel_clear_flag_recursive(channel, CF_VIDEO_DECODED_READ);
                                }
                                switch_core_media_set_video_file(session, NULL, SWITCH_RW_READ);
                                switch_core_media_set_video_file(session, NULL, SWITCH_RW_WRITE);
                        }
                        switch_channel_clear_flag(channel, CF_VIDEO_BLANK);
                        switch_core_file_close(fh);

                        switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
                        arg_recursion_check_stop(args);
                        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);
                merge_recording_variables(vars, event);
                switch_event_fire(&event);
        }

        {
                const char *app_exec = NULL;
                if (vars && (app_exec = switch_event_get_header(vars, "execute_on_record_start"))) {
                        switch_channel_execute_on_value(channel, app_exec);
                }
                switch_channel_execute_on(channel, "execute_on_record_start");
                switch_channel_api_on(channel, "api_on_record_start");
        }

        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;
                                switch_status_t ostatus;

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

                                        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 (switch_test_flag(&vfh, SWITCH_FILE_OPEN)) {
                        switch_core_file_command(&vfh, SCFC_FLUSH_AUDIO);

                        if (switch_test_flag(&vfh, SWITCH_FILE_FLAG_VIDEO_EOF)) {

                                //switch_core_media_set_video_file(session, NULL, SWITCH_RW_WRITE);

                                switch_core_media_lock_video_file(session, SWITCH_RW_WRITE);

                                switch_core_file_close(&vfh);
                                memset(&vfh, 0, sizeof(vfh));

                                if (switch_core_file_open(&vfh, video_file, fh->channels,
                                                                                  read_impl.actual_samples_per_second, vid_play_file_flags, NULL) != SWITCH_STATUS_SUCCESS) {
                                        memset(&vfh, 0, sizeof(vfh));
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Failure opening video playback file.\n");
                                }

                                if (switch_core_file_has_video(&vfh, SWITCH_TRUE)) {
                                        //switch_core_media_set_video_file(session, &vfh, SWITCH_RW_WRITE);
                                        switch_core_media_gen_key_frame(session);
                                } else {
                                        switch_core_media_set_video_file(session, NULL, SWITCH_RW_WRITE);
                                        switch_core_file_close(&vfh);
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Video playback file does not contain video\n");
                                        memset(&vfh, 0, sizeof(vfh));
                                }

                                switch_core_media_unlock_video_file(session, SWITCH_RW_WRITE);
                        }

                }

                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 * read_impl.number_of_channels; count++) {
                                energy += abs(fdata[j++]);
                        }

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

                        if (score < fh->thresh) {
                                if (!--fh->silence_hits) {
                                        switch_channel_set_variable(channel, "silence_hits_exhausted", "true");
                                        break;
                                }
                        } else {
                                fh->silence_hits = org_silence_hits;
                        }
                }

                write_frame.datalen = read_impl.decoded_bytes_per_packet;
                write_frame.samples = write_frame.datalen / 2;

                if (switch_test_flag(&ind_fh, SWITCH_FILE_OPEN)) {
                        switch_size_t olen = write_frame.codec->implementation->samples_per_packet;

                        if (switch_core_file_read(&ind_fh, write_frame.data, &olen) == SWITCH_STATUS_SUCCESS) {
                                write_frame.samples = olen;
                                write_frame.datalen = olen * 2 * ind_fh.channels;;
                        } else {
                                switch_core_file_close(&ind_fh);
                        }

                } else if (fill_cng) {
                        switch_generate_sln_silence((int16_t *) write_frame.data, write_frame.samples, read_impl.number_of_channels, fill_cng);
                } else if (waste_resources) {
                        switch_generate_sln_silence((int16_t *) write_frame.data, write_frame.samples, read_impl.number_of_channels, 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 / fh->channels;

                        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 / fh->channels;
                        if (switch_core_file_write(fh, write_frame.data, &len) != SWITCH_STATUS_SUCCESS) {
                                break;
                        }
                }


                if (waste_resources || switch_test_flag(&ind_fh, SWITCH_FILE_OPEN)) {
                        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);
        }

        if (switch_core_file_has_video(fh, SWITCH_FALSE)) {
                if (echo_on) {
                        switch_channel_clear_flag(channel, CF_VIDEO_ECHO);
                        switch_channel_clear_flag_recursive(channel, CF_VIDEO_DECODED_READ);
                }
                switch_core_media_set_video_file(session, NULL, SWITCH_RW_READ);
                switch_core_media_set_video_file(session, NULL, SWITCH_RW_WRITE);
        }
        switch_channel_clear_flag(channel, CF_VIDEO_BLANK);

        switch_core_file_pre_close(fh);
        switch_core_file_get_string(fh, SWITCH_AUDIO_COL_STR_FILE_SIZE, &file_size);
        switch_core_file_get_string(fh, SWITCH_AUDIO_COL_STR_FILE_TRIMMED, &file_trimmed);
        switch_core_file_get_string(fh, SWITCH_AUDIO_COL_STR_FILE_TRIMMED_MS, &file_trimmed_ms);
        if (file_trimmed_ms) {
                switch_channel_set_variable(channel, "record_record_trimmed_ms", file_trimmed_ms);
                switch_channel_set_variable(channel, "record_trimmed_ms", file_trimmed_ms);
        }
        if (file_size) {
                switch_channel_set_variable(channel, "record_record_file_size", file_size);
                switch_channel_set_variable(channel, "record_file_size", file_size);
        }
        if (file_trimmed) {
                switch_channel_set_variable(channel, "record_record_trimmed", file_trimmed);
                switch_channel_set_variable(channel, "record_trimmed", file_trimmed);
        }
        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 && fh->native_rate >= 1000) {
                switch_channel_set_variable_printf(channel, "record_seconds", "%d", fh->samples_out / fh->native_rate);
                switch_channel_set_variable_printf(channel, "record_ms", "%d", fh->samples_out / (fh->native_rate / 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);
                merge_recording_variables(vars, event);
                switch_event_fire(&event);
        }

        {
                const char *app_exec = NULL;
                if (vars && (app_exec = switch_event_get_header(vars, "execute_on_record_stop"))) {
                        switch_channel_execute_on_value(channel, app_exec);
                }
                switch_channel_execute_on(channel, "execute_on_record_stop");
                switch_channel_api_on(channel, "api_on_record_stop");
        }

        switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);

        arg_recursion_check_stop(args);
        return status;
}

teletone_handler()

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

static

Definition at line 1058 of file switch_ivr_play_say.c.

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

Referenced by switch_ivr_gentones().

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