IVR Library

Collaboration diagram for IVR Library:

Modules
	IVR Menu Library

Typedefs
typedef struct switch_ivr_digit_stream_parser	switch_ivr_digit_stream_parser_t
typedef struct switch_ivr_digit_stream	switch_ivr_digit_stream_t

Functions
switch_status_t	switch_ivr_deactivate_unicast (switch_core_session_t *session)
switch_status_t	switch_ivr_activate_unicast (switch_core_session_t *session, char *local_ip, switch_port_t local_port, char *remote_ip, switch_port_t remote_port, char *transport, char *flags)
switch_status_t	switch_ivr_generate_json_cdr (switch_core_session_t *session, cJSON **json_cdr, switch_bool_t urlencode)
	Generate an JSON CDR report. More...
switch_status_t	switch_ivr_generate_xml_cdr (switch_core_session_t *session, switch_xml_t *xml_cdr)
	Generate an XML CDR report. More...
int	switch_ivr_set_xml_profile_data (switch_xml_t xml, switch_caller_profile_t *caller_profile, int off)
int	switch_ivr_set_xml_chan_vars (switch_xml_t xml, switch_channel_t *channel, int off)
switch_status_t	switch_ivr_parse_event (_In_ switch_core_session_t *session, _In_ switch_event_t *event)
	Parse command from an event. More...
switch_status_t	switch_ivr_parse_all_events (switch_core_session_t *session)
	Parse all commands from an event. More...
switch_status_t	switch_ivr_parse_next_event (switch_core_session_t *session)
switch_status_t	switch_ivr_parse_all_messages (switch_core_session_t *session)
switch_status_t	switch_ivr_parse_all_signal_data (switch_core_session_t *session)
switch_status_t	switch_ivr_parse_signal_data (switch_core_session_t *session, switch_bool_t all, switch_bool_t only_session_thread)
switch_status_t	switch_ivr_parse_next_signal_data (switch_core_session_t *session)
switch_status_t	switch_ivr_process_indications (switch_core_session_t *session, switch_core_session_message_t *message)
switch_status_t	switch_ivr_sleep (switch_core_session_t *session, uint32_t ms, switch_bool_t sync, switch_input_args_t *args)
	Wait for time to pass for a specified number of milliseconds. More...
switch_status_t	switch_ivr_park (switch_core_session_t *session, switch_input_args_t *args)
switch_status_t	switch_ivr_collect_digits_callback (switch_core_session_t *session, switch_input_args_t *args, uint32_t digit_timeout, uint32_t abs_timeout)
	Wait for DTMF digits calling a pluggable callback function when digits are collected. More...
switch_status_t	switch_ivr_collect_digits_count (switch_core_session_t *session, char *buf, switch_size_t buflen, switch_size_t maxdigits, const char *terminators, char *terminator, uint32_t first_timeout, uint32_t digit_timeout, uint32_t abs_timeout)
	Wait for specified number of DTMF digits, untile terminator is received or until the channel hangs up. More...
switch_status_t	switch_ivr_play_and_detect_speech (switch_core_session_t *session, const char *file, const char *mod_name, const char *grammar, char **result, uint32_t input_timeout, switch_input_args_t *args)
	play a file to the session while doing speech recognition. More...
switch_status_t	switch_ivr_detect_speech_init (switch_core_session_t *session, const char *mod_name, const char *dest, switch_asr_handle_t *ah)
	Initialize background Speech detection on a session, so that parameters can be set, and grammars loaded. After calling this function, it is possible to call switch_ivr_set_param_detect_speech() to set recognition parameters. Calling switch_ivr_detect_speech_load_grammar() starts the speech recognition. More...
switch_status_t	switch_ivr_detect_speech (switch_core_session_t *session, const char *mod_name, const char *grammar, const char *name, const char *dest, switch_asr_handle_t *ah)
	Engage background Speech detection on a session. More...
switch_status_t	switch_ivr_stop_detect_speech (switch_core_session_t *session)
	Stop background Speech detection on a session. More...
switch_status_t	switch_ivr_pause_detect_speech (switch_core_session_t *session)
	Pause background Speech detection on a session. More...
switch_status_t	switch_ivr_resume_detect_speech (switch_core_session_t *session)
	Resume background Speech detection on a session. More...
switch_status_t	switch_ivr_detect_speech_load_grammar (switch_core_session_t *session, const char *grammar, const char *name)
	Load a grammar on a background speech detection handle. More...
switch_status_t	switch_ivr_detect_speech_unload_grammar (switch_core_session_t *session, const char *name)
	Unload a grammar on a background speech detection handle. More...
switch_status_t	switch_ivr_detect_speech_enable_grammar (switch_core_session_t *session, const char *name)
	Enable a grammar on a background speech detection handle. More...
switch_status_t	switch_ivr_detect_speech_disable_grammar (switch_core_session_t *session, const char *name)
	Disable a grammar on a background speech detection handle. More...
switch_status_t	switch_ivr_detect_speech_disable_all_grammars (switch_core_session_t *session)
	Disable all grammars on a background speech detection handle. More...
switch_status_t	switch_ivr_set_param_detect_speech (switch_core_session_t *session, const char *name, const char *val)
switch_status_t	switch_ivr_detect_speech_start_input_timers (switch_core_session_t *session)
	Start input timers on a background speech detection handle. More...
switch_status_t	switch_ivr_record_session (switch_core_session_t *session, const char *file, uint32_t limit, switch_file_handle_t *fh)
	Record a session to disk. More...
switch_status_t	switch_ivr_record_session_event (switch_core_session_t *session, const char *file, uint32_t limit, switch_file_handle_t *fh, switch_event_t *variables)
switch_status_t	switch_ivr_transfer_recordings (switch_core_session_t *orig_session, switch_core_session_t *new_session)
switch_status_t	switch_ivr_eavesdrop_pop_eavesdropper (switch_core_session_t *session, switch_core_session_t **sessionp)
switch_status_t	switch_ivr_eavesdrop_exec_all (switch_core_session_t *session, const char *app, const char *arg)
switch_status_t	switch_ivr_eavesdrop_update_display (switch_core_session_t *session, const char *name, const char *number)
switch_status_t	switch_ivr_eavesdrop_session (switch_core_session_t *session, const char *uuid, const char *require_group, switch_eavesdrop_flag_t flags)
	Eavesdrop on a another session. More...
switch_status_t	switch_ivr_displace_session (switch_core_session_t *session, const char *file, uint32_t limit, const char *flags)
	displace the media for a session with the audio from a file More...
switch_status_t	switch_ivr_stop_displace_session (switch_core_session_t *session, const char *file)
	Stop displacing a session. More...
switch_status_t	switch_ivr_stop_record_session (switch_core_session_t *session, const char *file)
	Stop Recording a session. More...
switch_status_t	switch_ivr_session_audio (switch_core_session_t *session, const char *cmd, const char *direction, int level)
switch_status_t	switch_ivr_stop_session_audio (switch_core_session_t *session)
switch_status_t	switch_ivr_inband_dtmf_session (switch_core_session_t *session)
	Start looking for DTMF inband. More...
switch_status_t	switch_ivr_stop_inband_dtmf_session (switch_core_session_t *session)
	Stop looking for DTMF inband. More...
switch_status_t	switch_ivr_inband_dtmf_generate_session (switch_core_session_t *session, switch_bool_t read_stream)
	Start generating DTMF inband. More...
switch_status_t	switch_ivr_stop_inband_dtmf_generate_session (switch_core_session_t *session)
	Stop generating DTMF inband. More...
switch_status_t	switch_ivr_session_echo (switch_core_session_t *session, switch_input_args_t *args)
	NEEDDESC - More...
switch_status_t	switch_ivr_stop_tone_detect_session (switch_core_session_t *session)
	Stop looking for TONES. More...
switch_status_t	switch_ivr_tone_detect_session (switch_core_session_t *session, const char *key, const char *tone_spec, const char *flags, time_t timeout, int hits, const char *app, const char *data, switch_tone_detect_callback_t callback)
	Start looking for TONES. More...
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_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_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_gentones (switch_core_session_t *session, const char *script, int32_t loops, switch_input_args_t *args)
switch_status_t	switch_ivr_record_file (_In_ switch_core_session_t *session, _In_ switch_file_handle_t *fh, _In_z_ const char *file, _In_opt_ switch_input_args_t *args, _In_ uint32_t limit)
	record a file from the session to a file More...
switch_status_t	switch_ivr_record_file_event (_In_ switch_core_session_t *session, _In_ switch_file_handle_t *fh, _In_z_ const char *file, _In_opt_ switch_input_args_t *args, _In_ uint32_t limit, switch_event_t *vars)
	record a file from the session to a file More...
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 *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...
switch_status_t	switch_ivr_originate (switch_core_session_t *session, switch_core_session_t **bleg, switch_call_cause_t *cause, const char *bridgeto, uint32_t timelimit_sec, const switch_state_handler_table_t *table, const char *cid_name_override, const char *cid_num_override, switch_caller_profile_t *caller_profile_override, switch_event_t *ovars, switch_originate_flag_t flags, switch_call_cause_t *cancel_cause, switch_dial_handle_t *dh)
	Make an outgoing call. More...
switch_status_t	switch_ivr_enterprise_originate (switch_core_session_t *session, switch_core_session_t **bleg, switch_call_cause_t *cause, const char *bridgeto, uint32_t timelimit_sec, const switch_state_handler_table_t *table, const char *cid_name_override, const char *cid_num_override, switch_caller_profile_t *caller_profile_override, switch_event_t *ovars, switch_originate_flag_t flags, switch_call_cause_t *cancel_cause, switch_dial_handle_list_t *hl)
void	switch_ivr_bridge_display (switch_core_session_t *session, switch_core_session_t *peer_session)
switch_status_t	switch_ivr_multi_threaded_bridge (_In_ switch_core_session_t *session, _In_ switch_core_session_t *peer_session, switch_input_callback_function_t dtmf_callback, void *session_data, void *peer_session_data)
	Bridge Audio from one session to another. More...
switch_status_t	switch_ivr_bridge_bleg (switch_core_session_t *session, switch_core_session_t *peer_session, uint32_t max_wait_ms)
	Bridge leaving b-leg in the control of another thread. Call from b-leg first then call switch_ivr_multi_threaded_bridge on a-leg and b-leg. More...
switch_status_t	switch_ivr_signal_bridge (switch_core_session_t *session, switch_core_session_t *peer_session)
	Bridge Signalling from one session to another. More...
void	switch_ivr_check_hold (switch_core_session_t *session)
switch_status_t	switch_ivr_session_transfer (_In_ switch_core_session_t *session, const char *extension, const char *dialplan, const char *context)
	Transfer an existing session to another location. More...
uint32_t	switch_ivr_schedule_transfer (time_t runtime, const char *uuid, char *extension, char *dialplan, char *context)
	Transfer an existing session to another location in the future. More...
uint32_t	switch_ivr_schedule_hangup (time_t runtime, const char *uuid, switch_call_cause_t cause, switch_bool_t bleg)
	Hangup an existing session in the future. More...
switch_status_t	switch_ivr_uuid_bridge (const char *originator_uuid, const char *originatee_uuid)
	Bridge two existing sessions. More...
switch_status_t	switch_ivr_media (const char *uuid, switch_media_flag_t flags)
	Signal a session to request direct media access to it's remote end. More...
switch_status_t	switch_ivr_3p_media (const char *uuid, switch_media_flag_t flags)
switch_status_t	switch_ivr_nomedia (const char *uuid, switch_media_flag_t flags)
	Signal a session to request indirect media allowing it to exchange media directly with another device. More...
switch_status_t	switch_ivr_3p_nomedia (const char *uuid, switch_media_flag_t flags)
void	switch_ivr_bg_media (const char *uuid, switch_media_flag_t flags, switch_bool_t on, switch_bool_t is3p, uint32_t delay)
switch_status_t	switch_ivr_hold_uuid (const char *uuid, const char *message, switch_bool_t moh)
	Signal the session with a protocol specific hold message. More...
switch_status_t	switch_ivr_hold_toggle_uuid (const char *uuid, const char *message, switch_bool_t moh)
	Toggles channel hold state of session. More...
switch_status_t	switch_ivr_unhold_uuid (const char *uuid)
	Signal the session with a protocol specific unhold message. More...
switch_status_t	switch_ivr_hold (switch_core_session_t *session, const char *message, switch_bool_t moh)
	Signal the session with a protocol specific hold message. More...
switch_status_t	switch_ivr_unhold (switch_core_session_t *session)
	Signal the session with a protocol specific unhold message. More...
uint32_t	switch_ivr_schedule_broadcast (time_t runtime, const char *uuid, const char *path, switch_media_flag_t flags)
	Signal the session to broadcast audio in the future. More...
switch_status_t	switch_ivr_broadcast (const char *uuid, const char *path, switch_media_flag_t flags)
	Signal the session to broadcast audio. More...
void	switch_ivr_broadcast_in_thread (switch_core_session_t *session, const char *app, int flags)
switch_status_t	switch_ivr_transfer_variable (switch_core_session_t *sessa, switch_core_session_t *sessb, char *var)
	Transfer variables from one session to another. More...
switch_status_t	switch_ivr_digit_stream_parser_new (switch_memory_pool_t *pool, switch_ivr_digit_stream_parser_t **parser)
	Create a digit stream parser object. More...
switch_status_t	switch_ivr_digit_stream_parser_destroy (switch_ivr_digit_stream_parser_t *parser)
	Destroy a digit stream parser object. More...
switch_status_t	switch_ivr_digit_stream_new (switch_ivr_digit_stream_parser_t *parser, switch_ivr_digit_stream_t **stream)
	Create a new digit stream object. More...
switch_status_t	switch_ivr_digit_stream_destroy (switch_ivr_digit_stream_t **stream)
	Destroys a digit stream object. More...
switch_status_t	switch_ivr_digit_stream_parser_set_event (switch_ivr_digit_stream_parser_t *parser, char *digits, void *data)
	Set a digit string to action mapping. More...
switch_status_t	switch_ivr_digit_stream_parser_del_event (switch_ivr_digit_stream_parser_t *parser, char *digits)
	Delete a string to action mapping. More...
void *	switch_ivr_digit_stream_parser_feed (switch_ivr_digit_stream_parser_t *parser, switch_ivr_digit_stream_t *stream, char digit)
	Feed digits collected into the stream for event match testing. More...
switch_status_t	switch_ivr_digit_stream_reset (switch_ivr_digit_stream_t *stream)
	Reset the collected digit stream to nothing. More...
switch_status_t	switch_ivr_digit_stream_parser_set_terminator (switch_ivr_digit_stream_parser_t *parser, char digit)
	Set a digit string terminator. More...

Detailed Description

A group of core functions to do IVR related functions designed to be building blocks for a higher level IVR interface.

Typedef Documentation

switch_ivr_digit_stream_parser_t

typedef struct switch_ivr_digit_stream_parser switch_ivr_digit_stream_parser_t

Definition at line 712 of file switch_ivr.h.

switch_ivr_digit_stream_t

typedef struct switch_ivr_digit_stream switch_ivr_digit_stream_t

Definition at line 714 of file switch_ivr.h.

Function Documentation

switch_ivr_3p_media()

switch_status_t switch_ivr_3p_media	(	const char *	uuid,
		switch_media_flag_t	flags
	)

Definition at line 1663 of file switch_ivr.c.

References CF_3P_MEDIA_REQUESTED, CF_BRIDGE_ORIGINATOR, CF_BRIDGED, CF_EARLY_MEDIA, CF_MEDIA_ACK, CF_MEDIA_SET, CF_MEDIA_TRANS, CF_PROXY_MODE, CF_REQ_MEDIA, switch_core_session_message::from, switch_core_session_message::message_id, switch_core_session_message::numeric_arg, SMF_IMMEDIATE, SMF_REBRIDGE, SMF_REPLYONLY_A, SMF_REPLYONLY_B, switch_assert, switch_channel_clear_flag(), switch_channel_clear_state_handler(), switch_channel_get_name(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_variable, switch_channel_test_flag(), switch_channel_wait_for_flag(), switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_receive_message, switch_core_session_rwunlock(), SWITCH_FALSE, switch_ivr_uuid_bridge(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_MESSAGE_INDICATE_3P_MEDIA, SWITCH_MESSAGE_INDICATE_CLEAR_PROGRESS, SWITCH_SIGNAL_BRIDGE_VARIABLE, SWITCH_STATUS_GENERR, SWITCH_STATUS_INUSE, SWITCH_STATUS_SUCCESS, SWITCH_TRUE, and switch_yield.

Referenced by media_thread_run().

{
        const char *other_uuid = NULL;
        switch_channel_t *channel, *other_channel = NULL;
        switch_core_session_t *session, *other_session;
        switch_core_session_message_t msg = { 0 };
        switch_status_t status = SWITCH_STATUS_GENERR;
        uint8_t swap = 0;
        //switch_frame_t *read_frame = NULL;

        msg.message_id = SWITCH_MESSAGE_INDICATE_3P_MEDIA;
        msg.from = __FILE__;

        if ((session = switch_core_session_locate(uuid))) {
                channel = switch_core_session_get_channel(session);

                if (switch_channel_test_flag(channel, CF_MEDIA_TRANS) || !switch_channel_test_flag(channel, CF_PROXY_MODE)) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,  "Operation is invalid\n");
                        switch_core_session_rwunlock(session);
                        return SWITCH_STATUS_INUSE;
                }

                switch_channel_set_flag(channel, CF_MEDIA_TRANS);

                if ((flags & SMF_REBRIDGE) && !switch_channel_test_flag(channel, CF_BRIDGE_ORIGINATOR)) {
                        swap = 1;
                }


                status = SWITCH_STATUS_SUCCESS;

                /* If we had early media in bypass mode before, it is no longer relevant */
                if (switch_channel_test_flag(channel, CF_EARLY_MEDIA)) {
                        switch_core_session_message_t msg2 = { 0 };

                        msg2.message_id = SWITCH_MESSAGE_INDICATE_CLEAR_PROGRESS;
                        msg2.from = __FILE__;
                        switch_core_session_receive_message(session, &msg2);
                }

                if ((flags & SMF_REPLYONLY_A)) {
                        msg.numeric_arg = 1;
                }

                switch_channel_set_flag(channel, CF_3P_MEDIA_REQUESTED);

                if (switch_core_session_receive_message(session, &msg) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Can't re-establsh media on %s\n", switch_channel_get_name(channel));
                        switch_channel_clear_flag(channel, CF_3P_MEDIA_REQUESTED);
                        switch_core_session_rwunlock(session);
                        return SWITCH_STATUS_GENERR;
                }

                if ((flags & SMF_REPLYONLY_B)) {
                        msg.numeric_arg = 1;
                } else {
                        msg.numeric_arg = 0;
                }

                if ((flags & SMF_IMMEDIATE)) {
                        switch_channel_wait_for_flag(channel, CF_REQ_MEDIA, SWITCH_FALSE, 250, NULL);
                        switch_yield(250000);
                } else {
                        switch_channel_wait_for_flag(channel, CF_REQ_MEDIA, SWITCH_FALSE, 10000, NULL);
                        switch_channel_wait_for_flag(channel, CF_MEDIA_ACK, SWITCH_TRUE, 10000, NULL);
                        switch_channel_wait_for_flag(channel, CF_MEDIA_SET, SWITCH_TRUE, 10000, NULL);
                        switch_channel_wait_for_flag(channel, CF_3P_MEDIA_REQUESTED, SWITCH_FALSE, 10000, NULL);
                        //switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
                }

                if ((flags & SMF_REBRIDGE)
                        && (other_uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BRIDGE_VARIABLE))
                        && (other_session = switch_core_session_locate(other_uuid))) {

                        other_channel = switch_core_session_get_channel(other_session);
                        switch_assert(other_channel != NULL);

                        switch_channel_set_flag(other_channel, CF_3P_MEDIA_REQUESTED);
                        switch_channel_set_variable(other_channel, "rtp_secure_media", "optional");

                        switch_core_session_receive_message(other_session, &msg);
                        switch_channel_wait_for_flag(other_channel, CF_REQ_MEDIA, SWITCH_FALSE, 10000, NULL);
                        switch_channel_wait_for_flag(other_channel, CF_MEDIA_ACK, SWITCH_TRUE, 10000, NULL);
                        switch_channel_wait_for_flag(other_channel, CF_MEDIA_SET, SWITCH_TRUE, 10000, NULL);
                        switch_channel_wait_for_flag(other_channel, CF_3P_MEDIA_REQUESTED, SWITCH_FALSE, 10000, NULL);
                        //switch_core_session_read_frame(other_session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
                        switch_channel_clear_state_handler(other_channel, NULL);
                        switch_core_session_rwunlock(other_session);
                }
                if (other_channel) {
                        switch_channel_clear_state_handler(channel, NULL);
                }

                switch_channel_clear_flag(channel, CF_MEDIA_TRANS);
                switch_core_session_rwunlock(session);

                if (other_channel) {
                        if (swap) {
                                switch_ivr_uuid_bridge(other_uuid, uuid);
                        } else {
                                switch_ivr_uuid_bridge(uuid, other_uuid);
                        }
                        switch_channel_wait_for_flag(channel, CF_BRIDGED, SWITCH_TRUE, 1000, NULL);
                        switch_channel_wait_for_flag(other_channel, CF_BRIDGED, SWITCH_TRUE, 1000, NULL);
                }
        }

        return status;
}

switch_ivr_3p_nomedia()

switch_status_t switch_ivr_3p_nomedia	(	const char *	uuid,
		switch_media_flag_t	flags
	)

Definition at line 1881 of file switch_ivr.c.

References CF_3P_NOMEDIA_REQUESTED, CF_3P_NOMEDIA_REQUESTED_BLEG, CF_BRIDGE_ORIGINATOR, CF_MEDIA_ACK, CF_MEDIA_TRANS, CF_PROXY_MODE, CF_REDIRECT, CF_REQ_MEDIA, CF_RESET, CS_HIBERNATE, CS_PARK, switch_core_session_message::from, switch_core_session_message::message_id, SMF_FORCE, SMF_REBRIDGE, switch_core_session_message::string_arg, SWITCH_BRIDGE_VARIABLE, switch_channel_clear_flag(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_state, switch_channel_set_variable, switch_channel_test_flag(), switch_channel_wait_for_flag(), switch_channel_wait_for_state(), switch_core_session_get_channel(), switch_core_session_in_thread(), switch_core_session_locate, switch_core_session_receive_message, switch_core_session_rwunlock(), SWITCH_FALSE, switch_ivr_signal_bridge(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_MESSAGE_INDICATE_3P_NOMEDIA, SWITCH_R_SDP_VARIABLE, SWITCH_STATUS_GENERR, SWITCH_STATUS_INUSE, SWITCH_STATUS_SUCCESS, SWITCH_TRUE, and switch_yield.

Referenced by audio_bridge_thread(), and media_thread_run().

{
        const char *other_uuid;
        switch_channel_t *channel, *other_channel = NULL;
        switch_core_session_t *session, *other_session = NULL;
        switch_core_session_message_t msg = { 0 };
        switch_status_t status = SWITCH_STATUS_GENERR;
        uint8_t swap = 0;

        msg.message_id = SWITCH_MESSAGE_INDICATE_3P_NOMEDIA;
        msg.from = __FILE__;

        if ((session = switch_core_session_locate(uuid))) {
                status = SWITCH_STATUS_SUCCESS;
                channel = switch_core_session_get_channel(session);

                if (switch_channel_test_flag(channel, CF_MEDIA_TRANS) || (!(flags & SMF_FORCE) && switch_channel_test_flag(channel, CF_PROXY_MODE))) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,  "Operation is invalid\n");
                        switch_core_session_rwunlock(session);
                        return SWITCH_STATUS_INUSE;
                }

                switch_channel_set_flag(channel, CF_MEDIA_TRANS);

                if ((flags & SMF_REBRIDGE) && !switch_channel_test_flag(channel, CF_BRIDGE_ORIGINATOR)) {
                        swap = 1;
                }

                if ((flags & SMF_FORCE) || !switch_channel_test_flag(channel, CF_PROXY_MODE)) {
                        if ((flags & SMF_REBRIDGE) && (other_uuid = switch_channel_get_variable(channel, SWITCH_BRIDGE_VARIABLE)) &&
                                (other_session = switch_core_session_locate(other_uuid))) {
                                other_channel = switch_core_session_get_channel(other_session);

                                switch_channel_set_flag(channel, CF_REDIRECT);
                                switch_channel_set_flag(channel, CF_RESET);

                                switch_channel_set_flag(other_channel, CF_RESET);
                                switch_channel_set_flag(other_channel, CF_REDIRECT);

                                switch_channel_set_variable(channel, SWITCH_R_SDP_VARIABLE, NULL);
                                switch_channel_set_flag(channel, CF_3P_NOMEDIA_REQUESTED);
                                switch_core_session_receive_message(session, &msg);

                                if (!switch_core_session_in_thread(session)) {
                                        switch_channel_set_state(channel, CS_PARK);
                                }

                                switch_channel_set_state(other_channel, CS_PARK);

                                if (switch_core_session_in_thread(session)) {
                                        switch_yield(100000);
                                } else {
                                        switch_channel_wait_for_state(other_channel, channel, CS_PARK);
                                }


                                if (!switch_core_session_in_thread(session)) {
                                        switch_channel_wait_for_state(channel, NULL, CS_PARK);
                                }

                                switch_channel_wait_for_flag(channel, CF_REQ_MEDIA, SWITCH_FALSE, 10000, NULL);
                                switch_channel_wait_for_flag(channel, CF_MEDIA_ACK, SWITCH_TRUE, 10000, NULL);
                                switch_channel_wait_for_flag(channel, CF_3P_NOMEDIA_REQUESTED, SWITCH_FALSE, 10000, NULL);

                                msg.string_arg = switch_channel_get_variable(channel, SWITCH_R_SDP_VARIABLE);
                                switch_channel_set_flag(other_channel, CF_3P_NOMEDIA_REQUESTED);
                                switch_channel_set_flag(other_channel, CF_3P_NOMEDIA_REQUESTED_BLEG);


                                switch_core_session_receive_message(other_session, &msg);
                                switch_channel_wait_for_flag(other_channel, CF_REQ_MEDIA, SWITCH_FALSE, 10000, NULL);
                                switch_channel_wait_for_flag(other_channel, CF_MEDIA_ACK, SWITCH_TRUE, 10000, NULL);
                                switch_channel_wait_for_flag(other_channel, CF_3P_NOMEDIA_REQUESTED, SWITCH_FALSE, 10000, NULL);
                        }

                        if (other_channel) {
                                if (swap) {
                                        switch_ivr_signal_bridge(other_session, session);
                                } else {
                                        switch_ivr_signal_bridge(session, other_session);
                                }

                                if (switch_core_session_in_thread(session)) {
                                        switch_yield(100000);
                                } else {
                                        switch_channel_wait_for_state(other_channel, channel, CS_HIBERNATE);
                                }

                                if (!switch_core_session_in_thread(session)) {
                                        switch_channel_wait_for_state(channel, other_channel, CS_HIBERNATE);
                                }
                                switch_core_session_rwunlock(other_session);
                        }
                }

                switch_channel_clear_flag(channel, CF_MEDIA_TRANS);
                switch_core_session_rwunlock(session);
        }



        return status;
}

switch_ivr_activate_unicast()

switch_status_t switch_ivr_activate_unicast	(	switch_core_session_t *	session,
		char *	local_ip,
		switch_port_t	local_port,
		char *	remote_ip,
		switch_port_t	remote_port,
		char *	transport,
		char *	flags
	)

Definition at line 404 of file switch_ivr.c.

References switch_codec_implementation::actual_samples_per_second, switch_frame::buflen, CF_UNICAST, switch_frame::codec, switch_frame::data, fail, switch_unicast_conninfo::flag_mutex, switch_codec::implementation, switch_unicast_conninfo::local_addr, switch_unicast_conninfo::local_ip, switch_unicast_conninfo::local_port, switch_codec_implementation::microseconds_per_packet, switch_unicast_conninfo::read_codec, switch_unicast_conninfo::remote_addr, switch_unicast_conninfo::remote_ip, switch_unicast_conninfo::remote_port, switch_unicast_conninfo::session, switch_unicast_conninfo::socket, SUF_NATIVE, SUF_READY, switch_assert, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_private(), SWITCH_CODEC_FLAG_DECODE, SWITCH_CODEC_FLAG_ENCODE, switch_core_codec_init, switch_core_session_alloc, switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_codec(), switch_core_session_strdup, SWITCH_LOG_CRIT, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, SWITCH_LOG_INFO, switch_log_printf(), switch_mutex_init(), SWITCH_MUTEX_NESTED, switch_set_flag, switch_set_flag_locked, switch_sockaddr_info_get(), switch_socket_bind(), switch_socket_create(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_test_flag, SWITCH_UNSPEC, switch_unicast_conninfo::transport, switch_unicast_conninfo::type, switch_unicast_conninfo::write_frame, and switch_unicast_conninfo::write_frame_data.

Referenced by switch_ivr_parse_event().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_unicast_conninfo_t *conninfo = switch_core_session_alloc(session, sizeof(*conninfo));
        switch_codec_t *read_codec;

        switch_assert(conninfo != NULL);

        conninfo->local_ip = switch_core_session_strdup(session, local_ip);
        conninfo->local_port = local_port;

        conninfo->remote_ip = switch_core_session_strdup(session, remote_ip);
        conninfo->remote_port = remote_port;
        conninfo->session = session;

        if (!strcasecmp(transport, "udp")) {
                conninfo->type = AF_INET;
                conninfo->transport = SOCK_DGRAM;
        } else if (!strcasecmp(transport, "tcp")) {
                conninfo->type = AF_INET;
                conninfo->transport = SOCK_STREAM;
        } else {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid transport %s\n", transport);
                goto fail;
        }

        if (flags) {
                if (strstr(flags, "native")) {
                        switch_set_flag(conninfo, SUF_NATIVE);
                }
        }

        switch_mutex_init(&conninfo->flag_mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));

        read_codec = switch_core_session_get_read_codec(session);

        if (!switch_test_flag(conninfo, SUF_NATIVE)) {
                if (switch_core_codec_init(&conninfo->read_codec,
                                                                   "L16",
                                                                   NULL,
                                                                   NULL,
                                                                   read_codec->implementation->actual_samples_per_second,
                                                                   read_codec->implementation->microseconds_per_packet / 1000,
                                                                   1, 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 Activation Success L16@%uhz 1 channel %dms\n",
                                                          read_codec->implementation->actual_samples_per_second, read_codec->implementation->microseconds_per_packet / 1000);
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Raw Codec Activation Failed L16@%uhz 1 channel %dms\n",
                                                          read_codec->implementation->actual_samples_per_second, read_codec->implementation->microseconds_per_packet / 1000);
                        goto fail;
                }
        }

        conninfo->write_frame.data = conninfo->write_frame_data;
        conninfo->write_frame.buflen = sizeof(conninfo->write_frame_data);
        conninfo->write_frame.codec = switch_test_flag(conninfo, SUF_NATIVE) ? read_codec : &conninfo->read_codec;

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "connect %s:%d->%s:%d\n",
                                          conninfo->local_ip, conninfo->local_port, conninfo->remote_ip, conninfo->remote_port);

        if (switch_sockaddr_info_get(&conninfo->local_addr,
                                                                 conninfo->local_ip, SWITCH_UNSPEC, conninfo->local_port, 0,
                                                                 switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
                goto fail;
        }

        if (switch_sockaddr_info_get(&conninfo->remote_addr,
                                                                 conninfo->remote_ip, SWITCH_UNSPEC, conninfo->remote_port, 0,
                                                                 switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
                goto fail;
        }

        if (switch_socket_create(&conninfo->socket, AF_INET, SOCK_DGRAM, 0, switch_core_session_get_pool(session)) == SWITCH_STATUS_SUCCESS) {
                if (switch_socket_bind(conninfo->socket, conninfo->local_addr) != SWITCH_STATUS_SUCCESS) {
                        goto fail;
                }
        } else {
                goto fail;
        }

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Created unicast connection %s:%d->%s:%d\n",
                                          conninfo->local_ip, conninfo->local_port, conninfo->remote_ip, conninfo->remote_port);
        switch_channel_set_private(channel, "unicast", conninfo);
        switch_channel_set_flag(channel, CF_UNICAST);
        switch_set_flag_locked(conninfo, SUF_READY);
        return SWITCH_STATUS_SUCCESS;

  fail:

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Failure creating unicast connection %s:%d->%s:%d\n",
                                          conninfo->local_ip, conninfo->local_port, conninfo->remote_ip, conninfo->remote_port);
        return SWITCH_STATUS_FALSE;
}

switch_ivr_bg_media()

void switch_ivr_bg_media	(	const char *	uuid,
		switch_media_flag_t	flags,
		switch_bool_t	on,
		switch_bool_t	is3p,
		uint32_t	delay
	)

Definition at line 2121 of file switch_ivr.c.

References media_job_t::delay, media_job_t::flags, switch_thread_data_s::func, media_job_t::is3p, media_thread_run(), switch_thread_data_s::obj, media_job_t::on, pool, switch_thread_data_s::pool, media_job_t::pool, switch_core_alloc, switch_core_new_memory_pool, switch_core_strdup, switch_thread_pool_launch_thread(), and media_job_t::uuid.

Referenced by switch_core_media_toggle_hold().

{
        switch_thread_data_t *td;
        switch_memory_pool_t *pool;
        media_job_t *job;

        switch_core_new_memory_pool(&pool);
        td = switch_core_alloc(pool, sizeof(*td));
        job = switch_core_alloc(pool, sizeof(*job));
        td->func = media_thread_run;
        job->pool = pool;
        job->uuid = switch_core_strdup(pool, uuid);
        job->flags = flags;
        job->on = on;
        job->is3p = is3p;
        job->delay = delay;
        td->obj = job;
        td->pool = pool;
        switch_thread_pool_launch_thread(&td);

}

switch_ivr_bridge_bleg()

switch_status_t switch_ivr_bridge_bleg	(	switch_core_session_t *	session,
		switch_core_session_t *	peer_session,
		uint32_t	max_wait_ms
	)

Bridge leaving b-leg in the control of another thread. Call from b-leg first then call switch_ivr_multi_threaded_bridge on a-leg and b-leg.

Parameters

session

b-leg session

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 1073 of file switch_ivr_bridge.c.

References audio_bridge_on_exchange_media(), CF_ARRANGED_BRIDGE, CF_TRANSFER, switch_assert, switch_channel_clear_flag(), switch_channel_set_flag, switch_channel_test_flag(), switch_channel_wait_for_flag(), switch_core_session_get_channel(), SWITCH_FALSE, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, uuid_bridge_on_hibernate(), uuid_bridge_on_reset(), and uuid_bridge_on_soft_execute().

{
        switch_channel_t *channel;
        switch_channel_t *peer_channel = NULL;
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        switch_assert(session);
        channel = switch_core_session_get_channel(session);
        
        switch_channel_set_flag(channel, CF_ARRANGED_BRIDGE);

        if (peer_session) {
                peer_channel = switch_core_session_get_channel(peer_session);
        }

        status = switch_channel_wait_for_flag(channel, CF_ARRANGED_BRIDGE, SWITCH_FALSE, max_wait_ms, peer_channel);

        if (status == SWITCH_STATUS_FALSE) return status;

        if (switch_channel_test_flag(channel, CF_ARRANGED_BRIDGE)) {
                switch_channel_clear_flag(channel, CF_ARRANGED_BRIDGE);
                return SWITCH_STATUS_FALSE;
        } else {
                switch_channel_t *channel = switch_core_session_get_channel(session);
                if (!switch_channel_test_flag(channel, CF_TRANSFER)) {
                        audio_bridge_on_exchange_media(session);
                }
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_ivr_bridge_display()

void switch_ivr_bridge_display	(	switch_core_session_t *	session,
		switch_core_session_t *	peer_session
	)

Definition at line 336 of file switch_ivr_bridge.c.

References send_display().

Referenced by audio_bridge_thread(), and switch_ivr_signal_bridge().

{

        send_display(session, peer_session);
        send_display(peer_session, session);

}

switch_ivr_broadcast()

switch_status_t switch_ivr_broadcast	(	const char *	uuid,
		const char *	path,
		switch_media_flag_t	flags
	)

Signal the session to broadcast audio.

Parameters

uuid	the uuid of the session to broadcast on
path	the path data of the broadcast "/path/to/file.wav [<timer name>]" or "speak:<engine>|<voice>|<Text to say>"
flags	flags to send to the request (SMF_ECHO_BRIDGED to send the broadcast to both sides of the call)

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 5654 of file switch_ivr_async.c.

References CF_BROADCAST_DROP_MEDIA, CF_PROXY_MODE, SAF_MEDIA_TAP, SMF_ECHO_ALEG, SMF_ECHO_BLEG, SMF_EXEC_INLINE, SMF_HOLD_BLEG, SMF_LOOP, SMF_PRIORITY, SMF_REBRIDGE, switch_assert, switch_channel_get_partner_uuid(), switch_channel_set_flag, switch_channel_test_flag(), switch_core_session_execute_application, switch_core_session_execute_application_get_flags(), switch_core_session_get_app_flags(), switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_queue_private_event(), switch_core_session_rwunlock(), switch_event_add_header(), switch_event_add_header_string(), SWITCH_EVENT_COMMAND, switch_event_create, switch_ivr_media(), switch_safe_free, SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by audio_bridge_thread(), bcast_thread(), meta_on_dtmf(), switch_core_media_toggle_hold(), switch_core_session_send_dtmf(), switch_ivr_hold(), switch_ivr_parse_event(), switch_ivr_soft_hold(), and SWITCH_STANDARD_SCHED_FUNC().

{
        switch_channel_t *channel;
        switch_core_session_t *session;
        switch_event_t *event;
        switch_core_session_t *other_session = NULL;
        const char *other_uuid = NULL;
        char *app = "playback";
        char *cause = NULL;
        char *mypath;
        char *p;
        int app_flags = 0, nomedia = 0;

        switch_assert(path);

        if (!(session = switch_core_session_locate(uuid))) {
                return SWITCH_STATUS_FALSE;
        }

        channel = switch_core_session_get_channel(session);

        mypath = strdup(path);
        switch_assert(mypath);

        if ((p = strchr(mypath, ':')) && *(p + 1) == ':') {
                app = mypath;
                *p++ = '\0';
                *p++ = '\0';
                path = p;
        }

        if (switch_channel_test_flag(channel, CF_PROXY_MODE)) {
                nomedia = 1;
                switch_ivr_media(uuid, SMF_REBRIDGE);
        }

        if ((cause = strchr(app, '!'))) {
                *cause++ = '\0';
                if (!*cause) {
                        cause = "normal_clearing";
                }
        }

        if ((flags & SMF_ECHO_BLEG) && (other_uuid = switch_channel_get_partner_uuid(channel))
                && (other_session = switch_core_session_locate(other_uuid))) {
                if ((flags & SMF_EXEC_INLINE)) {
                        switch_core_session_execute_application_get_flags(other_session, app, path, &app_flags);
                        nomedia = 0;
                } else {
                        switch_core_session_get_app_flags(app, &app_flags);
                        if (switch_event_create(&event, SWITCH_EVENT_COMMAND) == SWITCH_STATUS_SUCCESS) {
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "call-command", "execute");
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "execute-app-name", app);
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "execute-app-arg", path);
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, (flags & SMF_PRIORITY) ? "event-lock-pri" : "event-lock", "true");

                                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "lead-frames", "%d", 5);

                                if ((flags & SMF_LOOP)) {
                                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "loops", "%d", -1);
                                }

                                if ((flags & SMF_HOLD_BLEG)) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "hold-bleg", "true");
                                }

                                switch_core_session_queue_private_event(other_session, &event, (flags & SMF_PRIORITY));
                        }
                }

                switch_core_session_rwunlock(other_session);
                other_session = NULL;
        }

        if ((app_flags & SAF_MEDIA_TAP)) {
                nomedia = 0;
        }

        if ((flags & SMF_ECHO_ALEG)) {
                if ((flags & SMF_EXEC_INLINE)) {
                        switch_core_session_execute_application(session, app, path);
                } else {
                        if (switch_event_create(&event, SWITCH_EVENT_COMMAND) == SWITCH_STATUS_SUCCESS) {
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "call-command", "execute");
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "execute-app-name", app);
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "execute-app-arg", path);
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, (flags & SMF_PRIORITY) ? "event-lock-pri" : "event-lock", "true");
                                switch_event_add_header(event, SWITCH_STACK_BOTTOM, "lead-frames", "%d", 5);

                                if ((flags & SMF_LOOP)) {
                                        switch_event_add_header(event, SWITCH_STACK_BOTTOM, "loops", "%d", -1);
                                }
                                if ((flags & SMF_HOLD_BLEG)) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "hold-bleg", "true");
                                }

                                switch_core_session_queue_private_event(session, &event, (flags & SMF_PRIORITY));

                                if (nomedia)
                                        switch_channel_set_flag(channel, CF_BROADCAST_DROP_MEDIA);
                        }
                }
        }

        if (cause) {
                if (switch_event_create(&event, SWITCH_EVENT_COMMAND) == SWITCH_STATUS_SUCCESS) {
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "call-command", "execute");
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "execute-app-name", "hangup");
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "execute-app-arg", cause);
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, (flags & SMF_PRIORITY) ? "event-lock-pri" : "event-lock", "true");
                        switch_core_session_queue_private_event(session, &event, (flags & SMF_PRIORITY));
                }
        }

        switch_core_session_rwunlock(session);
        switch_safe_free(mypath);

        return SWITCH_STATUS_SUCCESS;
}

switch_ivr_broadcast_in_thread()

void switch_ivr_broadcast_in_thread	(	switch_core_session_t *	session,
		const char *	app,
		int	flags
	)

Definition at line 4540 of file switch_ivr_async.c.

References bch_t::app, bcast_thread(), bch_t::flags, pool, bch_t::session, switch_assert, switch_core_session_alloc, switch_core_session_get_pool(), switch_thread_create(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_detach_set(), switch_threadattr_stacksize_set(), and thread.

Referenced by meta_on_dtmf().

{
        switch_thread_t *thread;
        switch_threadattr_t *thd_attr = NULL;
        switch_memory_pool_t *pool;
        bch_t *bch;

        switch_assert(session);

        pool = switch_core_session_get_pool(session);

        bch = switch_core_session_alloc(session, sizeof(*bch));
        bch->session = session;
        bch->app = app;
        bch->flags = flags;


        switch_threadattr_create(&thd_attr, pool);
        switch_threadattr_detach_set(thd_attr, 1);
        switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
        switch_thread_create(&thread, thd_attr, bcast_thread, bch, pool);
}

switch_ivr_check_hold()

void switch_ivr_check_hold

(

switch_core_session_t *

session

)

Definition at line 2143 of file switch_ivr.c.

References CC_MUTE_VIA_MEDIA_STREAM, CF_ANSWERED, CF_HOLD, switch_core_session_message::from, switch_core_session_message::message_id, SDP_TYPE_REQUEST, switch_channel_test_cap(), switch_channel_test_flag(), switch_core_media_set_smode(), switch_core_session_get_channel(), switch_core_session_media_flow(), switch_core_session_receive_message, switch_ivr_unhold(), SWITCH_MEDIA_FLOW_SENDRECV, SWITCH_MEDIA_TYPE_AUDIO, and SWITCH_MESSAGE_INDICATE_MEDIA_RENEG.

Referenced by switch_ivr_session_transfer(), and switch_ivr_uuid_bridge().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);

        if (switch_channel_test_flag(channel, CF_ANSWERED) && switch_channel_test_cap(channel, CC_MUTE_VIA_MEDIA_STREAM) &&
                switch_core_session_media_flow(session, SWITCH_MEDIA_TYPE_AUDIO) != SWITCH_MEDIA_FLOW_SENDRECV) {
                switch_core_session_message_t msg = { 0 };

                msg.message_id = SWITCH_MESSAGE_INDICATE_MEDIA_RENEG;
                msg.from = __FILE__;

                switch_core_media_set_smode(session, SWITCH_MEDIA_TYPE_AUDIO, SWITCH_MEDIA_FLOW_SENDRECV, SDP_TYPE_REQUEST);
                switch_core_session_receive_message(session, &msg);
        }

        if (switch_channel_test_flag(channel, CF_HOLD)) {
                switch_ivr_unhold(session);
        }
}

switch_ivr_clear_speech_cache()

void switch_ivr_clear_speech_cache

(

switch_core_session_t *

session

)

Definition at line 3008 of file switch_ivr_play_say.c.

References cached_speech_handle::codec, switch_timer::interval, cached_speech_handle::sh, switch_speech_handle::speech_interface, SWITCH_CACHE_SPEECH_HANDLES_OBJ_NAME, switch_channel_get_private(), switch_channel_set_private(), switch_core_codec_destroy(), switch_core_session_get_channel(), switch_core_speech_close(), switch_core_timer_destroy(), SWITCH_SPEECH_FLAG_NONE, and cached_speech_handle::timer.

Referenced by switch_core_session_perform_destroy(), and switch_ivr_speak_text().

{
        cached_speech_handle_t *cache_obj = NULL;
        switch_channel_t *channel = switch_core_session_get_channel(session);

        if ((cache_obj = switch_channel_get_private(channel, SWITCH_CACHE_SPEECH_HANDLES_OBJ_NAME))) {
                switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_NONE;
                if (cache_obj->timer.interval) {
                        switch_core_timer_destroy(&cache_obj->timer);
                }
                if (cache_obj->sh.speech_interface) {
                        switch_core_speech_close(&cache_obj->sh, &flags);
                }
                switch_core_codec_destroy(&cache_obj->codec);
                switch_channel_set_private(channel, SWITCH_CACHE_SPEECH_HANDLES_OBJ_NAME, NULL);
        }
}

switch_ivr_collect_digits_callback()

switch_status_t switch_ivr_collect_digits_callback	(	switch_core_session_t *	session,
		switch_input_args_t *	args,
		uint32_t	digit_timeout,
		uint32_t	abs_timeout
	)

Wait for DTMF digits calling a pluggable callback function when digits are collected.

Parameters

session	the session to read.
args	arguements to pass for callbacks etc
timeout	a timeout in milliseconds

Returns

SWITCH_STATUS_SUCCESS to keep the collection moving.

Definition at line 1225 of file switch_ivr.c.

References arg_recursion_check_start, arg_recursion_check_stop, switch_input_args_t::buf, switch_input_args_t::buflen, CF_BREAK, CF_SERVICE, switch_dtmf_t::digit, switch_input_args_t::dmachine, switch_input_args_t::input_callback, switch_input_args_t::read_frame_callback, switch_channel_clear_flag(), switch_channel_dequeue_dtmf(), switch_channel_has_dtmf(), switch_channel_ready, switch_channel_test_flag(), switch_cond_next(), switch_core_session_dequeue_event(), switch_core_session_get_channel(), switch_core_session_read_frame(), switch_event_destroy(), SWITCH_FALSE, SWITCH_INPUT_TYPE_DTMF, SWITCH_INPUT_TYPE_EVENT, SWITCH_IO_FLAG_NONE, switch_ivr_dmachine_feed(), switch_ivr_dmachine_ping(), switch_ivr_parse_all_events(), switch_micro_time_now(), SWITCH_READ_ACCEPTABLE, SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, SWITCH_STATUS_TIMEOUT, and switch_input_args_t::user_data.

Referenced by CoreSession::collectDigits(), enterprise_originate_ringback_thread(), fs_switch_ivr_collect_digits_callback(), and switch_ivr_soft_hold().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        switch_time_t abs_started = 0, digit_started = 0;
        uint32_t abs_elapsed = 0, digit_elapsed = 0;

        if (!args) {
                return SWITCH_STATUS_GENERR;
        }

        arg_recursion_check_start(args);

        if (abs_timeout) {
                abs_started = switch_micro_time_now();
        }
        if (digit_timeout) {
                digit_started = switch_micro_time_now();
        }

        while (switch_channel_ready(channel)) {
                switch_frame_t *read_frame = NULL;
                switch_event_t *event;
                switch_dtmf_t dtmf = { 0 };

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

                if (abs_timeout) {
                        abs_elapsed = (uint32_t) ((switch_micro_time_now() - abs_started) / 1000);
                        if (abs_elapsed >= abs_timeout) {
                                status = SWITCH_STATUS_TIMEOUT;
                                break;
                        }
                }
                if (digit_timeout) {
                        digit_elapsed = (uint32_t) ((switch_micro_time_now() - digit_started) / 1000);
                        if (digit_elapsed >= digit_timeout) {
                                status = SWITCH_STATUS_TIMEOUT;
                                break;
                        }
                }


                switch_ivr_parse_all_events(session);


                if (switch_channel_has_dtmf(channel)) {
                        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);
                        }

                        if (digit_timeout) {
                                digit_started = switch_micro_time_now();
                        }
                }

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

                if (status != SWITCH_STATUS_SUCCESS) {
                        break;
                }

                if (switch_channel_test_flag(channel, CF_SERVICE)) {
                        switch_cond_next();
                } else {
                        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 (read_frame && args && (args->read_frame_callback)) {
                        if ((status = args->read_frame_callback(session, read_frame, args->user_data)) != SWITCH_STATUS_SUCCESS) {
                                break;
                        }
                }
        }

        arg_recursion_check_stop(args);

        return status;
}

switch_ivr_collect_digits_count()

switch_status_t switch_ivr_collect_digits_count	(	switch_core_session_t *	session,
		char *	buf,
		switch_size_t	buflen,
		switch_size_t	maxdigits,
		const char *	terminators,
		char *	terminator,
		uint32_t	first_timeout,
		uint32_t	digit_timeout,
		uint32_t	abs_timeout
	)

Wait for specified number of DTMF digits, untile terminator is received or until the channel hangs up.

Parameters

session	the session to read.
buf	strig to write to
buflen	max size of buf
maxdigits	max number of digits to read
terminators	digits to end the collection
terminator	actual digit that caused the collection to end (if any)
first_timeout	timeout in ms
digit_timeout	digit timeout in ms
abs_timeout	abs timeout in ms

Returns

SWITCH_STATUS_SUCCESS to keep the collection moving.

Definition at line 1342 of file switch_ivr.c.

References switch_frame::buflen, CF_SERVICE, switch_frame::codec, switch_frame::data, switch_frame::datalen, switch_codec_implementation::decoded_bytes_per_packet, switch_dtmf_t::digit, switch_codec_implementation::microseconds_per_packet, switch_codec_implementation::number_of_channels, switch_frame::samples, switch_codec_implementation::samples_per_second, switch_channel_dequeue_dtmf(), switch_channel_get_variable, switch_channel_has_dtmf(), switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_test_flag(), SWITCH_CODEC_FLAG_DECODE, SWITCH_CODEC_FLAG_ENCODE, switch_cond_next(), switch_core_codec_destroy(), switch_core_codec_init, switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_impl(), switch_core_session_read_frame(), switch_core_session_write_frame(), switch_generate_sln_silence(), SWITCH_IO_FLAG_NONE, switch_ivr_parse_all_events(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_micro_time_now(), SWITCH_READ_ACCEPTABLE, SWITCH_RECOMMENDED_BUFFER_SIZE, switch_safe_free, SWITCH_SEND_SILENCE_WHEN_IDLE_VARIABLE, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, SWITCH_STATUS_TIMEOUT, switch_zmalloc, and zstr.

Referenced by fs_switch_ivr_collect_digits_count(), CoreSession::getDigits(), play_and_collect(), and switch_ivr_read().

{
        switch_size_t i = 0, x = strlen(buf);
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_time_t started = 0, digit_started = 0;
        uint32_t abs_elapsed = 0, digit_elapsed = 0;
        uint32_t eff_timeout = 0;
        switch_frame_t write_frame = { 0 };
        unsigned char *abuf = NULL;
        switch_codec_implementation_t imp = { 0 };
        switch_codec_t codec = { 0 };
        int sval = 0;
        const char *var;


        if (x >= buflen || x >= maxdigits) {
                return SWITCH_STATUS_FALSE;
        }

        if ((var = switch_channel_get_variable(channel, SWITCH_SEND_SILENCE_WHEN_IDLE_VARIABLE)) && (sval = atoi(var))) {
                switch_core_session_get_read_impl(session, &imp);

                if (switch_core_codec_init(&codec,
                                                                   "L16",
                                                                   NULL,
                                                                   NULL,
                                                                   imp.samples_per_second,
                                                                   imp.microseconds_per_packet / 1000,
                                                                   imp.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_ERROR, "Codec Error L16@%uhz %u channels %dms\n",
                                                          imp.samples_per_second, imp.number_of_channels, imp.microseconds_per_packet / 1000);
                        return SWITCH_STATUS_FALSE;
                }


                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Codec Activated L16@%uhz %u channels %dms\n",
                                                  imp.samples_per_second, imp.number_of_channels, imp.microseconds_per_packet / 1000);

                write_frame.codec = &codec;
                switch_zmalloc(abuf, SWITCH_RECOMMENDED_BUFFER_SIZE);
                write_frame.data = abuf;
                write_frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE;
                write_frame.datalen = imp.decoded_bytes_per_packet;
                write_frame.samples = write_frame.datalen / sizeof(int16_t);
        }

        if (terminator != NULL) {
                *terminator = '\0';
        }

        if (!zstr(terminators)) {
                for (i = 0; i < x; i++) {
                        if (strchr(terminators, buf[i]) && terminator != NULL) {
                                *terminator = buf[i];
                                buf[i] = '\0';
                                switch_safe_free(abuf);
                                return SWITCH_STATUS_SUCCESS;
                        }
                }
        }

        if (abs_timeout) {
                started = switch_micro_time_now();
        }

        if (digit_timeout && first_timeout) {
                eff_timeout = first_timeout;
        } else if (digit_timeout && !first_timeout) {
                eff_timeout = digit_timeout;
        } else if (first_timeout) {
                digit_timeout = eff_timeout = first_timeout;
        }


        if (eff_timeout) {
                digit_started = switch_micro_time_now();
        }

        while (switch_channel_ready(channel)) {
                switch_frame_t *read_frame;

                if (abs_timeout) {
                        abs_elapsed = (uint32_t) ((switch_micro_time_now() - started) / 1000);
                        if (abs_elapsed >= abs_timeout) {
                                status = SWITCH_STATUS_TIMEOUT;
                                break;
                        }
                }


                switch_ivr_parse_all_events(session);



                if (eff_timeout) {
                        digit_elapsed = (uint32_t) ((switch_micro_time_now() - digit_started) / 1000);

                        if (digit_elapsed >= eff_timeout) {
                                status = SWITCH_STATUS_TIMEOUT;
                                break;
                        }
                }

                if (switch_channel_has_dtmf(channel)) {
                        switch_dtmf_t dtmf = { 0 };
                        switch_size_t y;

                        if (eff_timeout) {
                                eff_timeout = digit_timeout;
                                digit_started = switch_micro_time_now();
                        }

                        for (y = 0; y <= maxdigits; y++) {
                                if (switch_channel_dequeue_dtmf(channel, &dtmf) != SWITCH_STATUS_SUCCESS) {
                                        break;
                                }

                                if (!zstr(terminators) && strchr(terminators, dtmf.digit) && terminator != NULL) {
                                        *terminator = dtmf.digit;
                                        switch_safe_free(abuf);
                                        return SWITCH_STATUS_SUCCESS;
                                }


                                buf[x++] = dtmf.digit;
                                buf[x] = '\0';

                                if (x >= buflen || x >= maxdigits) {
                                        switch_safe_free(abuf);
                                        return SWITCH_STATUS_SUCCESS;
                                }
                        }
                }

                if (switch_channel_test_flag(channel, CF_SERVICE)) {
                        switch_cond_next();
                } else {
                        status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
                        if (!SWITCH_READ_ACCEPTABLE(status)) {
                                break;
                        }

                        if (write_frame.data) {
                                switch_generate_sln_silence((int16_t *) write_frame.data, write_frame.samples, imp.number_of_channels, sval);
                                switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0);
                        }

                }
        }

        if (write_frame.codec) {
                switch_core_codec_destroy(&codec);
        }

        switch_safe_free(abuf);

        return status;
}

switch_ivr_deactivate_unicast()

switch_status_t switch_ivr_deactivate_unicast

(

switch_core_session_t *

session

)

Definition at line 371 of file switch_ivr.c.

References CF_UNICAST, switch_unicast_conninfo::read_codec, switch_unicast_conninfo::socket, SUF_READY, SUF_THREAD_RUNNING, switch_channel_clear_flag(), switch_channel_get_private(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_test_flag(), switch_clear_flag_locked, switch_core_codec_destroy(), switch_core_codec_ready(), switch_core_session_get_channel(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_SHUTDOWN_READWRITE, switch_socket_close(), switch_socket_shutdown(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_test_flag, switch_thread_join(), switch_yield, and switch_unicast_conninfo::thread.

Referenced by switch_core_session_perform_destroy(), switch_core_session_reset(), and switch_ivr_park().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_unicast_conninfo_t *conninfo;
        int sanity = 0;

        if (!switch_channel_test_flag(channel, CF_UNICAST)) {
                return SWITCH_STATUS_FALSE;
        }

        if ((conninfo = switch_channel_get_private(channel, "unicast"))) {
                switch_status_t st;

                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Shutting down unicast connection\n");
                switch_clear_flag_locked(conninfo, SUF_READY);
                switch_socket_shutdown(conninfo->socket, SWITCH_SHUTDOWN_READWRITE);
                switch_thread_join(&st, conninfo->thread);

                while (switch_test_flag(conninfo, SUF_THREAD_RUNNING)) {
                        switch_yield(10000);
                        if (++sanity >= 10000) {
                                break;
                        }
                }
                if (switch_core_codec_ready(&conninfo->read_codec)) {
                        switch_core_codec_destroy(&conninfo->read_codec);
                }
                switch_socket_close(conninfo->socket);
        }
        switch_channel_clear_flag(channel, CF_UNICAST);
        return SWITCH_STATUS_SUCCESS;
}

switch_ivr_detect_audio()

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
	)

Definition at line 2235 of file switch_ivr_play_say.c.

References switch_codec_implementation::actual_samples_per_second, switch_frame::buflen, switch_file_handle::channels, switch_frame::codec, count, switch_frame::data, switch_frame::datalen, switch_codec::implementation, switch_codec_implementation::microseconds_per_packet, switch_codec_implementation::number_of_channels, switch_frame::samples, switch_codec_implementation::samples_per_packet, switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_channel_set_variable_printf(), 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_read(), 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_write_frame(), SWITCH_FALSE, SWITCH_FILE_DATA_SHORT, SWITCH_FILE_FLAG_READ, SWITCH_IO_FLAG_NONE, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_READ_ACCEPTABLE, SWITCH_RECOMMENDED_BUFFER_SIZE, SWITCH_STATUS_FALSE, SWITCH_STATUS_NOTFOUND, SWITCH_STATUS_SUCCESS, SWITCH_TRUE, and switch_zmalloc.

{
        uint32_t score, count = 0, j = 0;
        double energy = 0;
        switch_channel_t *channel = switch_core_session_get_channel(session);
        int divisor = 0;
        uint32_t channels;
        switch_frame_t *read_frame;
        switch_status_t status = SWITCH_STATUS_FALSE;
        int16_t *data;
        uint32_t hits = 0;
        switch_codec_t raw_codec = { 0 };
        int16_t *abuf = NULL;
        switch_frame_t write_frame = { 0 };
        switch_file_handle_t fh = { 0 };
        int32_t sample_count = 0;
        switch_codec_implementation_t read_impl = { 0 };
        switch_core_session_get_read_impl(session, &read_impl);

        if (timeout_ms) {
                sample_count = (read_impl.actual_samples_per_second / 1000) * timeout_ms;
        }

        if (file) {
                if (switch_core_file_open(&fh,
                                                                  file,
                                                                  read_impl.number_of_channels,
                                                                  read_impl.actual_samples_per_second, SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, NULL) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Failure opening playback file %s.\n", file);
                        switch_core_session_reset(session, SWITCH_TRUE, SWITCH_FALSE);
                        return SWITCH_STATUS_NOTFOUND;
                }
                switch_zmalloc(abuf, SWITCH_RECOMMENDED_BUFFER_SIZE);
                write_frame.data = abuf;
                write_frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE;
        }


        if (switch_core_codec_init(&raw_codec,
                                                           "L16",
                                                           NULL,
                                                           NULL,
                                                           read_impl.actual_samples_per_second,
                                                           read_impl.microseconds_per_packet / 1000,
                                                           1, 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_WARNING, "Failed to initialize L16 codec.\n");
                status = SWITCH_STATUS_FALSE;
                goto end;
        }

        write_frame.codec = &raw_codec;

        divisor = read_impl.actual_samples_per_second / 8000;
        channels = read_impl.number_of_channels;

        switch_core_session_set_read_codec(session, &raw_codec);

        while (switch_channel_ready(channel)) {

                status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);

                if (!SWITCH_READ_ACCEPTABLE(status)) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Failed to read frame.\n");
                        break;
                }

                if (sample_count) {
                        sample_count -= raw_codec.implementation->samples_per_packet;
                        if (sample_count <= 0) {
                                switch_channel_set_variable(channel, "detect_audio_timeout", "true");
                                switch_channel_set_variable_printf(channel, "detect_audio_hits", "%d", hits);
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                  "switch_ivr_detect_audio: TIMEOUT after %d ms at %d hits\n",
                                  timeout_ms, hits);
                                break;
                        }
                }

                if (abuf) {
                        switch_size_t olen = raw_codec.implementation->samples_per_packet;

                        if (switch_core_file_read(&fh, abuf, &olen) != SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Failed to read file %s.\n", file);
                                break;
                        }

                        write_frame.samples = (uint32_t) olen;
                        write_frame.datalen = (uint32_t) (olen * sizeof(int16_t) * fh.channels);
                        if ((status = switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0)) != SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Failed to write frame from file %s.\n", file);
                                break;
                        }
                }

                data = (int16_t *) read_frame->data;

                for (energy = 0, j = 0, count = 0; count < read_frame->samples; count++) {
                        energy += abs(data[j++]);
                        j += channels;
                }

                score = (uint32_t) (energy / (read_frame->samples / divisor));

                if (score >= thresh) {
                        hits++;
                } else {
                        hits=0;
                }

                if (hits > audio_hits) {
                        switch_channel_set_variable(channel, "detect_audio_timeout", "false");
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "switch_ivr_detect_audio: AUDIO DETECTED\n");
                        break;
                }
        }

        switch_core_session_reset(session, SWITCH_FALSE, SWITCH_TRUE);
        switch_core_codec_destroy(&raw_codec);

  end:

        if (abuf) {

                switch_core_file_close(&fh);
                free(abuf);
        }

        return status;
}

switch_ivr_detect_silence()

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
	)

Definition at line 2368 of file switch_ivr_play_say.c.

References switch_codec_implementation::actual_samples_per_second, switch_frame::buflen, switch_file_handle::channels, switch_frame::codec, count, switch_frame::data, switch_frame::datalen, switch_codec::implementation, switch_codec_implementation::microseconds_per_packet, switch_codec_implementation::number_of_channels, switch_frame::samples, switch_codec_implementation::samples_per_packet, switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_channel_set_variable_printf(), 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_read(), 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_write_frame(), SWITCH_FALSE, SWITCH_FILE_DATA_SHORT, SWITCH_FILE_FLAG_READ, SWITCH_IO_FLAG_NONE, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_READ_ACCEPTABLE, SWITCH_RECOMMENDED_BUFFER_SIZE, SWITCH_STATUS_FALSE, SWITCH_STATUS_NOTFOUND, SWITCH_STATUS_SUCCESS, SWITCH_TRUE, and switch_zmalloc.

{
        uint32_t score, count = 0, j = 0;
        double energy = 0;
        switch_channel_t *channel = switch_core_session_get_channel(session);
        int divisor = 0;
        uint32_t channels;
        switch_frame_t *read_frame;
        switch_status_t status = SWITCH_STATUS_FALSE;
        int16_t *data;
        uint32_t hits = 0;
        switch_codec_t raw_codec = { 0 };
        int16_t *abuf = NULL;
        switch_frame_t write_frame = { 0 };
        switch_file_handle_t fh = { 0 };
        int32_t sample_count = 0;
        switch_codec_implementation_t read_impl = { 0 };
        switch_core_session_get_read_impl(session, &read_impl);


        if (timeout_ms) {
                sample_count = (read_impl.actual_samples_per_second / 1000) * timeout_ms;
        }

        if (file) {
                if (switch_core_file_open(&fh,
                                                                  file,
                                                                  read_impl.number_of_channels,
                                                                  read_impl.actual_samples_per_second, SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, NULL) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Failure opening playback file %s.\n", file);
                        switch_core_session_reset(session, SWITCH_TRUE, SWITCH_FALSE);
                        return SWITCH_STATUS_NOTFOUND;
                }
                switch_zmalloc(abuf, SWITCH_RECOMMENDED_BUFFER_SIZE);
                write_frame.data = abuf;
                write_frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE;
        }


        if (switch_core_codec_init(&raw_codec,
                                                           "L16",
                                                           NULL,
                                                           NULL,
                                                           read_impl.actual_samples_per_second,
                                                           read_impl.microseconds_per_packet / 1000,
                                                           1, 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_WARNING, "Failed to initialize L16 codec.\n");
                status = SWITCH_STATUS_FALSE;
                goto end;
        }

        write_frame.codec = &raw_codec;

        divisor = read_impl.actual_samples_per_second / 8000;
        channels = read_impl.number_of_channels;

        switch_core_session_set_read_codec(session, &raw_codec);

        while (switch_channel_ready(channel)) {

                status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);

                if (!SWITCH_READ_ACCEPTABLE(status)) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Failed to read frame.\n");
                        break;
                }

                if (sample_count) {
                        sample_count -= raw_codec.implementation->samples_per_packet;
                        if (sample_count <= 0) {
                                switch_channel_set_variable(channel, "detect_silence_timeout", "true");
                                switch_channel_set_variable_printf(channel, "detect_silence_hits", "%d", hits);
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                  "switch_ivr_detect_silence: TIMEOUT after %d ms at %d hits\n",
                                  timeout_ms, hits);
                                break;
                        }
                }

                if (abuf) {
                        switch_size_t olen = raw_codec.implementation->samples_per_packet;

                        if (switch_core_file_read(&fh, abuf, &olen) != SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Failed to read file %s.\n", file);
                                break;
                        }

                        write_frame.samples = (uint32_t) olen;
                        write_frame.datalen = (uint32_t) (olen * sizeof(int16_t) * fh.channels);
                        if ((status = switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0)) != SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Failed to write frame from file %s.\n", file);
                                break;
                        }
                }

                data = (int16_t *) read_frame->data;

                for (energy = 0, j = 0, count = 0; count < read_frame->samples; count++) {
                        energy += abs(data[j++]);
                        j += channels;
                }

                score = (uint32_t) (energy / (read_frame->samples / divisor));

                if (score <= thresh) {
                        hits++;
                } else {
                        hits=0;
                }

                if (hits > silence_hits) {
                        switch_channel_set_variable(channel, "detect_silence_timeout", "false");
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "switch_ivr_detect_silence: SILENCE DETECTED\n");
                        break;
                }
        }

        switch_core_session_reset(session, SWITCH_FALSE, SWITCH_TRUE);
        switch_core_codec_destroy(&raw_codec);

  end:

        if (abuf) {

                switch_core_file_close(&fh);
                free(abuf);
        }

        return status;
}

switch_ivr_detect_speech()

switch_status_t switch_ivr_detect_speech	(	switch_core_session_t *	session,
		const char *	mod_name,
		const char *	grammar,
		const char *	name,
		const char *	dest,
		switch_asr_handle_t *	ah
	)

Engage background Speech detection on a session.

Parameters

session	the session to attach
mod_name	the module name of the ASR library
grammar	the grammar text, URI, or local file name
name	the grammar name
dest	the destination address
ah	an ASR handle to use (NULL to create one)

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 5461 of file switch_ivr_async.c.

References speech_thread_handle::ah, asr_set_json_text_params(), SWITCH_ASR_FLAG_FIRE_EVENTS, switch_channel_get_private(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_core_asr_load_grammar(), switch_core_session_get_channel(), switch_ivr_detect_speech_init(), switch_ivr_resume_detect_speech(), switch_ivr_stop_detect_speech(), SWITCH_LOG_DEBUG, switch_log_printf(), switch_set_flag, SWITCH_SPEECH_KEY, SWITCH_STATUS_FALSE, SWITCH_STATUS_NOT_INITALIZED, SWITCH_STATUS_SUCCESS, and switch_true().

Referenced by CoreSession::detectSpeech(), switch_ivr_play_and_collect_input(), and switch_ivr_play_and_detect_speech().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);
        const char *p;
        int resume = 0;


        if (!sth) {
                /* No speech thread handle available yet, init speech detection first. */
                if (switch_ivr_detect_speech_init(session, mod_name, dest, ah) != SWITCH_STATUS_SUCCESS) {
                        return SWITCH_STATUS_NOT_INITALIZED;
                }

                /* Fetch the new speech thread handle */
                if (!(sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY))) {
                        return SWITCH_STATUS_NOT_INITALIZED;
                }
        } else {
                resume = 1;
        }

        asr_set_json_text_params(session, sth->ah);

        if (switch_core_asr_load_grammar(sth->ah, grammar, name) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Error loading Grammar\n");
                switch_ivr_stop_detect_speech(session);
                return SWITCH_STATUS_FALSE;
        }

        if (resume) {
                switch_ivr_resume_detect_speech(session);
        }

        if ((p = switch_channel_get_variable(channel, "fire_asr_events")) && switch_true(p)) {
                switch_set_flag(sth->ah, SWITCH_ASR_FLAG_FIRE_EVENTS);
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_ivr_detect_speech_disable_all_grammars()

switch_status_t switch_ivr_detect_speech_disable_all_grammars

(

switch_core_session_t *

session

)

Disable all grammars on a background speech detection handle.

Parameters

session

The session to change the grammar on

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 5359 of file switch_ivr_async.c.

References speech_thread_handle::ah, switch_channel_get_private(), SWITCH_CHANNEL_SESSION_LOG, switch_core_asr_disable_all_grammars(), switch_core_session_get_channel(), switch_ivr_stop_detect_speech(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_SPEECH_KEY, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by CoreSession::detectSpeech().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);
        switch_status_t status;

        if (sth) {
                if ((status = switch_core_asr_disable_all_grammars(sth->ah)) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Error disabling all Grammars\n");
                        switch_ivr_stop_detect_speech(session);
                }
                return status;
        }
        return SWITCH_STATUS_FALSE;
}

switch_ivr_detect_speech_disable_grammar()

switch_status_t switch_ivr_detect_speech_disable_grammar	(	switch_core_session_t *	session,
		const char *	name
	)

Disable a grammar on a background speech detection handle.

Parameters

session	The session to change the grammar on
name	the grammar name

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 5343 of file switch_ivr_async.c.

References speech_thread_handle::ah, switch_channel_get_private(), SWITCH_CHANNEL_SESSION_LOG, switch_core_asr_disable_grammar(), switch_core_session_get_channel(), switch_ivr_stop_detect_speech(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_SPEECH_KEY, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by CoreSession::detectSpeech().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);
        switch_status_t status;

        if (sth) {
                if ((status = switch_core_asr_disable_grammar(sth->ah, name)) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Error disabling Grammar\n");
                        switch_ivr_stop_detect_speech(session);
                }
                return status;
        }
        return SWITCH_STATUS_FALSE;
}

switch_ivr_detect_speech_enable_grammar()

switch_status_t switch_ivr_detect_speech_enable_grammar	(	switch_core_session_t *	session,
		const char *	name
	)

Enable a grammar on a background speech detection handle.

Parameters

session	The session to change the grammar on
name	the grammar name

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 5327 of file switch_ivr_async.c.

References speech_thread_handle::ah, switch_channel_get_private(), SWITCH_CHANNEL_SESSION_LOG, switch_core_asr_enable_grammar(), switch_core_session_get_channel(), switch_ivr_stop_detect_speech(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_SPEECH_KEY, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by CoreSession::detectSpeech().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);
        switch_status_t status;

        if (sth) {
                if ((status = switch_core_asr_enable_grammar(sth->ah, name)) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Error enabling Grammar\n");
                        switch_ivr_stop_detect_speech(session);
                }
                return status;
        }
        return SWITCH_STATUS_FALSE;
}

switch_ivr_detect_speech_init()

switch_status_t switch_ivr_detect_speech_init	(	switch_core_session_t *	session,
		const char *	mod_name,
		const char *	dest,
		switch_asr_handle_t *	ah
	)

Initialize background Speech detection on a session, so that parameters can be set, and grammars loaded. After calling this function, it is possible to call switch_ivr_set_param_detect_speech() to set recognition parameters. Calling switch_ivr_detect_speech_load_grammar() starts the speech recognition.

Parameters

session	the session to attach
mod_name	the module name of the ASR library
dest	the destination address
ah	an ASR handle to use (NULL to create one)

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 5375 of file switch_ivr_async.c.

References switch_codec_implementation::actual_samples_per_second, speech_thread_handle::ah, speech_thread_handle::bug, switch_ivr_dmachine_binding::key, speech_thread_handle::pool, speech_thread_handle::session, SMBF_NO_PAUSE, SMBF_READ_STREAM, speech_callback(), speech_on_dtmf(), SWITCH_ASR_FLAG_FIRE_EVENTS, SWITCH_ASR_FLAG_NONE, switch_channel_get_private(), switch_channel_get_variable, switch_channel_set_private(), switch_core_asr_close(), switch_core_asr_open(), switch_core_media_bug_add(), switch_core_session_alloc, switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_impl(), switch_ivr_stop_detect_speech(), switch_set_flag, switch_snprintf(), SWITCH_SPEECH_KEY, SWITCH_STATUS_MEMERR, SWITCH_STATUS_SUCCESS, and switch_true().

Referenced by CoreSession::detectSpeech(), and switch_ivr_detect_speech().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_status_t status;
        switch_asr_flag_t flags = SWITCH_ASR_FLAG_NONE;
        struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);
        switch_codec_implementation_t read_impl = { 0 };
        const char *p;
        char key[512] = "";

        if (sth) {
                /* Already initialized */
                return SWITCH_STATUS_SUCCESS;
        }

        if (!ah) {
                if (!(ah = switch_core_session_alloc(session, sizeof(*ah)))) {
                        return SWITCH_STATUS_MEMERR;
                }
        }

        switch_core_session_get_read_impl(session, &read_impl);

        if ((status = switch_core_asr_open(ah,
                                                                           mod_name,
                                                                           "L16",
                                                                           read_impl.actual_samples_per_second, dest, &flags,
                                                                           switch_core_session_get_pool(session))) != SWITCH_STATUS_SUCCESS) {
                return status;
        }

        sth = switch_core_session_alloc(session, sizeof(*sth));
        sth->pool = switch_core_session_get_pool(session);
        sth->session = session;
        sth->ah = ah;

        if ((p = switch_channel_get_variable(channel, "fire_asr_events")) && switch_true(p)) {
                switch_set_flag(ah, SWITCH_ASR_FLAG_FIRE_EVENTS);
        }

        switch_snprintf(key, sizeof(key), "%s/%s/%s/%s", mod_name, NULL, NULL, dest);

        if ((status = switch_core_media_bug_add(session, "detect_speech", key,
                                                                                        speech_callback, sth, 0, SMBF_READ_STREAM | SMBF_NO_PAUSE, &sth->bug)) != SWITCH_STATUS_SUCCESS) {
                switch_core_asr_close(ah, &flags);
                return status;
        }

        if ((status = switch_core_event_hook_add_recv_dtmf(session, speech_on_dtmf)) != SWITCH_STATUS_SUCCESS) {
                switch_ivr_stop_detect_speech(session);
                return status;
        }

        switch_channel_set_private(channel, SWITCH_SPEECH_KEY, sth);

        return SWITCH_STATUS_SUCCESS;
}

switch_ivr_detect_speech_load_grammar()

switch_status_t switch_ivr_detect_speech_load_grammar	(	switch_core_session_t *	session,
		const char *	grammar,
		const char *	name
	)

Load a grammar on a background speech detection handle.

Parameters

session	The session to change the grammar on
grammar	the grammar text, URI, or local file name
name	the grammar name

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 5270 of file switch_ivr_async.c.

References speech_thread_handle::ah, switch_channel_get_private(), SWITCH_CHANNEL_SESSION_LOG, switch_core_asr_load_grammar(), switch_core_session_get_channel(), switch_ivr_stop_detect_speech(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_SPEECH_KEY, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by CoreSession::detectSpeech().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);
        switch_status_t status;

        if (sth) {
                if ((status = switch_core_asr_load_grammar(sth->ah, grammar, name)) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Error loading Grammar\n");
                        switch_ivr_stop_detect_speech(session);
                }
                return status;
        }
        return SWITCH_STATUS_FALSE;
}

switch_ivr_detect_speech_start_input_timers()

switch_status_t switch_ivr_detect_speech_start_input_timers

(

switch_core_session_t *

session

)

Start input timers on a background speech detection handle.

Parameters

session

The session to start the timers on

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 5299 of file switch_ivr_async.c.

References speech_thread_handle::ah, switch_channel_get_private(), switch_core_asr_start_input_timers(), switch_core_session_get_channel(), SWITCH_SPEECH_KEY, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by CoreSession::detectSpeech(), switch_ivr_play_and_collect_input(), and switch_ivr_play_and_detect_speech().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);

        if (sth) {
                switch_core_asr_start_input_timers(sth->ah);
                return SWITCH_STATUS_SUCCESS;
        }
        return SWITCH_STATUS_FALSE;
}

switch_ivr_detect_speech_unload_grammar()

switch_status_t switch_ivr_detect_speech_unload_grammar	(	switch_core_session_t *	session,
		const char *	name
	)

Unload a grammar on a background speech detection handle.

Parameters

session	The session to change the grammar on
name	the grammar name

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 5311 of file switch_ivr_async.c.

References speech_thread_handle::ah, switch_channel_get_private(), SWITCH_CHANNEL_SESSION_LOG, switch_core_asr_unload_grammar(), switch_core_session_get_channel(), switch_ivr_stop_detect_speech(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_SPEECH_KEY, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by CoreSession::detectSpeech().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);
        switch_status_t status;

        if (sth) {
                if ((status = switch_core_asr_unload_grammar(sth->ah, name)) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Error unloading Grammar\n");
                        switch_ivr_stop_detect_speech(session);
                }
                return status;
        }
        return SWITCH_STATUS_FALSE;
}

switch_ivr_digit_stream_destroy()

switch_status_t switch_ivr_digit_stream_destroy

(

switch_ivr_digit_stream_t **

stream

)

Destroys a digit stream object.

Parameters

stream

a pointer to the stream object

Returns

NULL if no match found or consumer data that was associated with a given digit string when matched

Definition at line 2447 of file switch_ivr.c.

References switch_safe_free, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (*stream) {
                switch_safe_free((*stream)->digits);
                free(*stream);
                *stream = NULL;
                status = SWITCH_STATUS_SUCCESS;
        }

        return status;
}

switch_ivr_digit_stream_new()

switch_status_t switch_ivr_digit_stream_new	(	switch_ivr_digit_stream_parser_t *	parser,
		switch_ivr_digit_stream_t **	stream
	)

Create a new digit stream object.

Parameters

parser	a pointer to the parser object created by switch_ivr_digit_stream_parser_new
stream	a pointer to the stream object pointer

Returns

NULL if no match found or consumer data that was associated with a given digit string when matched

Definition at line 2431 of file switch_ivr.c.

References switch_ivr_digit_stream_parser::buflen, memset(), switch_assert, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_zmalloc.

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        /* if we have a parser object memory pool and a stream object pointer that is null */
        if (parser && stream && *stream == NULL) {
                *stream = (switch_ivr_digit_stream_t *) malloc(sizeof(**stream));
                switch_assert(*stream);
                memset(*stream, 0, sizeof(**stream));
                switch_zmalloc((*stream)->digits, parser->buflen + 1);
                status = SWITCH_STATUS_SUCCESS;
        }

        return status;
}

switch_ivr_digit_stream_parser_del_event()

switch_status_t switch_ivr_digit_stream_parser_del_event	(	switch_ivr_digit_stream_parser_t *	parser,
		char *	digits
	)

Delete a string to action mapping.

Parameters

parser	a pointer to the parser object created by switch_ivr_digit_stream_parser_new
digits	the digit string to be removed from the map

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 2503 of file switch_ivr.c.

References switch_ivr_digit_stream_parser::hash, SWITCH_CHANNEL_LOG, switch_core_hash_delete(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (parser != NULL && digits != NULL && *digits) {
                status = switch_core_hash_delete(parser->hash, digits) ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
        }

        if (status != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "unable to del hash for '%s'\n", digits);
        }

        return status;
}

switch_ivr_digit_stream_parser_destroy()

switch_status_t switch_ivr_digit_stream_parser_destroy

(

switch_ivr_digit_stream_parser_t *

parser

)

Destroy a digit stream parser object.

Parameters

parser

a pointer to the parser object

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 2413 of file switch_ivr.c.

References switch_ivr_digit_stream_parser::hash, switch_ivr_digit_stream_parser::pool, switch_ivr_digit_stream_parser::pool_auto_created, switch_core_destroy_memory_pool, switch_core_hash_destroy(), and SWITCH_STATUS_FALSE.

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (parser != NULL) {
                if (parser->hash != NULL) {
                        switch_core_hash_destroy(&parser->hash);
                        parser->hash = NULL;
                }
                /* free the memory pool if we created it */
                if (parser->pool_auto_created && parser->pool != NULL) {
                        status = switch_core_destroy_memory_pool(&parser->pool);
                }
        }

        return status;
}

switch_ivr_digit_stream_parser_feed()

void* switch_ivr_digit_stream_parser_feed	(	switch_ivr_digit_stream_parser_t *	parser,
		switch_ivr_digit_stream_t *	stream,
		char	digit
	)

Feed digits collected into the stream for event match testing.

Parameters

parser	a pointer to the parser object created by switch_ivr_digit_stream_parser_new
stream	a stream to write data to
digit	a digit to collect and test against the map of digit strings

Returns

NULL if no match found or consumer data that was associated with a given digit string when matched

Definition at line 2518 of file switch_ivr.c.

References switch_ivr_digit_stream_parser::digit_timeout_ms, switch_ivr_digit_stream::digits, switch_ivr_digit_stream_parser::hash, switch_ivr_digit_stream::last_digit_time, switch_ivr_digit_stream_parser::maxlen, switch_ivr_digit_stream_parser::minlen, switch_assert, switch_core_hash_find(), switch_micro_time_now(), and switch_ivr_digit_stream_parser::terminator.

{
        void *result = NULL;
        switch_size_t len;

        switch_assert(parser);
        switch_assert(stream);
        switch_assert(stream->digits);

        len = strlen(stream->digits);

        /* handle new digit arrivals */
        if (digit) {
                /* if it's not a terminator digit, add it to the collected digits */
                if (digit != parser->terminator) {
                        /* if collected digits length >= the max length of the keys
                         * in the hash table, then left shift the digit string
                         */
                        if (len > 0 && parser->maxlen != 0 && len >= parser->maxlen) {
                                char *src = stream->digits + 1;
                                char *dst = stream->digits;

                                while (*src) {
                                        *(dst++) = *(src++);
                                }
                                *dst = digit;
                        } else {
                                *(stream->digits + (len++)) = digit;
                                *(stream->digits + len) = '\0';
                                stream->last_digit_time = switch_micro_time_now() / 1000;
                        }
                }
        }

        /* don't allow collected digit string testing if there are varying sized keys until timeout */
        if (parser->maxlen - parser->minlen > 0 && (switch_micro_time_now() / 1000) - stream->last_digit_time < parser->digit_timeout_ms) {
                len = 0;
        }
        /* if we have digits to test */
        if (len) {
                result = switch_core_hash_find(parser->hash, stream->digits);
                /* if we matched the digit string, or this digit is the terminator
                 * reset the collected digits for next digit string
                 */
                if (result != NULL || parser->terminator == digit) {
                        *stream->digits = '\0';
                }
        }


        return result;
}

switch_ivr_digit_stream_parser_new()

switch_status_t switch_ivr_digit_stream_parser_new	(	switch_memory_pool_t *	pool,
		switch_ivr_digit_stream_parser_t **	parser
	)

Create a digit stream parser object.

Parameters

pool	the pool to use for the new hash
parser	a pointer to the object pointer

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 2373 of file switch_ivr.c.

References memset(), switch_ivr_digit_stream_parser::pool, switch_ivr_digit_stream_parser::pool_auto_created, SWITCH_CHANNEL_LOG, switch_core_alloc, switch_core_destroy_memory_pool, switch_core_hash_init, switch_core_new_memory_pool, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_MEMERR, and SWITCH_STATUS_SUCCESS.

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (parser != NULL) {
                int pool_auto_created = 0;

                /* if the caller didn't provide a pool, make one */
                if (pool == NULL) {
                        switch_core_new_memory_pool(&pool);
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "created a memory pool\n");
                        if (pool != NULL) {
                                pool_auto_created = 1;
                        }
                }
                /* if we have a pool, make a parser object */
                if (pool != NULL) {
                        *parser = (switch_ivr_digit_stream_parser_t *) switch_core_alloc(pool, sizeof(switch_ivr_digit_stream_parser_t));
                }
                /* if we have parser object, initialize it for the caller */
                if (pool && *parser != NULL) {
                        memset(*parser, 0, sizeof(switch_ivr_digit_stream_parser_t));
                        (*parser)->pool_auto_created = pool_auto_created;
                        (*parser)->pool = pool;
                        (*parser)->digit_timeout_ms = 1000;
                        switch_core_hash_init(&(*parser)->hash);

                        status = SWITCH_STATUS_SUCCESS;
                } else {
                        status = SWITCH_STATUS_MEMERR;
                        /* if we can't create a parser object,clean up the pool if we created it */
                        if (pool != NULL && pool_auto_created) {
                                switch_core_destroy_memory_pool(&pool);
                        }
                }
        }

        return status;
}

switch_ivr_digit_stream_parser_set_event()

switch_status_t switch_ivr_digit_stream_parser_set_event	(	switch_ivr_digit_stream_parser_t *	parser,
		char *	digits,
		void *	data
	)

Set a digit string to action mapping.

Parameters

parser	a pointer to the parser object created by switch_ivr_digit_stream_parser_new
digits	a string of digits to associate with an action
data	consumer data attached to this digit string

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 2461 of file switch_ivr.c.

References switch_ivr_digit_stream_parser::buflen, switch_ivr_digit_stream_parser::hash, switch_ivr_digit_stream_parser::maxlen, switch_ivr_digit_stream_parser::minlen, SWITCH_CHANNEL_LOG, switch_core_hash_insert, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_ivr_digit_stream_parser::terminator.

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (parser != NULL && digits != NULL && *digits && parser->hash != NULL) {

                status = switch_core_hash_insert(parser->hash, digits, data);
                if (status == SWITCH_STATUS_SUCCESS) {
                        switch_size_t len = strlen(digits);

                        /* if we don't have a terminator, then we have to try and
                         * figure out when a digit set is completed, therefore we
                         * keep track of the min and max digit lengths
                         */

                        if (len > parser->buflen) {
                                parser->buflen = len;
                        }

                        if (parser->terminator == '\0') {
                                if (len > parser->maxlen) {
                                        parser->maxlen = len;
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "max len %u\n", (uint32_t) parser->maxlen);
                                }
                                if (parser->minlen == 0 || len < parser->minlen) {
                                        parser->minlen = len;
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "min len %u\n", (uint32_t) parser->minlen);
                                }
                        } else {
                                /* since we have a terminator, reset min and max */
                                parser->minlen = 0;
                                parser->maxlen = 0;
                        }
                }
        }
        if (status != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "unable to add hash for '%s'\n", digits);
        }

        return status;
}

switch_ivr_digit_stream_parser_set_terminator()

switch_status_t switch_ivr_digit_stream_parser_set_terminator	(	switch_ivr_digit_stream_parser_t *	parser,
		char	digit
	)

Set a digit string terminator.

Parameters

parser	a pointer to the parser object created by switch_ivr_digit_stream_parser_new
digit	the terminator digit

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 2584 of file switch_ivr.c.

References switch_ivr_digit_stream_parser::maxlen, switch_ivr_digit_stream_parser::minlen, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_ivr_digit_stream_parser::terminator.

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (parser != NULL) {
                parser->terminator = digit;
                /* since we have a terminator, reset min and max */
                parser->minlen = 0;
                parser->maxlen = 0;
                status = SWITCH_STATUS_SUCCESS;
        }

        return status;
}

switch_ivr_digit_stream_reset()

switch_status_t switch_ivr_digit_stream_reset

(

switch_ivr_digit_stream_t *

stream

)

Reset the collected digit stream to nothing.

Parameters

stream

a pointer to the parser stream object created by switch_ivr_digit_stream_new

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 2571 of file switch_ivr.c.

References switch_ivr_digit_stream::digits, switch_ivr_digit_stream::last_digit_time, switch_assert, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_assert(stream);
        switch_assert(stream->digits);

        *stream->digits = '\0';
        stream->last_digit_time = 0;
        status = SWITCH_STATUS_SUCCESS;

        return status;
}

switch_ivr_displace_session()

switch_status_t switch_ivr_displace_session	(	switch_core_session_t *	session,
		const char *	file,
		uint32_t	limit,
		const char *	flags
	)

displace the media for a session with the audio from a file

Parameters

session	the session to displace
file	filename
limit	time limit in ms
flags	m (mux) l (loop) or r(read session instead of write session)

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 1001 of file switch_ivr_async.c.

References switch_codec_implementation::actual_samples_per_second, switch_directories::base_dir, switch_file_handle::channels, displace_helper_t::fh, displace_helper_t::file, switch_codec_implementation::iananame, displace_helper_t::loop, displace_helper_t::mutex, displace_helper_t::mux, switch_codec_implementation::number_of_channels, read_displace_callback(), switch_file_handle::samplerate, SMBF_FIRST, SMBF_NO_PAUSE, SMBF_READ_REPLACE, SMBF_WRITE_REPLACE, switch_buffer_create_dynamic(), SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER, switch_channel_get_private(), switch_channel_get_variable, switch_channel_hangup, switch_channel_media_up, switch_channel_pre_answer, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_private(), switch_core_file_close(), switch_core_file_open, switch_core_media_bug_add(), switch_core_session_alloc, switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_codec(), switch_core_session_get_read_impl(), switch_core_session_reset(), switch_core_session_sprintf(), switch_core_session_strdup, switch_epoch_time_now(), SWITCH_FALSE, SWITCH_FILE_DATA_SHORT, SWITCH_FILE_FLAG_READ, switch_find_end_paren(), SWITCH_GLOBAL_dirs, switch_is_file_path(), SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_init(), SWITCH_MUTEX_NESTED, SWITCH_PATH_SEPARATOR, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_MEMERR, SWITCH_STATUS_SUCCESS, switch_str_nil, SWITCH_TRUE, switch_true(), SWITCH_URL_SEPARATOR, to, displace_helper_t::wbuffer, write_displace_callback(), and zstr.

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_media_bug_t *bug;
        switch_status_t status;
        time_t to = 0;
        char *ext;
        const char *prefix;
        displace_helper_t *dh;
        const char *p;
        switch_bool_t hangup_on_error = SWITCH_FALSE;
        switch_media_bug_flag_enum_t bug_flags = 0;
        switch_codec_implementation_t read_impl = { 0 };
        switch_core_session_get_read_impl(session, &read_impl);

        if ((p = switch_channel_get_variable(channel, "DISPLACE_HANGUP_ON_ERROR"))) {
                hangup_on_error = switch_true(p);
        }

        if (zstr(file)) {
                return SWITCH_STATUS_FALSE;
        }

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

        if (!switch_channel_media_up(channel) || !switch_core_session_get_read_codec(session)) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Can not displace session.  Media not enabled on channel\n");
                return SWITCH_STATUS_FALSE;
        }

        if ((bug = switch_channel_get_private(channel, file))) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Only 1 of the same file per channel please!\n");
                return SWITCH_STATUS_FALSE;
        }

        if (!(dh = switch_core_session_alloc(session, sizeof(*dh)))) {
                return SWITCH_STATUS_MEMERR;
        }

        if (!(prefix = switch_channel_get_variable(channel, "sound_prefix"))) {
                prefix = SWITCH_GLOBAL_dirs.base_dir;
        }

        if (!strstr(file, SWITCH_URL_SEPARATOR)) {
                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);
                }
        }

        dh->fh.channels = read_impl.number_of_channels;
        dh->fh.samplerate = read_impl.actual_samples_per_second;
        dh->file = switch_core_session_strdup(session, file);

        if (switch_core_file_open(&dh->fh,
                                                          file,
                                                          read_impl.number_of_channels,
                                                          read_impl.actual_samples_per_second, SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, NULL) != SWITCH_STATUS_SUCCESS) {
                if (hangup_on_error) {
                        switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                        switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
                }
                return SWITCH_STATUS_GENERR;
        }

        if (limit) {
                to = switch_epoch_time_now(NULL) + limit;
        }

        if (flags && strchr(flags, 'm')) {
                dh->mux++;
        }

        if (flags && strchr(flags, 'l')) {
                dh->loop++;
        }

        if (flags && strchr(flags, 'f')) {
                bug_flags |= SMBF_FIRST;
        }

        if (flags && strchr(flags, 'r')) {
                if (strchr(flags, 'w')) { // r&w mode, both sides can hear the same file
                        int len = dh->fh.samplerate / 10 * 2 * dh->fh.channels; // init with 100ms

                        switch_mutex_init(&dh->mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));
                        switch_buffer_create_dynamic(&dh->wbuffer, len, len, 0);
                }

                status = switch_core_media_bug_add(session, "displace", file,
                                                                                   read_displace_callback, dh, to, bug_flags | SMBF_WRITE_REPLACE | SMBF_READ_REPLACE | SMBF_NO_PAUSE, &bug);
        } else {
                status = switch_core_media_bug_add(session, "displace", file,
                                                                                   write_displace_callback, dh, to, bug_flags | SMBF_WRITE_REPLACE | SMBF_READ_REPLACE | SMBF_NO_PAUSE, &bug);
        }

        if (status != SWITCH_STATUS_SUCCESS) {
                switch_core_file_close(&dh->fh);
                return status;
        }

        switch_channel_set_private(channel, file, bug);

        return SWITCH_STATUS_SUCCESS;
}

switch_ivr_eavesdrop_exec_all()

switch_status_t switch_ivr_eavesdrop_exec_all	(	switch_core_session_t *	session,
		const char *	app,
		const char *	arg
	)

Definition at line 2232 of file switch_ivr_async.c.

References exec_cb_data::caller, exec_cb(), switch_core_media_bug_exec_all(), switch_core_session_alloc, switch_core_session_strdup, exec_cb_data::val, and exec_cb_data::var.

{
        struct exec_cb_data *data = NULL;

        data = switch_core_session_alloc(session, sizeof(*data));
        data->var = switch_core_session_strdup(session, app);
        data->val = switch_core_session_strdup(session, arg);
        data->caller = session;

        return switch_core_media_bug_exec_all(session, "eavesdrop", exec_cb, data);
}

switch_ivr_eavesdrop_pop_eavesdropper()

switch_status_t switch_ivr_eavesdrop_pop_eavesdropper	(	switch_core_session_t *	session,
		switch_core_session_t **	sessionp
	)

Definition at line 2172 of file switch_ivr_async.c.

References eavesdrop_pvt::eavesdropper, SMBF_PRUNE, switch_core_media_bug_get_user_data(), switch_core_media_bug_pop(), switch_core_media_bug_set_flag(), switch_core_session_read_lock(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_media_bug_t *bug;
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (switch_core_media_bug_pop(session, "eavesdrop", &bug) == SWITCH_STATUS_SUCCESS) {
                struct eavesdrop_pvt *ep = (struct eavesdrop_pvt *) switch_core_media_bug_get_user_data(bug);

                if (ep && ep->eavesdropper && ep->eavesdropper != session) {
                        if (switch_core_session_read_lock(ep->eavesdropper) == SWITCH_STATUS_SUCCESS) {
                                *sessionp = ep->eavesdropper;
                                switch_core_media_bug_set_flag(bug, SMBF_PRUNE);
                                status = SWITCH_STATUS_SUCCESS;
                        }
                }
        }


        return status;
}

switch_ivr_eavesdrop_session()

switch_status_t switch_ivr_eavesdrop_session	(	switch_core_session_t *	session,
		const char *	uuid,
		const char *	require_group,
		switch_eavesdrop_flag_t	flags
	)

Eavesdrop on a another session.

Parameters

session	our session
uuid	the uuid of the session to spy on
require_group	group name to use to limit by group
flags	tweak read-mux, write-mux and dtmf

Returns

SWITCH_STATUS_SUCESS if all is well

Definition at line 2285 of file switch_ivr_async.c.

References switch_codec_implementation::actual_samples_per_second, buf, eavesdrop_pvt::buffer, switch_frame::buflen, switch_caller_profile::callee_id_name, switch_caller_profile::callee_id_number, switch_caller_profile::caller_id_name, switch_caller_profile::caller_id_number, CF_BRIDGE_ORIGINATOR, CF_BRIDGED, CF_VIDEO, switch_core_session::channel, switch_frame::channels, switch_frame::codec, switch_frame::data, eavesdrop_pvt::data, switch_frame::datalen, switch_codec_implementation::decoded_bytes_per_packet, switch_dtmf_t::digit, eavesdrop_callback(), eavesdrop_pvt::eavesdropper, ED_BRIDGE_READ, ED_BRIDGE_WRITE, ED_COPY_DISPLAY, ED_DTMF, ED_MUX_READ, ED_MUX_WRITE, ED_STEREO, ED_TAP_READ, ED_TAP_WRITE, eavesdrop_pvt::flags, switch_core_session_message::from, switch_codec_implementation::iananame, switch_codec::implementation, switch_core_session_message::message_id, switch_codec_implementation::microseconds_per_packet, eavesdrop_pvt::mutex, name, switch_codec_implementation::number_of_channels, eavesdrop_pvt::r_buffer, eavesdrop_pvt::r_mutex, switch_frame::rate, eavesdrop_pvt::read_impl, switch_frame::samples, SFF_CNG, SMBF_NO_PAUSE, SMBF_READ_PING, SMBF_READ_REPLACE, SMBF_READ_STREAM, SMBF_READ_VIDEO_PING, SMBF_READ_VIDEO_STREAM, SMBF_SPY_VIDEO_STREAM, SMBF_SPY_VIDEO_STREAM_BLEG, SMBF_STEREO, SMBF_TAP_NATIVE_READ, SMBF_TAP_NATIVE_WRITE, SMBF_THREAD_LOCK, SMBF_WRITE_REPLACE, SMBF_WRITE_STREAM, SMBF_WRITE_VIDEO_STREAM, switch_core_session_message::string_arg, switch_buffer_add_mutex(), switch_buffer_create_dynamic(), switch_buffer_destroy(), switch_buffer_inuse(), switch_buffer_lock(), switch_buffer_read(), switch_buffer_unlock(), switch_buffer_zero(), switch_buffer_zwrite(), switch_channel_dequeue_dtmf(), switch_channel_get_caller_profile(), switch_channel_get_variable, switch_channel_has_dtmf(), switch_channel_media_ack, switch_channel_media_up, switch_channel_pre_answer, switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_state_change_pending(), switch_channel_test_flag(), switch_channel_up, switch_channel_up_nosig, switch_clear_flag, SWITCH_CODEC_FLAG_DECODE, SWITCH_CODEC_FLAG_ENCODE, switch_core_codec_destroy(), switch_core_codec_init, switch_core_media_bug_add(), switch_core_media_bug_clear_flag(), switch_core_media_bug_remove(), switch_core_media_bug_set_flag(), switch_core_media_bug_test_flag(), switch_core_session_alloc, switch_core_session_dequeue_event(), switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_impl(), switch_core_session_get_real_read_impl(), switch_core_session_locate, switch_core_session_read_frame(), switch_core_session_receive_message, switch_core_session_request_video_refresh, switch_core_session_reset(), switch_core_session_rwunlock(), switch_core_session_set_read_codec(), switch_core_session_strdup, switch_core_session_write_frame(), switch_event_destroy(), switch_event_get_header, SWITCH_FALSE, switch_goto_status, SWITCH_IO_FLAG_NONE, switch_ivr_phrase_macro, switch_lcm(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_media_bug_parse_spy_fmt(), switch_media_bug_set_spy_fmt(), SWITCH_MESSAGE_INDICATE_BRIDGE, SWITCH_MESSAGE_INDICATE_DISPLAY, SWITCH_MESSAGE_INDICATE_UNBRIDGE, SWITCH_MESSAGE_INDICATE_VIDEO_REFRESH_REQ, switch_mutex_init(), SWITCH_MUTEX_NESTED, switch_mux_channels(), SWITCH_READ_ACCEPTABLE, SWITCH_RECOMMENDED_BUFFER_SIZE, switch_safe_free, switch_separate_string(), switch_set_flag, switch_snprintf(), SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_test_flag, SWITCH_TRUE, switch_true(), switch_yield, eavesdrop_pvt::tread_impl, eavesdrop_pvt::w_buffer, eavesdrop_pvt::w_mutex, and zstr.

{
        switch_core_session_t *tsession;
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_channel_t *channel = switch_core_session_get_channel(session);
        int codec_initialized = 0;
        const char *name, *num;

        if ((tsession = switch_core_session_locate(uuid))) {
                struct eavesdrop_pvt *ep = NULL;
                switch_media_bug_t *bug = NULL;
                switch_channel_t *tchannel = switch_core_session_get_channel(tsession);
                switch_frame_t *read_frame, write_frame = { 0 };
                switch_codec_t codec = { 0 };
                int16_t buf[SWITCH_RECOMMENDED_BUFFER_SIZE / 2];
                uint32_t tlen;
                const char *macro_name = "eavesdrop_announce";
                const char *id_name = NULL;
                switch_codec_implementation_t tread_impl = { 0 }, read_impl = { 0 };
                switch_core_session_message_t msg = { 0 };
                char cid_buf[1024] = "";
                switch_caller_profile_t *cp = NULL;
                uint32_t sanity = 600;
                switch_media_bug_flag_t read_flags = 0, write_flags = 0, stereo_flag = 0;
                const char *vval;
                int buf_size = 0;
                int channels;
                int lcm, buff_min_len, buffered = 1;

                if (!switch_channel_media_up(channel)) {
                        goto end;
                }

                if (tsession == session) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Eavesdrop target invalid.\n");
                        goto end;
                }

                while(switch_channel_state_change_pending(tchannel) || !switch_channel_media_up(tchannel)) {
                        switch_yield(10000);
                        if (!--sanity) break;
                }

                if (!switch_channel_media_up(tchannel)) {
                        goto end;
                }

                if ((flags & ED_TAP_READ) || (flags & ED_TAP_WRITE)) {
                        switch_core_session_get_real_read_impl(tsession, &tread_impl);
                        switch_core_session_get_real_read_impl(session, &read_impl);
                        
                        if (strcasecmp(tread_impl.iananame, read_impl.iananame)) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Codecs do not match which is required for this mode\n");
                                goto end;
                        }
                }

                switch_core_session_get_read_impl(tsession, &tread_impl);
                switch_core_session_get_read_impl(session, &read_impl);
                
                if ((id_name = switch_channel_get_variable(tchannel, "eavesdrop_announce_id"))) {
                        const char *tmp = switch_channel_get_variable(tchannel, "eavesdrop_announce_macro");
                        if (tmp) {
                                macro_name = tmp;
                        }

                        switch_ivr_phrase_macro(session, macro_name, id_name, NULL, NULL);
                }


                if (!zstr(require_group)) {
                        int argc, i;
                        int ok = 0;
                        char *argv[10] = { 0 };
                        char *data;

                        const char *group_name = switch_channel_get_variable(tchannel, "eavesdrop_group");
                        /* If we don't have a group, then return */
                        if (!group_name) {
                                switch_goto_status(SWITCH_STATUS_BREAK, end);
                        }
                        /* Separate the group */
                        data = strdup(group_name);
                        if ((argc = switch_separate_string(data, ',', argv, (sizeof(argv) / sizeof(argv[0]))))) {
                                for (i = 0; i < argc; i++) {
                                        /* If one of the group matches, then ok */
                                        if (argv[i] && !strcmp(argv[i], require_group)) {
                                                ok = 1;
                                        }
                                }
                        }
                        switch_safe_free(data);
                        /* If we didn't find any match, then end */
                        if (!ok) {
                                switch_goto_status(SWITCH_STATUS_BREAK, end);
                        }
                }


                ep = switch_core_session_alloc(session, sizeof(*ep));


                if (switch_channel_pre_answer(channel) != SWITCH_STATUS_SUCCESS) {
                        goto end;
                }

                if (tread_impl.decoded_bytes_per_packet < read_impl.decoded_bytes_per_packet) {
                        if (switch_core_codec_init(&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_ERROR, "Cannot init codec\n");
                                goto end;
                        }
                } else {
                        if (switch_core_codec_init(&codec,
                                                                   "L16",
                                                                   NULL,
                                                                   NULL,
                                                                   tread_impl.actual_samples_per_second,
                                                                   tread_impl.microseconds_per_packet / 1000,
                                                                   tread_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_ERROR, "Cannot init codec\n");
                        goto end;
                        }
                        buffered = 0;
                }

                ep->read_impl = read_impl;
                ep->tread_impl = tread_impl;

                codec_initialized = 1;

                switch_core_session_set_read_codec(session, &codec);
                write_frame.codec = &codec;
                write_frame.data = buf;
                write_frame.buflen = sizeof(buf);
                write_frame.rate = codec.implementation->actual_samples_per_second;

                /* Make sure that at least one leg is bridged, default to both */
                if (! (flags & (ED_BRIDGE_READ | ED_BRIDGE_WRITE))) {
                        flags |= ED_BRIDGE_READ | ED_BRIDGE_WRITE;
                }

                buf_size = codec.implementation->decoded_bytes_per_packet * 10;

                ep->eavesdropper = session;
                ep->flags = flags;

                if (!(flags & ED_TAP_READ) && !(flags & ED_TAP_WRITE)) {
                        switch_mutex_init(&ep->mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(tsession));
                        switch_buffer_create_dynamic(&ep->buffer, buf_size, buf_size, buf_size);
                        switch_buffer_add_mutex(ep->buffer, ep->mutex);
                        
                        switch_mutex_init(&ep->w_mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(tsession));
                        switch_buffer_create_dynamic(&ep->w_buffer, buf_size, buf_size, buf_size);
                        switch_buffer_add_mutex(ep->w_buffer, ep->w_mutex);
                        
                        switch_mutex_init(&ep->r_mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(tsession));
                        switch_buffer_create_dynamic(&ep->r_buffer, buf_size, buf_size, buf_size);
                        switch_buffer_add_mutex(ep->r_buffer, ep->r_mutex);
                }
                
                if (flags & ED_BRIDGE_READ) {
                        read_flags = SMBF_READ_STREAM | SMBF_READ_REPLACE;
                }

                if (flags & ED_BRIDGE_WRITE) {
                        write_flags = SMBF_WRITE_STREAM | SMBF_WRITE_REPLACE;
                }

                if (flags & ED_TAP_READ) {
                        read_flags = SMBF_TAP_NATIVE_READ;
                        write_flags = 0;
                }

                if (flags & ED_TAP_WRITE) {
                        write_flags = SMBF_TAP_NATIVE_WRITE;
                        read_flags = 0;
                }

                if (flags & ED_STEREO) {
                        stereo_flag = SMBF_STEREO;
                }

                if (switch_channel_test_flag(session->channel, CF_VIDEO) && switch_channel_test_flag(tsession->channel, CF_VIDEO)) {
                        if ((vval = switch_channel_get_variable(session->channel, "eavesdrop_show_listener_video"))) {
                                if (switch_true(vval) || !strcasecmp(vval, "aleg") || !strcasecmp(vval, "bleg") || !strcasecmp(vval, "both")) {
                                        read_flags |= SMBF_SPY_VIDEO_STREAM;
                                }
                                if (switch_true(vval) || !strcasecmp(vval, "bleg") || !strcasecmp(vval, "both")) {
                                        read_flags |= SMBF_SPY_VIDEO_STREAM_BLEG;
                                }
                        }

                        if ((vval = switch_channel_get_variable(session->channel, "eavesdrop_concat_video")) && switch_true(vval)) {
                                read_flags |= SMBF_READ_VIDEO_STREAM;
                                read_flags |= SMBF_WRITE_VIDEO_STREAM;
                        } else {
                                read_flags |= SMBF_READ_VIDEO_PING;
                        }
                } else {
                        read_flags &= ~SMBF_READ_VIDEO_PING;
                        read_flags &= ~SMBF_READ_VIDEO_STREAM;
                        read_flags &= ~SMBF_WRITE_VIDEO_STREAM;
                        read_flags &= ~SMBF_SPY_VIDEO_STREAM;
                        read_flags &= ~SMBF_SPY_VIDEO_STREAM_BLEG;
                }


                if (switch_core_media_bug_add(tsession, "eavesdrop", uuid,
                                                                          eavesdrop_callback, ep, 0,
                                                                          read_flags | write_flags | SMBF_READ_PING | SMBF_THREAD_LOCK | SMBF_NO_PAUSE | stereo_flag,
                                                                          &bug) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot attach bug\n");
                        goto end;
                }

                if ((vval = switch_channel_get_variable(session->channel, "eavesdrop_video_spy_fmt"))) {
                        switch_media_bug_set_spy_fmt(bug, switch_media_bug_parse_spy_fmt(vval));
                }

                msg.from = __FILE__;

                /* Tell the channel we are going to be in a bridge */
                msg.message_id = SWITCH_MESSAGE_INDICATE_BRIDGE;
                switch_core_session_receive_message(session, &msg);
                cp = switch_channel_get_caller_profile(tchannel);

                name = cp->caller_id_name;
                num = cp->caller_id_number;

                if ((flags & ED_TAP_READ) || (flags & ED_TAP_WRITE)) {
                        flags &= ~ED_DTMF;
                        flags &= ~ED_BRIDGE_READ;
                        flags &= ~ED_BRIDGE_WRITE;
                }
                
                if (flags & ED_COPY_DISPLAY) {
                        if (switch_channel_test_flag(tchannel, CF_BRIDGE_ORIGINATOR) || !switch_channel_test_flag(tchannel, CF_BRIDGED)) {
                                name = cp->callee_id_name;
                                num = cp->callee_id_number;
                        } else {
                                name = cp->caller_id_name;
                                num = cp->caller_id_number;
                        }
                }

                sanity = 300;
                while(switch_channel_up(channel) && !switch_channel_media_ack(channel) && --sanity) {
                        switch_yield(10000);
                }


                switch_snprintf(cid_buf, sizeof(cid_buf), "%s|%s", name, num);
                msg.string_arg = cid_buf;
                msg.message_id = SWITCH_MESSAGE_INDICATE_DISPLAY;
                switch_core_session_receive_message(session, &msg);

                if (switch_channel_test_flag(tchannel, CF_VIDEO)) {

                        msg.message_id = SWITCH_MESSAGE_INDICATE_VIDEO_REFRESH_REQ;

                        switch_core_session_receive_message(tsession, &msg);
                }

                lcm = switch_lcm(tread_impl.decoded_bytes_per_packet, read_impl.decoded_bytes_per_packet);

                while (switch_channel_up_nosig(tchannel) && switch_channel_ready(channel)) {
                        uint32_t len = sizeof(buf);
                        switch_event_t *event = NULL;
                        char *fcommand = NULL;
                        char db[2] = "";
                        int vid_bug = 0, vid_dual = 0;

                        status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);

                        if (!SWITCH_READ_ACCEPTABLE(status)) {
                                goto end_loop;
                        }

                        if (switch_core_session_dequeue_event(session, &event, SWITCH_FALSE) == SWITCH_STATUS_SUCCESS) {
                                char *command = switch_event_get_header(event, "eavesdrop-command");
                                if (command) {
                                        fcommand = switch_core_session_strdup(session, command);
                                }
                                switch_event_destroy(&event);
                        }

                        if ((flags & ED_DTMF) && switch_channel_has_dtmf(channel)) {
                                switch_dtmf_t dtmf = { 0 };
                                switch_channel_dequeue_dtmf(channel, &dtmf);
                                db[0] = dtmf.digit;
                                fcommand = db;
                        }

                        if (switch_core_media_bug_test_flag(bug, SMBF_READ_VIDEO_STREAM) ||
                                switch_core_media_bug_test_flag(bug, SMBF_WRITE_VIDEO_STREAM)) {
                                vid_dual = 1;
                        }

                        if (vid_dual || switch_core_media_bug_test_flag(bug, SMBF_READ_VIDEO_PING)) {
                                vid_bug = 1;
                        }

                        if (fcommand) {
                                char *d;
                                for (d = fcommand; *d; d++) {
                                        int z = 1;

                                        switch (*d) {
                                        case '1':
                                                switch_set_flag(ep, ED_MUX_READ);
                                                switch_clear_flag(ep, ED_MUX_WRITE);
                                                if (vid_bug) {
                                                        switch_core_media_bug_set_flag(bug, SMBF_SPY_VIDEO_STREAM);
                                                        switch_core_media_bug_clear_flag(bug, SMBF_SPY_VIDEO_STREAM_BLEG);
                                                        switch_core_session_request_video_refresh(tsession);
                                                }
                                                break;
                                        case '2':
                                                switch_set_flag(ep, ED_MUX_WRITE);
                                                switch_clear_flag(ep, ED_MUX_READ);
                                                if (vid_bug) {
                                                        switch_core_media_bug_set_flag(bug, SMBF_SPY_VIDEO_STREAM_BLEG);
                                                        switch_core_media_bug_clear_flag(bug, SMBF_SPY_VIDEO_STREAM);
                                                        switch_core_session_request_video_refresh(tsession);
                                                }
                                                break;
                                        case '3':
                                                switch_set_flag(ep, ED_MUX_READ);
                                                switch_set_flag(ep, ED_MUX_WRITE);
                                                if (vid_bug) {
                                                        switch_core_media_bug_set_flag(bug, SMBF_SPY_VIDEO_STREAM);
                                                        switch_core_media_bug_set_flag(bug, SMBF_SPY_VIDEO_STREAM_BLEG);
                                                        switch_core_session_request_video_refresh(tsession);
                                                }
                                                break;

                                        case '4':
                                                switch_media_bug_set_spy_fmt(bug, switch_media_bug_parse_spy_fmt("dual-crop"));
                                                break;
                                        case '5':
                                                switch_media_bug_set_spy_fmt(bug, switch_media_bug_parse_spy_fmt("lower-right-small"));
                                                break;
                                        case '6':
                                                switch_media_bug_set_spy_fmt(bug, switch_media_bug_parse_spy_fmt("lower-right-large"));
                                                break;
                                        case '0':
                                                switch_clear_flag(ep, ED_MUX_READ);
                                                switch_clear_flag(ep, ED_MUX_WRITE);
                                                if (vid_bug) {
                                                        switch_core_media_bug_clear_flag(bug, SMBF_SPY_VIDEO_STREAM);
                                                        switch_core_media_bug_clear_flag(bug, SMBF_SPY_VIDEO_STREAM_BLEG);
                                                        switch_core_session_request_video_refresh(tsession);
                                                }
                                                break;
                                        case '*':
                                                goto end_loop;
                                        default:
                                                z = 0;
                                                break;

                                        }

                                        if (z) {
                                                if (ep->r_buffer) {
                                                        switch_buffer_lock(ep->r_buffer);
                                                        switch_buffer_zero(ep->r_buffer);
                                                        switch_buffer_unlock(ep->r_buffer);
                                                }

                                                if (ep->w_buffer) {
                                                        switch_buffer_lock(ep->w_buffer);
                                                        switch_buffer_zero(ep->w_buffer);
                                                        switch_buffer_unlock(ep->w_buffer);
                                                }
                                        }
                                }
                        }

                        if (ep->r_buffer && ep->w_buffer && !switch_test_flag(read_frame, SFF_CNG)) {
                                switch_buffer_lock(ep->r_buffer);
                                switch_buffer_zwrite(ep->r_buffer, read_frame->data, read_frame->datalen);
                                switch_buffer_unlock(ep->r_buffer);

                                switch_buffer_lock(ep->w_buffer);
                                switch_buffer_zwrite(ep->w_buffer, read_frame->data, read_frame->datalen);
                                switch_buffer_unlock(ep->w_buffer);
                        }

                        channels = switch_core_media_bug_test_flag(bug, SMBF_STEREO) ? 2 : tread_impl.number_of_channels;

                        if (channels == 0) {
                                channels = 1;
                        }

                        tlen = ep->read_impl.decoded_bytes_per_packet * channels;

                        if (len > tlen) {
                                len = tlen;
                        }

                        if (buffered) {
                                buff_min_len = lcm * 2;
                                if (switch_buffer_inuse(ep->buffer) < buff_min_len) {
                                        continue;
                                }
                        } else {
                                buff_min_len = len;
                        }

                        if (ep->buffer) {
                                switch_buffer_lock(ep->buffer);
                                while (switch_buffer_inuse(ep->buffer) >= buff_min_len) {
                                        int tchanged = 0, changed = 0;

                                        write_frame.datalen = (uint32_t) switch_buffer_read(ep->buffer, buf, len);
                                        write_frame.samples = write_frame.datalen / 2 / channels;
                                        write_frame.channels = channels;

                                        switch_core_session_get_read_impl(tsession, &tread_impl);
                                        switch_core_session_get_read_impl(session, &read_impl);

                                        if (tread_impl.number_of_channels != ep->tread_impl.number_of_channels ||
                                                tread_impl.actual_samples_per_second != ep->tread_impl.actual_samples_per_second) {
                                                tchanged = 1;
                                        }

                                        if (read_impl.number_of_channels != ep->read_impl.number_of_channels ||
                                                read_impl.actual_samples_per_second != ep->read_impl.actual_samples_per_second) {
                                                changed = 1;
                                        }

                                        if (changed || tchanged) {

                                                if (changed) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                                          "SPYING CHANNEL CODEC CHANGE FROM %dhz@%dc to %dhz@%dc\n",
                                                                                          ep->read_impl.actual_samples_per_second,
                                                                                          ep->read_impl.number_of_channels,
                                                                                          read_impl.actual_samples_per_second,
                                                                                          read_impl.number_of_channels);

                                                        tlen = read_impl.decoded_bytes_per_packet * channels;

                                                        if (len > tlen) {
                                                                len = tlen;
                                                        }

                                                }

                                                if (tchanged) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                                          "SPYED CHANNEL CODEC CHANGE FROM %dhz@%dc to %dhz@%dc\n",
                                                                                          ep->tread_impl.actual_samples_per_second,
                                                                                          ep->tread_impl.number_of_channels,
                                                                                          tread_impl.actual_samples_per_second,
                                                                                          tread_impl.number_of_channels);
                                                }
                                                

                                                switch_core_codec_destroy(&codec);

                                                if (tread_impl.decoded_bytes_per_packet < read_impl.decoded_bytes_per_packet) {
                                                        if (switch_core_codec_init(&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_ERROR, "Cannot init codec\n");
                                                                        switch_buffer_unlock(ep->buffer);
                                                                        goto end;
                                                        } 
                                                        buffered = 1;
                                                        lcm = switch_lcm(tread_impl.decoded_bytes_per_packet, read_impl.decoded_bytes_per_packet);
                                                } else {
                                                        if (switch_core_codec_init(&codec,
                                                                                                   "L16",
                                                                                                   NULL,
                                                                                                   NULL,
                                                                                                   tread_impl.actual_samples_per_second,
                                                                                                   tread_impl.microseconds_per_packet / 1000,
                                                                                                   tread_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_ERROR, "Cannot init codec\n");
                                                                switch_buffer_unlock(ep->buffer);
                                                                goto end;
                                                        }
                                                        if (buffered == 1) {
                                                                buffered = 0;
                                                        }
                                                }

                                                ep->read_impl = read_impl;
                                                ep->tread_impl = tread_impl;
                                        }


                                        if (ep->tread_impl.number_of_channels != ep->read_impl.number_of_channels) {
                                                uint32_t rlen = write_frame.datalen / 2 / ep->tread_impl.number_of_channels;

                                                switch_mux_channels((int16_t *) write_frame.data, rlen, ep->tread_impl.number_of_channels, ep->read_impl.number_of_channels);
                                                write_frame.datalen = rlen * 2 * ep->read_impl.number_of_channels;
                                                write_frame.samples = write_frame.datalen / 2;
                                        }

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

                                        switch_buffer_unlock(ep->buffer);
                                        switch_buffer_lock(ep->buffer);

                                        if (ep->tread_impl.decoded_bytes_per_packet == ep->read_impl.decoded_bytes_per_packet) {
                                                /* push just the number of samples worth of a packet. */
                                                break;
                                        }
                                }
                                switch_buffer_unlock(ep->buffer);
                        }
                }

          end_loop:

                /* Tell the channel we are no longer going to be in a bridge */
                msg.message_id = SWITCH_MESSAGE_INDICATE_UNBRIDGE;
                switch_core_session_receive_message(session, &msg);

                status = SWITCH_STATUS_SUCCESS;
          end:

                if (codec_initialized)
                        switch_core_codec_destroy(&codec);

                if (bug) {
                        switch_core_media_bug_remove(tsession, &bug);
                }

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

                        if (ep->r_buffer) {
                                switch_buffer_destroy(&ep->r_buffer);
                        }

                        if (ep->w_buffer) {
                                switch_buffer_destroy(&ep->w_buffer);
                        }
                }

                switch_core_session_rwunlock(tsession);

                switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
        }

        return status;
}

switch_ivr_eavesdrop_update_display()

switch_status_t switch_ivr_eavesdrop_update_display	(	switch_core_session_t *	session,
		const char *	name,
		const char *	number
	)

Definition at line 2245 of file switch_ivr_async.c.

References exec_cb_data::caller, display_exec_cb(), switch_channel_clear_app_flag_key(), switch_channel_set_app_flag_key(), switch_channel_test_app_flag_key(), switch_core_media_bug_exec_all(), switch_core_session_alloc, switch_core_session_get_channel(), switch_core_session_strdup, SWITCH_STATUS_FALSE, exec_cb_data::val, and exec_cb_data::var.

{
        struct exec_cb_data *data = NULL;
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_status_t status = SWITCH_STATUS_FALSE;

        data = switch_core_session_alloc(session, sizeof(*data));
        data->var = switch_core_session_strdup(session, name);
        data->val = switch_core_session_strdup(session, number);
        data->caller = session;

        if (!switch_channel_test_app_flag_key("EAVESDROP", channel, 1)) {
                switch_channel_set_app_flag_key("EAVESDROP", channel, 1);
                status = switch_core_media_bug_exec_all(session, "eavesdrop", display_exec_cb, data);
                switch_channel_clear_app_flag_key("EAVESDROP", channel, 1);
        }

        return status;
}

switch_ivr_enterprise_originate()

switch_status_t switch_ivr_enterprise_originate	(	switch_core_session_t *	session,
		switch_core_session_t **	bleg,
		switch_call_cause_t *	cause,
		const char *	bridgeto,
		uint32_t	timelimit_sec,
		const switch_state_handler_table_t *	table,
		const char *	cid_name_override,
		const char *	cid_num_override,
		switch_caller_profile_t *	caller_profile_override,
		switch_event_t *	ovars,
		switch_originate_flag_t	flags,
		switch_call_cause_t *	cancel_cause,
		switch_dial_handle_list_t *	hl
	)

Definition at line 1567 of file switch_ivr_originate.c.

References enterprise_originate_handle_t::bleg, enterprise_originate_handle_t::cause, CF_ANSWERED, CF_NOT_READY, CF_PROXY_MEDIA, CF_PROXY_MODE, enterprise_originate_handle_t::dh, enterprise_originate_ringback_thread(), enterprise_originate_thread(), switch_dial_handle_list_s::global_vars, switch_dial_handle_list_s::handle_idx, switch_dial_handle_list_s::handles, switch_event::headers, MAX_PEERS, mutex, enterprise_originate_handle_t::mutex, switch_event_header::name, switch_event_header::next, enterprise_originate_handle_t::ovars, pool, ent_originate_ringback::ringback_data, running, ent_originate_ringback::running, ent_originate_ringback::session, enterprise_originate_handle_t::status, switch_caller_profile_clone(), switch_caller_profile_dup(), SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER, SWITCH_CAUSE_LOSE_RACE, SWITCH_CAUSE_NO_ANSWER, SWITCH_CAUSE_NO_PICKUP, SWITCH_CAUSE_ORIGINATOR_CANCEL, SWITCH_CAUSE_SUCCESS, switch_channel_cause2str(), switch_channel_clear_flag(), switch_channel_get_caller_profile(), switch_channel_get_variable, switch_channel_handle_cause(), switch_channel_media_ready, switch_channel_pre_answer, switch_channel_process_export(), switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_originatee_caller_profile(), switch_channel_set_originator_caller_profile(), switch_channel_set_variable, switch_channel_test_flag(), switch_core_destroy_memory_pool, switch_core_new_memory_pool, switch_core_session_get_channel(), switch_core_session_get_uuid(), switch_core_strdup, switch_dial_handle_destroy(), switch_dial_handle_dup(), SWITCH_ENT_ORIGINATE_DELIM, switch_event_add_header_string(), SWITCH_EVENT_CHANNEL_DATA, switch_event_create_brackets(), switch_event_create_plain(), switch_event_destroy(), switch_event_dup(), switch_event_merge(), SWITCH_EXPORT_VARS_VARIABLE, SWITCH_FALSE, switch_goto_status, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_init(), switch_mutex_lock(), SWITCH_MUTEX_NESTED, switch_mutex_unlock(), switch_separate_string_string(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, switch_thread_create(), switch_thread_join(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_stacksize_set(), switch_yield, thread, enterprise_originate_handle_t::thread, ent_originate_ringback::thread, switch_event_header::value, and zstr.

Referenced by switch_ivr_enterprise_orig_and_bridge(), and switch_ivr_originate().

{
        int x_argc = 0;
        char *x_argv[MAX_PEERS] = { 0 };
        enterprise_originate_handle_t *hp = NULL, handles[MAX_PEERS] = { {0} };
        int i;
        switch_caller_profile_t *cp = NULL;
        switch_channel_t *channel = NULL;
        char *data = NULL;
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_threadattr_t *thd_attr = NULL;
        int running = 0, over = 0;
        switch_status_t tstatus = SWITCH_STATUS_FALSE;
        switch_memory_pool_t *pool;
        switch_event_header_t *hi = NULL;
        struct ent_originate_ringback rb_data = { 0 };
        const char *ringback_data = NULL;
        switch_event_t *var_event = NULL;
        int getcause = 1;

        *cause = SWITCH_CAUSE_SUCCESS;

        switch_core_new_memory_pool(&pool);

        if (zstr(bridgeto) && (!hl || hl->handle_idx == 0)) {
                *cause = SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
                getcause = 0;
                switch_goto_status(SWITCH_STATUS_FALSE, end);
        }

        if (!hl) {
                data = switch_core_strdup(pool, bridgeto);
        }

        if (session) {
                switch_caller_profile_t *cpp = NULL;
                channel = switch_core_session_get_channel(session);
                if ((cpp = switch_channel_get_caller_profile(channel))) {
                        cp = switch_caller_profile_dup(pool, cpp);
                }
        }

        if (ovars) {
                var_event = ovars;
        } else {
                if (switch_event_create_plain(&var_event, SWITCH_EVENT_CHANNEL_DATA) != SWITCH_STATUS_SUCCESS) {
                        abort();
                }
        }

        if (session) {
                switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "ent_originate_aleg_uuid", switch_core_session_get_uuid(session));
        }

        if (channel) {
                const char *tmp_var = NULL;

                switch_channel_process_export(channel, NULL, var_event, SWITCH_EXPORT_VARS_VARIABLE);

                if ((tmp_var = switch_channel_get_variable(channel, "effective_ani"))) {
                        switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "origination_ani", tmp_var);
                }

                if ((tmp_var = switch_channel_get_variable(channel, "effective_aniii"))) {
                        switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "origination_aniii", tmp_var);
                }

                if ((tmp_var = switch_channel_get_variable(channel, "effective_caller_id_name"))) {
                        switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "origination_caller_id_name", tmp_var);
                }

                if ((tmp_var = switch_channel_get_variable(channel, "effective_caller_id_number"))) {
                        switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "origination_caller_id_number", tmp_var);
                }
        }

        /* strip leading spaces */
        while (data && *data && *data == ' ') {
                data++;
        }

        /* extract channel variables, allowing multiple sets of braces */
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Parsing ultra-global variables\n");
        while (data && *data == '<') {
                char *parsed = NULL;

                if (switch_event_create_brackets(data, '<', '>', ',', &var_event, &parsed, SWITCH_FALSE) != SWITCH_STATUS_SUCCESS || !parsed) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Parse Error!\n");
                        switch_goto_status(SWITCH_STATUS_GENERR, done);
                }

                data = parsed;
        }
        if (hl && hl->global_vars) {
                switch_event_merge(var_event, hl->global_vars);
        }

        /* strip leading spaces (again) */
        while (data && *data && *data == ' ') {
                data++;
        }

        if (ovars && ovars != var_event) {
                for (hi = ovars->headers; hi; hi = hi->next) {
                        switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, hi->name, hi->value);
                }
        }

        switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "ignore_early_media", "true");

        if (data) {
                if (!(x_argc = switch_separate_string_string(data, SWITCH_ENT_ORIGINATE_DELIM, x_argv, MAX_PEERS))) {
                        *cause = SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
                        getcause = 0;
                        switch_goto_status(SWITCH_STATUS_FALSE, end);
                }
        } else if (hl) {
                x_argc = hl->handle_idx;
        }

        switch_threadattr_create(&thd_attr, pool);
        switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);

        for (i = 0; i < x_argc; i++) {
                handles[i].session = session;
                handles[i].bleg = NULL;
                handles[i].cause = 0;
                handles[i].cancel_cause = 0;
                handles[i].bridgeto = x_argv[i];
                handles[i].timelimit_sec = timelimit_sec;
                handles[i].table = table;
                handles[i].cid_name_override = cid_name_override;
                handles[i].cid_num_override = cid_num_override;
                handles[i].caller_profile_override = cp;
                switch_event_dup(&handles[i].ovars, var_event);
                handles[i].flags = flags;
                if (hl) {
                        switch_dial_handle_dup(&handles[i].dh, hl->handles[i]);
                }
                switch_mutex_init(&handles[i].mutex, SWITCH_MUTEX_NESTED, pool);
                switch_mutex_init(&handles[i].fence_mutex, SWITCH_MUTEX_NESTED, pool);
                switch_mutex_lock(handles[i].mutex);
                switch_thread_create(&handles[i].thread, thd_attr, enterprise_originate_thread, &handles[i], pool);
        }

        if (channel && !switch_channel_test_flag(channel, CF_PROXY_MODE) && !switch_channel_test_flag(channel, CF_PROXY_MEDIA)) {
                if (switch_channel_test_flag(channel, CF_ANSWERED)) {
                        ringback_data = switch_channel_get_variable(channel, "transfer_ringback");
                }

                if (!ringback_data) {
                        ringback_data = switch_channel_get_variable(channel, "ringback");
                }

                if (ringback_data || switch_channel_media_ready(channel)) {
                        rb_data.ringback_data = ringback_data;
                        rb_data.session = session;
                        rb_data.running = 1;
                        if (!switch_channel_media_ready(channel)) {
                                if (switch_channel_pre_answer(channel) != SWITCH_STATUS_SUCCESS) {
                                        goto done;
                                }
                        }
                        switch_thread_create(&rb_data.thread, thd_attr, enterprise_originate_ringback_thread, &rb_data, pool);
                }
        }


        for (;;) {
                running = 0;
                over = 0;

                if (channel && !switch_channel_ready(channel)) {
                        break;
                }

                if (cancel_cause && *cancel_cause > 0) {
                        break;
                }

                for (i = 0; i < x_argc; i++) {

                        switch_mutex_lock(handles[i].fence_mutex);
                        if (handles[i].done == 0) {
                                running++;
                        } else if (handles[i].done == 1) {
                                if (handles[i].status == SWITCH_STATUS_SUCCESS) {
                                        handles[i].done = 2;
                                        hp = &handles[i];
                                        switch_mutex_unlock(handles[i].fence_mutex);
                                        goto done;
                                } else {
                                        handles[i].done = -1;
                                }
                        } else {
                                over++;
                        }

                        switch_mutex_unlock(handles[i].fence_mutex);

                        switch_yield(10000);
                }

                if (!running || over == x_argc) {
                        break;
                }
        }


  done:

        if (hp) {
                *cause = hp->cause;
                getcause = 0;
                status = hp->status;
                *bleg = hp->bleg;
                if (*bleg) {
                        switch_channel_t *bchan = switch_core_session_get_channel(*bleg);
                        switch_caller_profile_t *cloned_profile;

                        if (session) {
                                cloned_profile = switch_caller_profile_clone(*bleg, cp);
                                switch_channel_set_originator_caller_profile(bchan, cloned_profile);
                                
                                cloned_profile = switch_caller_profile_clone(session, switch_channel_get_caller_profile(bchan));
                                switch_channel_set_originatee_caller_profile(channel, cloned_profile);
                        }
                }
                switch_mutex_unlock(hp->mutex);
                switch_thread_join(&tstatus, hp->thread);
                switch_event_destroy(&hp->ovars);
                switch_dial_handle_destroy(&hp->dh);
        }

        for (i = 0; i < x_argc; i++) {
                if (hp == &handles[i]) {
                        continue;
                }

                if (cancel_cause && *cancel_cause > 0) {
                        handles[i].cancel_cause = *cancel_cause;
                } else {
                        /* Was this call taken by another destination? */
                        if (hp != NULL && hp->cause == SWITCH_CAUSE_SUCCESS) {
                                /* Yes, the race was lost */
                                handles[i].cancel_cause = SWITCH_CAUSE_LOSE_RACE;
                        } else {
                                /* No, something else happened, probably Originator Cancel */
                                handles[i].cancel_cause = SWITCH_CAUSE_ORIGINATOR_CANCEL;
                        }
                }
        }

        for (i = 0; i < x_argc; i++) {

                if (hp == &handles[i]) {
                        continue;
                }

                if (getcause && channel && handles[i].cause && handles[i].cause != SWITCH_CAUSE_SUCCESS) {
                        switch_channel_handle_cause(channel, handles[i].cause);
                }

                switch_mutex_unlock(handles[i].mutex);

                if (getcause && *cause != handles[i].cause && handles[i].cause != SWITCH_CAUSE_LOSE_RACE && handles[i].cause != SWITCH_CAUSE_NO_PICKUP) {
                        *cause = handles[i].cause;
                        getcause++;
                }

                switch_thread_join(&tstatus, handles[i].thread);
                switch_event_destroy(&handles[i].ovars);
                switch_dial_handle_destroy(&handles[i].dh);
        }

        if (channel && rb_data.thread) {
                switch_channel_set_flag(channel, CF_NOT_READY);
                switch_thread_join(&tstatus, rb_data.thread);
                switch_channel_clear_flag(channel, CF_NOT_READY);
        }


  end:

        if (getcause == 1 && *cause == SWITCH_CAUSE_SUCCESS) {
                *cause = SWITCH_CAUSE_NO_ANSWER;
        }

        if (channel) {
                if (*cause == SWITCH_CAUSE_SUCCESS) {
                        switch_channel_set_variable(channel, "originate_disposition", "success");
                } else {
                        switch_channel_set_variable(channel, "originate_disposition", "failure");
                        switch_channel_set_variable(channel, "hangup_cause", switch_channel_cause2str(*cause));
                }
        }


        if (var_event && var_event != ovars) {
                switch_event_destroy(&var_event);
        }

        switch_core_destroy_memory_pool(&pool);

        return status;

}

switch_ivr_generate_json_cdr()

switch_status_t switch_ivr_generate_json_cdr	(	switch_core_session_t *	session,
		cJSON **	json_cdr,
		switch_bool_t	urlencode
	)

Generate an JSON CDR report.

Parameters

session	the session to get the data from.
json_cdr	pointer to the json object

Returns

SWITCH_STATUS_SUCCESS if successful

Note

on success the json object must be freed

Definition at line 3335 of file switch_ivr.c.

References switch_channel_timetable::answered, switch_app_log::app, switch_caller_application::application_data, switch_caller_application::application_name, switch_caller_extension::applications, switch_app_log::arg, switch_channel_timetable::bridged, switch_caller_profile::caller_extension, switch_caller_extension::children, switch_channel_timetable::created, switch_caller_extension::current_application, switch_caller_profile::dialplan, switch_caller_extension::extension_name, switch_caller_extension::extension_number, switch_channel_timetable::hold_accum, switch_channel_timetable::hungup, switch_channel_timetable::last_hold, switch_app_log::next, switch_caller_profile::next, switch_caller_application::next, switch_caller_profile::originatee_caller_profile, switch_caller_profile::originator_caller_profile, switch_channel_timetable::profile_created, switch_caller_profile::profile_index, switch_channel_timetable::progress, switch_channel_timetable::progress_media, switch_channel_timetable::resurrected, switch_app_log::stamp, SWITCH_CALL_DIRECTION_OUTBOUND, switch_channel_direction(), switch_channel_get_caller_profile(), switch_channel_get_cap_string(), switch_channel_get_flag_string(), switch_channel_get_state(), switch_channel_state_name(), switch_core_get_switchname(), switch_core_get_uuid(), switch_core_session_get_app_log(), switch_core_session_get_channel(), switch_ivr_set_json_call_stats(), switch_ivr_set_json_chan_vars(), switch_ivr_set_json_profile_data(), SWITCH_MEDIA_TYPE_AUDIO, SWITCH_MEDIA_TYPE_VIDEO, switch_snprintf(), SWITCH_STATUS_SUCCESS, switch_str_nil, SWITCH_TIME_T_FMT, switch_caller_profile::times, switch_channel_timetable::transferred, and zstr.

Referenced by switch_ivr_multi_threaded_bridge(), and switch_ivr_originate().

{
        cJSON *cdr = cJSON_CreateObject();
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_caller_profile_t *caller_profile;
        cJSON *variables, *j_main_cp, *j_caller_profile, *j_caller_extension, *j_caller_extension_apps, *j_times, *j_application,
                *j_callflow, *j_profile, *j_inner_extension, *j_app_log, *j_apps, *j_o, *j_o_profiles, *j_channel_data, *callStats;
        switch_app_log_t *app_log;
        char tmp[512], *f;

        cJSON_AddItemToObject(cdr, "core-uuid", cJSON_CreateString(switch_core_get_uuid()));
        cJSON_AddItemToObject(cdr, "switchname", cJSON_CreateString(switch_core_get_switchname()));
        j_channel_data = cJSON_CreateObject();

        cJSON_AddItemToObject(cdr, "channel_data", j_channel_data);

        cJSON_AddItemToObject(j_channel_data, "state", cJSON_CreateString((char *) switch_channel_state_name(switch_channel_get_state(channel))));
        cJSON_AddItemToObject(j_channel_data, "direction", cJSON_CreateString(switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND ? "outbound" : "inbound"));

        switch_snprintf(tmp, sizeof(tmp), "%d", switch_channel_get_state(channel));
        cJSON_AddItemToObject(j_channel_data, "state_number", cJSON_CreateString((char *) tmp));

        if ((f = switch_channel_get_flag_string(channel))) {
                cJSON_AddItemToObject(j_channel_data, "flags", cJSON_CreateString((char *) f));
                free(f);
        }

        if ((f = switch_channel_get_cap_string(channel))) {
                cJSON_AddItemToObject(j_channel_data, "caps", cJSON_CreateString((char *) f));
                free(f);
        }

        callStats = cJSON_CreateObject();
        cJSON_AddItemToObject(cdr, "callStats", callStats);
        switch_ivr_set_json_call_stats(callStats, session, SWITCH_MEDIA_TYPE_AUDIO);
        switch_ivr_set_json_call_stats(callStats, session, SWITCH_MEDIA_TYPE_VIDEO);

        variables = cJSON_CreateObject();
        cJSON_AddItemToObject(cdr, "variables", variables);
        switch_ivr_set_json_chan_vars(variables, channel, urlencode);


        if ((app_log = switch_core_session_get_app_log(session))) {
                switch_app_log_t *ap;

                j_app_log = cJSON_CreateObject();
                j_apps = cJSON_CreateArray();

                cJSON_AddItemToObject(cdr, "app_log", j_app_log);
                cJSON_AddItemToObject(j_app_log, "applications", j_apps);

                for (ap = app_log; ap; ap = ap->next) {
                        j_application = cJSON_CreateObject();

                        cJSON_AddItemToObject(j_application, "app_name", cJSON_CreateString(ap->app));
                        cJSON_AddItemToObject(j_application, "app_data", cJSON_CreateString(ap->arg));
                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, ap->stamp);
                        cJSON_AddItemToObject(j_application, "app_stamp", cJSON_CreateString(tmp));

                        cJSON_AddItemToArray(j_apps, j_application);
                }
        }


        caller_profile = switch_channel_get_caller_profile(channel);

        j_callflow = cJSON_CreateArray();
        cJSON_AddItemToObject(cdr, "callflow", j_callflow);

        while (caller_profile) {

                j_profile = cJSON_CreateObject();

                if (!zstr(caller_profile->dialplan)) {
                        cJSON_AddItemToObject(j_profile, "dialplan", cJSON_CreateString((char *)caller_profile->dialplan));
                }

                if (!zstr(caller_profile->profile_index)) {
                        cJSON_AddItemToObject(j_profile, "profile_index", cJSON_CreateString((char *)caller_profile->profile_index));
                }

                if (caller_profile->caller_extension) {
                        switch_caller_application_t *ap;

                        j_caller_extension = cJSON_CreateObject();
                        j_caller_extension_apps = cJSON_CreateArray();

                        cJSON_AddItemToObject(j_profile, "extension", j_caller_extension);

                        cJSON_AddItemToObject(j_caller_extension, "name", cJSON_CreateString(caller_profile->caller_extension->extension_name));
                        cJSON_AddItemToObject(j_caller_extension, "number", cJSON_CreateString(caller_profile->caller_extension->extension_number));
                        cJSON_AddItemToObject(j_caller_extension, "applications", j_caller_extension_apps);

                        if (caller_profile->caller_extension->current_application) {
                                cJSON_AddItemToObject(j_caller_extension, "current_app", cJSON_CreateString(caller_profile->caller_extension->current_application->application_name));
                        }

                        for (ap = caller_profile->caller_extension->applications; ap; ap = ap->next) {
                                j_application = cJSON_CreateObject();

                                cJSON_AddItemToArray(j_caller_extension_apps, j_application);

                                if (ap == caller_profile->caller_extension->current_application) {
                                        cJSON_AddItemToObject(j_application, "last_executed", cJSON_CreateString("true"));
                                }
                                cJSON_AddItemToObject(j_application, "app_name", cJSON_CreateString(ap->application_name));
                                cJSON_AddItemToObject(j_application, "app_data", cJSON_CreateString(switch_str_nil(ap->application_data)));
                        }

                        if (caller_profile->caller_extension->children) {
                                switch_caller_profile_t *cp = NULL;
                                j_inner_extension = cJSON_CreateArray();
                                cJSON_AddItemToObject(j_caller_extension, "sub_extensions", j_inner_extension);
                                for (cp = caller_profile->caller_extension->children; cp; cp = cp->next) {

                                        if (!cp->caller_extension) {
                                                continue;
                                        }

                                        j_caller_extension = cJSON_CreateObject();
                                        cJSON_AddItemToArray(j_inner_extension, j_caller_extension);

                                        cJSON_AddItemToObject(j_caller_extension, "name", cJSON_CreateString(cp->caller_extension->extension_name));
                                        cJSON_AddItemToObject(j_caller_extension, "number", cJSON_CreateString(cp->caller_extension->extension_number));

                                        cJSON_AddItemToObject(j_caller_extension, "dialplan", cJSON_CreateString((char *)cp->dialplan));

                                        if (cp->caller_extension->current_application) {
                                                cJSON_AddItemToObject(j_caller_extension, "current_app", cJSON_CreateString(cp->caller_extension->current_application->application_name));
                                        }

                                        j_caller_extension_apps = cJSON_CreateArray();
                                        cJSON_AddItemToObject(j_caller_extension, "applications", j_caller_extension_apps);
                                        for (ap = cp->caller_extension->applications; ap; ap = ap->next) {
                                                j_application = cJSON_CreateObject();
                                                cJSON_AddItemToArray(j_caller_extension_apps, j_application);

                                                if (ap == cp->caller_extension->current_application) {
                                                        cJSON_AddItemToObject(j_application, "last_executed", cJSON_CreateString("true"));
                                                }
                                                cJSON_AddItemToObject(j_application, "app_name", cJSON_CreateString(ap->application_name));
                                                cJSON_AddItemToObject(j_application, "app_data", cJSON_CreateString(switch_str_nil(ap->application_data)));
                                        }
                                }
                        }
                }

                j_main_cp = cJSON_CreateObject();
                cJSON_AddItemToObject(j_profile, "caller_profile", j_main_cp);

                switch_ivr_set_json_profile_data(j_main_cp, caller_profile);

                if (caller_profile->originator_caller_profile) {
                        switch_caller_profile_t *cp = NULL;

                        j_o = cJSON_CreateObject();
                        cJSON_AddItemToObject(j_main_cp, "originator", j_o);

                        j_o_profiles = cJSON_CreateArray();
                        cJSON_AddItemToObject(j_o, "originator_caller_profiles", j_o_profiles);

                        for (cp = caller_profile->originator_caller_profile; cp; cp = cp->next) {
                                j_caller_profile = cJSON_CreateObject();
                                cJSON_AddItemToArray(j_o_profiles, j_caller_profile);

                                switch_ivr_set_json_profile_data(j_caller_profile, cp);
                        }
                }

                if (caller_profile->originatee_caller_profile) {
                        switch_caller_profile_t *cp = NULL;

                        j_o = cJSON_CreateObject();
                        cJSON_AddItemToObject(j_main_cp, "originatee", j_o);

                        j_o_profiles = cJSON_CreateArray();
                        cJSON_AddItemToObject(j_o, "originatee_caller_profiles", j_o_profiles);

                        for (cp = caller_profile->originatee_caller_profile; cp; cp = cp->next) {
                                j_caller_profile = cJSON_CreateObject();
                                cJSON_AddItemToArray(j_o_profiles, j_caller_profile);

                                switch_ivr_set_json_profile_data(j_caller_profile, cp);
                        }
                }

                if (caller_profile->times) {

                        j_times = cJSON_CreateObject();
                        cJSON_AddItemToObject(j_profile, "times", j_times);

                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->created);
                        cJSON_AddItemToObject(j_times, "created_time", cJSON_CreateString(tmp));

                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->profile_created);
                        cJSON_AddItemToObject(j_times, "profile_created_time", cJSON_CreateString(tmp));

                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->progress);
                        cJSON_AddItemToObject(j_times, "progress_time", cJSON_CreateString(tmp));

                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->progress_media);
                        cJSON_AddItemToObject(j_times, "progress_media_time", cJSON_CreateString(tmp));

                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->answered);
                        cJSON_AddItemToObject(j_times, "answered_time", cJSON_CreateString(tmp));

                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->bridged);
                        cJSON_AddItemToObject(j_times, "bridged_time", cJSON_CreateString(tmp));

                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->last_hold);
                        cJSON_AddItemToObject(j_times, "last_hold_time", cJSON_CreateString(tmp));

                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->hold_accum);
                        cJSON_AddItemToObject(j_times, "hold_accum_time", cJSON_CreateString(tmp));

                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->hungup);
                        cJSON_AddItemToObject(j_times, "hangup_time", cJSON_CreateString(tmp));

                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->resurrected);
                        cJSON_AddItemToObject(j_times, "resurrect_time", cJSON_CreateString(tmp));

                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->transferred);
                        cJSON_AddItemToObject(j_times, "transfer_time", cJSON_CreateString(tmp));

                }
                cJSON_AddItemToArray(j_callflow, j_profile);
                caller_profile = caller_profile->next;
        }

        *json_cdr = cdr;

        return SWITCH_STATUS_SUCCESS;

}

switch_ivr_generate_xml_cdr()

switch_status_t switch_ivr_generate_xml_cdr	(	switch_core_session_t *	session,
		switch_xml_t *	xml_cdr
	)

Generate an XML CDR report.

Parameters

session	the session to get the data from.
xml_cdr	pointer to the xml_record

Returns

SWITCH_STATUS_SUCCESS if successful

Note

on success the xml object must be freed

Definition at line 2862 of file switch_ivr.c.

References switch_channel_timetable::answered, switch_app_log::app, switch_caller_application::application_data, switch_caller_application::application_name, switch_caller_extension::applications, switch_app_log::arg, switch_channel_timetable::bridged, switch_caller_profile::caller_extension, switch_caller_extension::children, switch_caller_profile::clone_of, switch_channel_timetable::created, switch_caller_extension::current_application, switch_caller_profile::dialplan, switch_caller_extension::extension_name, switch_caller_extension::extension_number, switch_channel_timetable::hold_accum, switch_channel_timetable::hungup, switch_channel_timetable::last_hold, switch_app_log::next, switch_hold_record_s::next, switch_caller_profile::next, switch_caller_application::next, switch_caller_profile::originatee_caller_profile, switch_caller_profile::origination_caller_profile, switch_caller_profile::originator_caller_profile, switch_channel_timetable::profile_created, switch_caller_profile::profile_index, switch_channel_timetable::progress, switch_channel_timetable::progress_media, switch_channel_timetable::resurrected, switch_app_log::stamp, SWITCH_CALL_DIRECTION_OUTBOUND, switch_channel_direction(), switch_channel_get_caller_profile(), switch_channel_get_cap_string(), switch_channel_get_flag_string(), switch_channel_get_hold_record(), switch_channel_get_state(), switch_channel_state_name(), switch_core_get_switchname(), switch_core_get_uuid(), switch_core_session_get_app_log(), switch_core_session_get_channel(), switch_core_session_get_text_buffer(), switch_ivr_set_xml_call_stats(), switch_ivr_set_xml_chan_vars(), switch_ivr_set_xml_profile_data(), SWITCH_MEDIA_TYPE_AUDIO, SWITCH_MEDIA_TYPE_VIDEO, switch_snprintf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, SWITCH_TIME_T_FMT, switch_xml_add_child_d(), switch_xml_free(), switch_xml_new(), switch_xml_set_attr_d(), switch_xml_set_attr_d_buf(), switch_xml_set_txt_d(), switch_caller_profile::times, switch_channel_timetable::transferred, switch_caller_profile::uuid_str, and zstr.

Referenced by CoreSession::getXMLCDR(), process_device_hup(), switch_core_recovery_track(), switch_core_session_reporting_state(), switch_ivr_multi_threaded_bridge(), and switch_ivr_originate().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_caller_profile_t *caller_profile;
        switch_xml_t call_stats, variables, cdr, x_main_cp, x_caller_profile, x_caller_extension, x_times, time_tag,
                x_application, x_callflow, x_inner_extension, x_apps, x_o, x_channel_data, x_field, xhr, x_hold;
        switch_app_log_t *app_log;
        char tmp[512], *f;
        int cdr_off = 0, cd_off = 0;
        switch_hold_record_t *hold_record = switch_channel_get_hold_record(channel), *hr;
        const char *text_buffer = NULL;

        if (*xml_cdr) {
                cdr = *xml_cdr;
        } else {
                if (!(cdr = switch_xml_new("cdr"))) {
                        return SWITCH_STATUS_SUCCESS;
                }
        }

        switch_xml_set_attr_d(cdr, "core-uuid", switch_core_get_uuid());
        switch_xml_set_attr_d(cdr, "switchname", switch_core_get_switchname());

        if (!(x_channel_data = switch_xml_add_child_d(cdr, "channel_data", cdr_off++))) {
                goto error;
        }

        x_field = switch_xml_add_child_d(x_channel_data, "state", cd_off++);
        switch_xml_set_txt_d(x_field, switch_channel_state_name(switch_channel_get_state(channel)));

        x_field = switch_xml_add_child_d(x_channel_data, "direction", cd_off++);
        switch_xml_set_txt_d(x_field, switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND ? "outbound" : "inbound");


        if ((text_buffer = switch_core_session_get_text_buffer(session))) {
                x_field = switch_xml_add_child_d(x_channel_data, "textlog", cd_off++);
                switch_xml_set_txt_d(x_field, text_buffer);
        }

        x_field = switch_xml_add_child_d(x_channel_data, "state_number", cd_off++);
        switch_snprintf(tmp, sizeof(tmp), "%d", switch_channel_get_state(channel));
        switch_xml_set_txt_d(x_field, tmp);

        if ((f = switch_channel_get_flag_string(channel))) {
                x_field = switch_xml_add_child_d(x_channel_data, "flags", cd_off++);
                switch_xml_set_txt_d(x_field, f);
                free(f);
        }

        if ((f = switch_channel_get_cap_string(channel))) {
                x_field = switch_xml_add_child_d(x_channel_data, "caps", cd_off++);
                switch_xml_set_txt_d(x_field, f);
                free(f);
        }

        if (!(call_stats = switch_xml_add_child_d(cdr, "call-stats", cdr_off++))) {
                goto error;
        }

        switch_ivr_set_xml_call_stats(call_stats, session, 0, SWITCH_MEDIA_TYPE_AUDIO);
        switch_ivr_set_xml_call_stats(call_stats, session, 0, SWITCH_MEDIA_TYPE_VIDEO);


        if (!(variables = switch_xml_add_child_d(cdr, "variables", cdr_off++))) {
                goto error;
        }

        switch_ivr_set_xml_chan_vars(variables, channel, 0);


        if ((app_log = switch_core_session_get_app_log(session))) {
                int app_off = 0;
                switch_app_log_t *ap;

                if (!(x_apps = switch_xml_add_child_d(cdr, "app_log", cdr_off++))) {
                        goto error;
                }
                for (ap = app_log; ap; ap = ap->next) {
                        char tmp[128];

                        if (!(x_application = switch_xml_add_child_d(x_apps, "application", app_off++))) {
                                goto error;
                        }

                        switch_xml_set_attr_d(x_application, "app_name", ap->app);
                        switch_xml_set_attr_d(x_application, "app_data", ap->arg);

                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, ap->stamp);
                        switch_xml_set_attr_d_buf(x_application, "app_stamp", tmp);
                }
        }

        if (hold_record) {
                int cf_off = 0;

                if (!(xhr = switch_xml_add_child_d(cdr, "hold-record", cdr_off++))) {
                        goto error;
                }

                for (hr = hold_record; hr; hr = hr->next) {
                        char *t = tmp;
                        if (!(x_hold = switch_xml_add_child_d(xhr, "hold", cf_off++))) {
                                goto error;
                        }

                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, hr->on);
                        switch_xml_set_attr_d(x_hold, "on", t);

                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, hr->off);
                        switch_xml_set_attr_d(x_hold, "off", t);

                        if (hr->uuid) {
                                switch_xml_set_attr_d(x_hold, "bridged-to", hr->uuid);
                        }


                }


        }



        caller_profile = switch_channel_get_caller_profile(channel);

        while (caller_profile) {
                int cf_off = 0;
                int cp_off = 0;

                if (!(x_callflow = switch_xml_add_child_d(cdr, "callflow", cdr_off++))) {
                        goto error;
                }

                if (!zstr(caller_profile->dialplan)) {
                        switch_xml_set_attr_d(x_callflow, "dialplan", caller_profile->dialplan);
                }

                if (!zstr(caller_profile->uuid_str)) {
                        switch_xml_set_attr_d(x_callflow, "unique-id", caller_profile->uuid_str);
                }

                if (!zstr(caller_profile->clone_of)) {
                        switch_xml_set_attr_d(x_callflow, "clone-of", caller_profile->clone_of);
                }

                if (!zstr(caller_profile->profile_index)) {
                        switch_xml_set_attr_d(x_callflow, "profile_index", caller_profile->profile_index);
                }

                if (caller_profile->caller_extension) {
                        switch_caller_application_t *ap;
                        int app_off = 0;

                        if (!(x_caller_extension = switch_xml_add_child_d(x_callflow, "extension", cf_off++))) {
                                goto error;
                        }

                        switch_xml_set_attr_d(x_caller_extension, "name", caller_profile->caller_extension->extension_name);
                        switch_xml_set_attr_d(x_caller_extension, "number", caller_profile->caller_extension->extension_number);
                        if (caller_profile->caller_extension->current_application) {
                                switch_xml_set_attr_d(x_caller_extension, "current_app", caller_profile->caller_extension->current_application->application_name);
                        }

                        for (ap = caller_profile->caller_extension->applications; ap; ap = ap->next) {
                                if (!(x_application = switch_xml_add_child_d(x_caller_extension, "application", app_off++))) {
                                        goto error;
                                }
                                if (ap == caller_profile->caller_extension->current_application) {
                                        switch_xml_set_attr_d(x_application, "last_executed", "true");
                                }
                                switch_xml_set_attr_d(x_application, "app_name", ap->application_name);
                                switch_xml_set_attr_d(x_application, "app_data", ap->application_data);
                        }

                        if (caller_profile->caller_extension->children) {
                                switch_caller_profile_t *cp = NULL;
                                int i_off = 0, i_app_off = 0;
                                for (cp = caller_profile->caller_extension->children; cp; cp = cp->next) {

                                        if (!cp->caller_extension) {
                                                continue;
                                        }
                                        if (!(x_inner_extension = switch_xml_add_child_d(x_caller_extension, "sub_extensions", app_off++))) {
                                                goto error;
                                        }

                                        if (!(x_caller_extension = switch_xml_add_child_d(x_inner_extension, "extension", i_off++))) {
                                                goto error;
                                        }
                                        switch_xml_set_attr_d(x_caller_extension, "name", cp->caller_extension->extension_name);
                                        switch_xml_set_attr_d(x_caller_extension, "number", cp->caller_extension->extension_number);
                                        switch_xml_set_attr_d(x_caller_extension, "dialplan", cp->dialplan);
                                        if (cp->caller_extension->current_application) {
                                                switch_xml_set_attr_d(x_caller_extension, "current_app", cp->caller_extension->current_application->application_name);
                                        }

                                        for (ap = cp->caller_extension->applications; ap; ap = ap->next) {
                                                if (!(x_application = switch_xml_add_child_d(x_caller_extension, "application", i_app_off++))) {
                                                        goto error;
                                                }
                                                if (ap == cp->caller_extension->current_application) {
                                                        switch_xml_set_attr_d(x_application, "last_executed", "true");
                                                }
                                                switch_xml_set_attr_d(x_application, "app_name", ap->application_name);
                                                switch_xml_set_attr_d(x_application, "app_data", ap->application_data);
                                        }
                                }
                        }
                }

                if (!(x_main_cp = switch_xml_add_child_d(x_callflow, "caller_profile", cf_off++))) {
                        goto error;
                }

                cp_off += switch_ivr_set_xml_profile_data(x_main_cp, caller_profile, 0);

                if (caller_profile->origination_caller_profile) {
                        switch_caller_profile_t *cp = NULL;
                        int off = 0;
                        if (!(x_o = switch_xml_add_child_d(x_main_cp, "origination", cp_off++))) {
                                goto error;
                        }

                        for (cp = caller_profile->origination_caller_profile; cp; cp = cp->next) {
                                if (!(x_caller_profile = switch_xml_add_child_d(x_o, "origination_caller_profile", off++))) {
                                        goto error;
                                }
                                switch_ivr_set_xml_profile_data(x_caller_profile, cp, 0);
                        }
                }

                if (caller_profile->originator_caller_profile) {
                        switch_caller_profile_t *cp = NULL;
                        int off = 0;
                        if (!(x_o = switch_xml_add_child_d(x_main_cp, "originator", cp_off++))) {
                                goto error;
                        }

                        for (cp = caller_profile->originator_caller_profile; cp; cp = cp->next) {
                                if (!(x_caller_profile = switch_xml_add_child_d(x_o, "originator_caller_profile", off++))) {
                                        goto error;
                                }
                                switch_ivr_set_xml_profile_data(x_caller_profile, cp, 0);
                        }
                }

                if (caller_profile->originatee_caller_profile) {
                        switch_caller_profile_t *cp = NULL;
                        int off = 0;
                        if (!(x_o = switch_xml_add_child_d(x_main_cp, "originatee", cp_off++))) {
                                goto error;
                        }
                        for (cp = caller_profile->originatee_caller_profile; cp; cp = cp->next) {
                                if (!(x_caller_profile = switch_xml_add_child_d(x_o, "originatee_caller_profile", off++))) {
                                        goto error;
                                }
                                switch_ivr_set_xml_profile_data(x_caller_profile, cp, 0);
                        }
                }

                if (caller_profile->times) {
                        int t_off = 0;
                        if (!(x_times = switch_xml_add_child_d(x_callflow, "times", cf_off++))) {
                                goto error;
                        }
                        if (!(time_tag = switch_xml_add_child_d(x_times, "created_time", t_off++))) {
                                goto error;
                        }
                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->created);
                        switch_xml_set_txt_d(time_tag, tmp);

                        if (!(time_tag = switch_xml_add_child_d(x_times, "profile_created_time", t_off++))) {
                                goto error;
                        }
                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->profile_created);
                        switch_xml_set_txt_d(time_tag, tmp);

                        if (!(time_tag = switch_xml_add_child_d(x_times, "progress_time", t_off++))) {
                                goto error;
                        }
                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->progress);
                        switch_xml_set_txt_d(time_tag, tmp);


                        if (!(time_tag = switch_xml_add_child_d(x_times, "progress_media_time", t_off++))) {
                                goto error;
                        }
                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->progress_media);
                        switch_xml_set_txt_d(time_tag, tmp);

                        if (!(time_tag = switch_xml_add_child_d(x_times, "answered_time", t_off++))) {
                                goto error;
                        }
                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->answered);
                        switch_xml_set_txt_d(time_tag, tmp);

                        if (!(time_tag = switch_xml_add_child_d(x_times, "bridged_time", t_off++))) {
                                goto error;
                        }
                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->bridged);
                        switch_xml_set_txt_d(time_tag, tmp);

                        if (!(time_tag = switch_xml_add_child_d(x_times, "last_hold_time", t_off++))) {
                                goto error;
                        }
                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->last_hold);
                        switch_xml_set_txt_d(time_tag, tmp);

                        if (!(time_tag = switch_xml_add_child_d(x_times, "hold_accum_time", t_off++))) {
                                goto error;
                        }
                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->hold_accum);
                        switch_xml_set_txt_d(time_tag, tmp);

                        if (!(time_tag = switch_xml_add_child_d(x_times, "hangup_time", t_off++))) {
                                goto error;
                        }
                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->hungup);
                        switch_xml_set_txt_d(time_tag, tmp);

                        if (!(time_tag = switch_xml_add_child_d(x_times, "resurrect_time", t_off++))) {
                                goto error;
                        }
                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->resurrected);
                        switch_xml_set_txt_d(time_tag, tmp);

                        if (!(time_tag = switch_xml_add_child_d(x_times, "transfer_time", t_off++))) {
                                goto error;
                        }
                        switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->transferred);
                        switch_xml_set_txt_d(time_tag, tmp);
                }

                caller_profile = caller_profile->next;
        }

        *xml_cdr = cdr;

        return SWITCH_STATUS_SUCCESS;

  error:

        if (cdr) {
                switch_xml_free(cdr);
        }

        return SWITCH_STATUS_FALSE;
}

switch_ivr_gentones()

switch_status_t switch_ivr_gentones	(	switch_core_session_t *	session,
		const char *	script,
		int32_t	loops,
		switch_input_args_t *	args
	)

Definition at line 1073 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, teletone_generation_session::channels, switch_frame::codec, switch_frame::data, switch_frame::datalen, switch_codec_implementation::decoded_bytes_per_packet, switch_dtmf_t::digit, switch_input_args_t::dmachine, switch_input_args_t::input_callback, memset(), switch_codec_implementation::microseconds_per_packet, switch_codec_implementation::number_of_channels, teletone_generation_session::rate, switch_input_args_t::read_frame_callback, switch_frame::samples, switch_buffer_create_dynamic(), switch_buffer_destroy(), switch_buffer_read_loop(), switch_buffer_set_loops(), switch_channel_clear_flag(), switch_channel_dequeue_dtmf(), switch_channel_has_dtmf(), switch_channel_pre_answer, switch_channel_ready, switch_channel_test_flag(), SWITCH_CODEC_FLAG_DECODE, SWITCH_CODEC_FLAG_ENCODE, switch_core_codec_destroy(), switch_core_codec_init, 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_write_frame(), switch_event_destroy(), SWITCH_FALSE, SWITCH_INPUT_TYPE_DTMF, SWITCH_INPUT_TYPE_EVENT, SWITCH_IO_FLAG_NONE, switch_ivr_dmachine_feed(), switch_ivr_dmachine_ping(), switch_ivr_parse_all_events(), SWITCH_READ_ACCEPTABLE, SWITCH_RECOMMENDED_BUFFER_SIZE, SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, teletone_destroy_session(), teletone_handler(), teletone_init_session(), teletone_run(), and switch_input_args_t::user_data.

Referenced by enterprise_originate_ringback_thread().

{
        teletone_generation_session_t ts;
        switch_dtmf_t dtmf = { 0 };
        switch_buffer_t *audio_buffer;
        switch_frame_t *read_frame = NULL;
        switch_codec_t write_codec = { 0 };
        switch_frame_t write_frame = { 0 };
        switch_byte_t data[SWITCH_RECOMMENDED_BUFFER_SIZE];
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_codec_implementation_t read_impl = { 0 };
        switch_core_session_get_read_impl(session, &read_impl);

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

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

                return SWITCH_STATUS_FALSE;
        }

        arg_recursion_check_start(args);

        memset(&ts, 0, sizeof(ts));
        write_frame.codec = &write_codec;
        write_frame.data = data;
        write_frame.buflen = sizeof(data);

        switch_buffer_create_dynamic(&audio_buffer, 512, 1024, 0);
        teletone_init_session(&ts, 0, teletone_handler, audio_buffer);
        ts.rate = read_impl.actual_samples_per_second;
        ts.channels = read_impl.number_of_channels;
        teletone_run(&ts, script);

        if (loops) {
                switch_buffer_set_loops(audio_buffer, loops);
        }

        for (;;) {
                switch_status_t status;

                if (!switch_channel_ready(channel)) {
                        break;
                }

                if (switch_channel_test_flag(channel, CF_BREAK)) {
                        switch_channel_clear_flag(channel, CF_BREAK);
                        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;
                        }
                }

                switch_ivr_parse_all_events(session);

                if (args) {
                        /*
                           dtmf handler function you can hook up to be executed when a digit is dialed during gentones
                           if you return anything but SWITCH_STATUS_SUCCESS the playback will stop.
                         */
                        if (switch_channel_has_dtmf(channel)) {
                                if (!args->input_callback && !args->buf && !args->dmachine) {
                                        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;

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

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

                if ((write_frame.datalen = (uint32_t) switch_buffer_read_loop(audio_buffer, write_frame.data, read_impl.decoded_bytes_per_packet)) <= 0) {
                        break;
                }

                write_frame.samples = write_frame.datalen / 2;

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

        switch_core_codec_destroy(&write_codec);
        switch_buffer_destroy(&audio_buffer);
        teletone_destroy_session(&ts);

        arg_recursion_check_stop(args);

        return SWITCH_STATUS_SUCCESS;
}

switch_ivr_hold()

switch_status_t switch_ivr_hold	(	switch_core_session_t *	session,
		const char *	message,
		switch_bool_t	moh
	)

Signal the session with a protocol specific hold message.

Parameters

session	the session to hold
message	optional message
moh	play music-on-hold

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 1525 of file switch_ivr.c.

References CCS_HELD, CF_HOLD, CF_SUSPEND, switch_core_session_message::from, switch_core_session_message::message_id, SMF_ECHO_ALEG, SMF_LOOP, switch_core_session_message::string_arg, switch_channel_event_set_data(), switch_channel_get_callstate(), switch_channel_get_hold_music(), switch_channel_get_partner_uuid(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_core_session_get_channel(), switch_core_session_receive_message, SWITCH_EVENT_CHANNEL_HOLD, switch_event_create, switch_event_fire, switch_ivr_broadcast(), switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_MESSAGE_INDICATE_HOLD, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_ivr_hold_toggle_uuid(), and switch_ivr_hold_uuid().

{
        switch_core_session_message_t msg = { 0 };
        switch_channel_t *channel = switch_core_session_get_channel(session);
        const char *stream;
        const char *other_uuid;
        switch_event_t *event;

        if (channel) {
                switch_channel_callstate_t callstate;

                callstate = switch_channel_get_callstate(channel);
                if (callstate == CCS_HELD) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Call is already on hold. No need to hold again.\n");
                        return SWITCH_STATUS_FALSE;
                }
        }

        msg.message_id = SWITCH_MESSAGE_INDICATE_HOLD;
        msg.string_arg = message;
        msg.from = __FILE__;

        switch_channel_set_flag(channel, CF_HOLD);
        switch_channel_set_flag(channel, CF_SUSPEND);

        switch_core_session_receive_message(session, &msg);

        if (moh && (stream = switch_channel_get_hold_music(channel))) {
                if ((other_uuid = switch_channel_get_partner_uuid(channel))) {
                        switch_ivr_broadcast(other_uuid, stream, SMF_ECHO_ALEG | SMF_LOOP);
                }
        }

        if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_HOLD) == SWITCH_STATUS_SUCCESS) {
                switch_channel_event_set_data(channel, event);
                switch_event_fire(&event);
        }


        return SWITCH_STATUS_SUCCESS;
}

switch_ivr_hold_toggle_uuid()

switch_status_t switch_ivr_hold_toggle_uuid	(	const char *	uuid,
		const char *	message,
		switch_bool_t	moh
	)

Toggles channel hold state of session.

Parameters

uuid	the uuid of the session to hold
message	optional message
moh	play music-on-hold

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 1580 of file switch_ivr.c.

References CCS_ACTIVE, CCS_HELD, CCS_UNHELD, switch_channel_get_callstate(), switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_rwunlock(), switch_ivr_hold(), switch_ivr_unhold(), and SWITCH_STATUS_SUCCESS.

{
        switch_core_session_t *session;
        switch_channel_t *channel;
        switch_channel_callstate_t callstate;
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        if ((session = switch_core_session_locate(uuid))) {
                if ((channel = switch_core_session_get_channel(session))) {
                        callstate = switch_channel_get_callstate(channel);

                        if (callstate == CCS_ACTIVE || callstate == CCS_UNHELD) {
                                status = switch_ivr_hold(session, message, moh);
                        } else if (callstate == CCS_HELD) {
                                status = switch_ivr_unhold(session);
                        }
                }
                switch_core_session_rwunlock(session);
        }

        return status;
}

switch_ivr_hold_uuid()

switch_status_t switch_ivr_hold_uuid	(	const char *	uuid,
		const char *	message,
		switch_bool_t	moh
	)

Signal the session with a protocol specific hold message.

Parameters

uuid	the uuid of the session to hold
message	optional message
moh	play music-on-hold

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 1567 of file switch_ivr.c.

References switch_core_session_locate, switch_core_session_rwunlock(), switch_ivr_hold(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_media_toggle_hold().

{
        switch_core_session_t *session;
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        if ((session = switch_core_session_locate(uuid))) {
                status = switch_ivr_hold(session, message, moh);
                switch_core_session_rwunlock(session);
        }

        return status;
}

switch_ivr_inband_dtmf_generate_session()

switch_status_t switch_ivr_inband_dtmf_generate_session	(	switch_core_session_t *	session,
		switch_bool_t	read_stream
	)

Start generating DTMF inband.

Parameters

session	the session to generate on
read_stream	true to use the session we are reading from, false for the session we are writing to.

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 4090 of file switch_ivr_async.c.

References inband_dtmf_generate_callback(), switch_inband_dtmf_generate_t::read, switch_inband_dtmf_generate_t::session, SMBF_NO_PAUSE, SMBF_READ_REPLACE, SMBF_WRITE_REPLACE, switch_channel_media_up, switch_channel_pre_answer, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_private(), switch_core_media_bug_add(), switch_core_session_alloc, switch_core_session_get_channel(), switch_core_session_get_read_codec(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_MEMERR, and SWITCH_STATUS_SUCCESS.

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_media_bug_t *bug;
        switch_status_t status;
        switch_inband_dtmf_generate_t *pvt;

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

        if (!switch_channel_media_up(channel) || !switch_core_session_get_read_codec(session)) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Can not install inband dtmf generate.  Media not enabled on channel\n");
                return status;
        }

        if (!(pvt = switch_core_session_alloc(session, sizeof(*pvt)))) {
                return SWITCH_STATUS_MEMERR;
        }

        pvt->session = session;
        pvt->read = !!read_stream;

        if ((status = switch_core_media_bug_add(session, "inband_dtmf_generate", NULL,
                                                                                        inband_dtmf_generate_callback, pvt, 0,
                                                                                        SMBF_NO_PAUSE | (pvt->read ? SMBF_READ_REPLACE : SMBF_WRITE_REPLACE) , &bug)) != SWITCH_STATUS_SUCCESS) {
                return status;
        }

        switch_channel_set_private(channel, "dtmf_generate", bug);

        return SWITCH_STATUS_SUCCESS;
}

switch_ivr_inband_dtmf_session()

switch_status_t switch_ivr_inband_dtmf_session

(

switch_core_session_t *

session

)

Start looking for DTMF inband.

Parameters

session

the session to start looking

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 3854 of file switch_ivr_async.c.

References switch_codec_implementation::actual_samples_per_second, switch_inband_dtmf_t::dtmf_detect, inband_dtmf_callback(), switch_inband_dtmf_t::session, SMBF_NO_PAUSE, SMBF_ONE_ONLY, SMBF_READ_REPLACE, switch_channel_pre_answer, switch_channel_set_private(), switch_core_media_bug_add(), switch_core_session_alloc, switch_core_session_get_channel(), switch_core_session_get_read_impl(), SWITCH_STATUS_FALSE, SWITCH_STATUS_MEMERR, SWITCH_STATUS_SUCCESS, and teletone_dtmf_detect_init().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_media_bug_t *bug;
        switch_status_t status;
        switch_inband_dtmf_t *pvt;
        switch_codec_implementation_t read_impl = { 0 };

        switch_core_session_get_read_impl(session, &read_impl);

        if (!(pvt = switch_core_session_alloc(session, sizeof(*pvt)))) {
                return SWITCH_STATUS_MEMERR;
        }

        teletone_dtmf_detect_init(&pvt->dtmf_detect, read_impl.actual_samples_per_second);

        pvt->session = session;


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

        if ((status = switch_core_media_bug_add(session, "inband_dtmf", NULL,
                                                                                        inband_dtmf_callback, pvt, 0, SMBF_READ_REPLACE | SMBF_NO_PAUSE | SMBF_ONE_ONLY, &bug)) != SWITCH_STATUS_SUCCESS) {
                return status;
        }

        switch_channel_set_private(channel, "dtmf", bug);

        return SWITCH_STATUS_SUCCESS;
}

switch_ivr_media()

switch_status_t switch_ivr_media	(	const char *	uuid,
		switch_media_flag_t	flags
	)

Signal a session to request direct media access to it's remote end.

Parameters

uuid	the uuid of the session to request
flags	flags to influence behaviour (SMF_REBRIDGE to rebridge the call in media mode)

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 1773 of file switch_ivr.c.

References CF_BRIDGE_ORIGINATOR, CF_BRIDGED, CF_EARLY_MEDIA, CF_MEDIA_ACK, CF_MEDIA_SET, CF_MEDIA_TRANS, CF_PROXY_MODE, CF_REQ_MEDIA, switch_core_session_message::from, switch_core_session_message::message_id, switch_core_session_message::numeric_arg, SMF_IMMEDIATE, SMF_REBRIDGE, SMF_REPLYONLY_A, SMF_REPLYONLY_B, switch_assert, switch_channel_clear_flag(), switch_channel_clear_state_handler(), switch_channel_get_name(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_test_flag(), switch_channel_wait_for_flag(), switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_read_frame(), switch_core_session_receive_message, switch_core_session_rwunlock(), SWITCH_FALSE, SWITCH_IO_FLAG_NONE, switch_ivr_uuid_bridge(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_MESSAGE_INDICATE_CLEAR_PROGRESS, SWITCH_MESSAGE_INDICATE_MEDIA, SWITCH_SIGNAL_BRIDGE_VARIABLE, SWITCH_STATUS_GENERR, SWITCH_STATUS_INUSE, SWITCH_STATUS_SUCCESS, SWITCH_TRUE, and switch_yield.

Referenced by cleanup_proxy_mode_b(), media_thread_run(), switch_core_session_execute_application_get_flags(), switch_core_standard_on_routing(), switch_ivr_broadcast(), switch_ivr_originate(), and switch_ivr_session_transfer().

{
        const char *other_uuid = NULL;
        switch_channel_t *channel, *other_channel = NULL;
        switch_core_session_t *session, *other_session;
        switch_core_session_message_t msg = { 0 };
        switch_status_t status = SWITCH_STATUS_GENERR;
        uint8_t swap = 0;
        switch_frame_t *read_frame = NULL;

        msg.message_id = SWITCH_MESSAGE_INDICATE_MEDIA;
        msg.from = __FILE__;

        if ((session = switch_core_session_locate(uuid))) {
                channel = switch_core_session_get_channel(session);

                if (switch_channel_test_flag(channel, CF_MEDIA_TRANS)) {
                        switch_core_session_rwunlock(session);

                        return SWITCH_STATUS_INUSE;
                }

                switch_channel_set_flag(channel, CF_MEDIA_TRANS);

                if ((flags & SMF_REBRIDGE) && !switch_channel_test_flag(channel, CF_BRIDGE_ORIGINATOR)) {
                        swap = 1;
                }

                if (switch_channel_test_flag(channel, CF_PROXY_MODE)) {
                        switch_status_t res = SWITCH_STATUS_SUCCESS;

                        status = SWITCH_STATUS_SUCCESS;

                        /* If we had early media in bypass mode before, it is no longer relevant */
                        if (switch_channel_test_flag(channel, CF_EARLY_MEDIA)) {
                                switch_core_session_message_t msg2 = { 0 };

                                msg2.message_id = SWITCH_MESSAGE_INDICATE_CLEAR_PROGRESS;
                                msg2.from = __FILE__;
                                switch_core_session_receive_message(session, &msg2);
                        }

                        if ((flags & SMF_REPLYONLY_A)) {
                                msg.numeric_arg = 1;
                        }

                        if (switch_core_session_receive_message(session, &msg) != SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Can't re-establsh media on %s\n", switch_channel_get_name(channel));
                                switch_core_session_rwunlock(session);

                                return SWITCH_STATUS_GENERR;
                        }

                        if ((flags & SMF_REPLYONLY_B)) {
                                msg.numeric_arg = 1;
                        } else {
                                msg.numeric_arg = 0;
                        }

                        if ((flags & SMF_IMMEDIATE)) {
                                switch_channel_wait_for_flag(channel, CF_REQ_MEDIA, SWITCH_FALSE, 250, NULL);
                                switch_yield(250000);
                        } else {
                                switch_channel_wait_for_flag(channel, CF_REQ_MEDIA, SWITCH_FALSE, 10000, NULL);
                                switch_channel_wait_for_flag(channel, CF_MEDIA_ACK, SWITCH_TRUE, 10000, NULL);
                                switch_channel_wait_for_flag(channel, CF_MEDIA_SET, SWITCH_TRUE, 10000, NULL);
                                res = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
                        }

                        if ((flags & SMF_REBRIDGE)
                                && (other_uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BRIDGE_VARIABLE))
                                && (other_session = switch_core_session_locate(other_uuid))) {
                                other_channel = switch_core_session_get_channel(other_session);
                                switch_assert(other_channel != NULL);
                                switch_core_session_receive_message(other_session, &msg);
                                switch_channel_wait_for_flag(other_channel, CF_REQ_MEDIA, SWITCH_FALSE, 10000, NULL);
                                switch_channel_wait_for_flag(other_channel, CF_MEDIA_ACK, SWITCH_TRUE, 10000, NULL);
                                switch_channel_wait_for_flag(other_channel, CF_MEDIA_SET, SWITCH_TRUE, 10000, NULL);
                                res = switch_core_session_read_frame(other_session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
                                switch_channel_clear_state_handler(other_channel, NULL);
                                switch_core_session_rwunlock(other_session);
                        }

                        (void)res;

                        if (other_channel) {
                                switch_channel_clear_state_handler(channel, NULL);
                        }
                }

                switch_channel_clear_flag(channel, CF_MEDIA_TRANS);
                switch_core_session_rwunlock(session);

                if (other_channel) {
                        if (swap) {
                                switch_ivr_uuid_bridge(other_uuid, uuid);
                        } else {
                                switch_ivr_uuid_bridge(uuid, other_uuid);
                        }

                        switch_channel_wait_for_flag(channel, CF_BRIDGED, SWITCH_TRUE, 1000, NULL);
                        switch_channel_wait_for_flag(other_channel, CF_BRIDGED, SWITCH_TRUE, 1000, NULL);
                }
        }

        return status;
}

switch_ivr_multi_threaded_bridge()

switch_status_t switch_ivr_multi_threaded_bridge	(	_In_ switch_core_session_t *	session,
		_In_ switch_core_session_t *	peer_session,
		switch_input_callback_function_t	dtmf_callback,
		void *	session_data,
		void *	peer_session_data
	)

Bridge Audio from one session to another.

Parameters

session	one session
peer_session	the other session
dtmf_callback	a callback for messages and dtmf
session_data	data to pass to the DTMF callback for session
peer_session_data	data to pass to the DTMF callback for peer_session

Returns

SWITCH_STATUS_SUCCESS if all is well

Referenced by bridge(), fs_switch_ivr_originate(), switch_ivr_enterprise_orig_and_bridge(), and switch_ivr_orig_and_bridge().

switch_ivr_nomedia()

switch_status_t switch_ivr_nomedia	(	const char *	uuid,
		switch_media_flag_t	flags
	)

Signal a session to request indirect media allowing it to exchange media directly with another device.

Parameters

uuid	the uuid of the session to request
flags	flags to influence behaviour (SMF_REBRIDGE to rebridge the call in no_media mode)

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 1987 of file switch_ivr.c.

References CF_BRIDGE_ORIGINATOR, CF_MEDIA_ACK, CF_MEDIA_SET, CF_MEDIA_TRANS, CF_PROXY_MODE, CF_REDIRECT, CF_REQ_MEDIA, CF_RESET, CF_SECURE, CS_HIBERNATE, CS_PARK, switch_core_session_message::from, switch_core_session_message::message_id, SMF_FORCE, SMF_REBRIDGE, SWITCH_BRIDGE_VARIABLE, switch_channel_clear_flag(), switch_channel_get_name(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_state, switch_channel_test_flag(), switch_channel_wait_for_flag(), switch_channel_wait_for_state(), switch_core_session_get_channel(), switch_core_session_in_thread(), switch_core_session_locate, switch_core_session_receive_message, switch_core_session_rwunlock(), SWITCH_FALSE, switch_ivr_signal_bridge(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_MESSAGE_INDICATE_NOMEDIA, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_INUSE, SWITCH_STATUS_SUCCESS, SWITCH_TRUE, and switch_yield.

Referenced by audio_bridge_thread(), media_thread_run(), and switch_ivr_parse_event().

{
        const char *other_uuid;
        switch_channel_t *channel, *other_channel = NULL;
        switch_core_session_t *session, *other_session = NULL;
        switch_core_session_message_t msg = { 0 };
        switch_status_t status = SWITCH_STATUS_GENERR;
        uint8_t swap = 0;

        msg.message_id = SWITCH_MESSAGE_INDICATE_NOMEDIA;
        msg.from = __FILE__;

        if ((session = switch_core_session_locate(uuid))) {

                status = SWITCH_STATUS_SUCCESS;
                channel = switch_core_session_get_channel(session);

                if (switch_channel_test_flag(channel, CF_SECURE)) {
                        switch_core_session_rwunlock(session);
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,
                                                          "Cannot bypass %s due to secure connection.\n", switch_channel_get_name(channel));
                        return SWITCH_STATUS_FALSE;
                }

                if (switch_channel_test_flag(channel, CF_MEDIA_TRANS)) {
                        switch_core_session_rwunlock(session);
                        return SWITCH_STATUS_INUSE;
                }

                switch_channel_set_flag(channel, CF_MEDIA_TRANS);

                if ((flags & SMF_REBRIDGE) && !switch_channel_test_flag(channel, CF_BRIDGE_ORIGINATOR)) {
                        swap = 1;
                }

                switch_channel_set_flag(channel, CF_REDIRECT);
                switch_channel_set_flag(channel, CF_RESET);

                if ((flags & SMF_FORCE) || !switch_channel_test_flag(channel, CF_PROXY_MODE)) {
                        if ((flags & SMF_REBRIDGE) && (other_uuid = switch_channel_get_variable(channel, SWITCH_BRIDGE_VARIABLE)) &&
                                (other_session = switch_core_session_locate(other_uuid))) {
                                other_channel = switch_core_session_get_channel(other_session);

                                switch_channel_set_flag(other_channel, CF_RESET);
                                switch_channel_set_flag(other_channel, CF_REDIRECT);

                                if (!switch_core_session_in_thread(session)) {
                                        switch_channel_set_state(channel, CS_PARK);
                                }
                                switch_channel_set_state(other_channel, CS_PARK);
                                if (switch_core_session_in_thread(session)) {
                                        switch_yield(100000);
                                } else {
                                        switch_channel_wait_for_state(other_channel, channel, CS_PARK);
                                }
                                switch_core_session_receive_message(other_session, &msg);
                                switch_channel_wait_for_flag(other_channel, CF_REQ_MEDIA, SWITCH_FALSE, 10000, NULL);
                                //switch_channel_wait_for_flag(other_channel, CF_MEDIA_ACK, SWITCH_TRUE, 10000, NULL);
                                switch_channel_wait_for_flag(other_channel, CF_MEDIA_SET, SWITCH_TRUE, 10000, NULL);
                        }

                        switch_core_session_receive_message(session, &msg);

                        if (other_channel) {
                                if (!switch_core_session_in_thread(session)) {
                                        switch_channel_wait_for_state(channel, NULL, CS_PARK);
                                        switch_channel_wait_for_flag(channel, CF_REQ_MEDIA, SWITCH_FALSE, 10000, NULL);
                                        switch_channel_wait_for_flag(channel, CF_MEDIA_ACK, SWITCH_TRUE, 10000, NULL);
                                        switch_channel_wait_for_flag(channel, CF_MEDIA_SET, SWITCH_TRUE, 10000, NULL);
                                }

                                if (swap) {
                                        switch_ivr_signal_bridge(other_session, session);
                                } else {
                                        switch_ivr_signal_bridge(session, other_session);
                                }

                                if (switch_core_session_in_thread(session)) {
                                        switch_yield(100000);
                                } else {
                                        switch_channel_wait_for_state(other_channel, channel, CS_HIBERNATE);
                                }

                                if (!switch_core_session_in_thread(session)) {
                                        switch_channel_wait_for_state(channel, other_channel, CS_HIBERNATE);
                                }
                                switch_core_session_rwunlock(other_session);
                        }
                }

                switch_channel_clear_flag(channel, CF_MEDIA_TRANS);
                switch_core_session_rwunlock(session);
        }



        return status;
}

switch_ivr_originate()

switch_status_t switch_ivr_originate	(	switch_core_session_t *	session,
		switch_core_session_t **	bleg,
		switch_call_cause_t *	cause,
		const char *	bridgeto,
		uint32_t	timelimit_sec,
		const switch_state_handler_table_t *	table,
		const char *	cid_name_override,
		const char *	cid_num_override,
		switch_caller_profile_t *	caller_profile_override,
		switch_event_t *	ovars,
		switch_originate_flag_t	flags,
		switch_call_cause_t *	cancel_cause,
		switch_dial_handle_t *	dh
	)

Make an outgoing call.

Parameters

session	originating session
bleg	B leg session
cause	a pointer to hold call cause
bridgeto	the desired remote callstring
timelimit_sec	timeout in seconds for outgoing call
table	optional state handler table to install on the channel
cid_name_override	override the caller id name
cid_num_override	override the caller id number
caller_profile_override	override the entire calling caller profile
ovars	variables to be set on the outgoing channel
flags	flags to pass

Returns

SWITCH_STATUS_SUCCESS if bleg is a running session.

Note

bleg will be read locked which must be unlocked with switch_core_session_rwunlock() before losing scope

switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE) &&

Definition at line 2064 of file switch_ivr_originate.c.

References switch_caller_profile::ani, switch_caller_profile::aniii, ringback::asis, ringback::audio_buffer, originate_global_t::bridge_early_media, buf, early_state::buffer, switch_frame::buflen, buflen, switch_caller_profile::callee_id_name, switch_caller_profile::callee_id_number, switch_caller_profile::caller_id_name, switch_caller_profile::caller_id_number, originate_status_t::caller_profile, originate_global_t::caller_profile_override, originate_global_t::cancel_timeout, CF_ANSWERED, CF_BLOCK_STATE, CF_BRIDGED, CF_CONSUME_ON_ORIGINATE, CF_DISABLE_RINGBACK, CF_EARLY_MEDIA, CF_INTERCEPT, CF_INTERCEPTED, CF_LAZY_ATTENDED_TRANSFER, CF_NO_PRESENCE, CF_ORIGINATING, CF_ORIGINATOR, CF_PROXY_MEDIA, CF_PROXY_MODE, CF_REDIRECT, CF_RING_READY, CF_TIMESTAMP_SET, CF_TRANSFER, CF_XFER_ZOMBIE, switch_caller_profile::chan_name, switch_file_handle::channels, check_channel_status(), check_per_channel_timeouts(), originate_global_t::check_vars, switch_frame::codec, originate_global_t::confirm_read_timeout, originate_global_t::confirm_timeout, originate_global_t::continue_on_timeout, CS_HANGUP, CS_REPORTING, CS_RESET, CS_ROUTING, switch_frame::data, switch_frame::datalen, switch_codec_implementation::decoded_bytes_per_packet, switch_caller_profile::destination_number, switch_dtmf_t::digit, originate_status_t::down_session, originate_global_t::early_ok, early_thread_run(), switch_codec_implementation::encoded_bytes_per_packet, originate_global_t::error_file, originate_global_t::ethread, ringback::fh, originate_global_t::file, switch_caller_profile::flags, switch_core_session_message::from, switch_event::headers, originate_global_t::hups, originate_global_t::idx, IDX_CANCEL, IDX_KEY_CANCEL, IDX_NADA, IDX_TIMEOUT, IDX_XFER, originate_global_t::ignore_early_media, originate_global_t::ignore_ring_ready, switch_codec::implementation, originate_global_t::instant_ringback, originate_global_t::key, MAX_PEERS, memset(), switch_core_session_message::message_id, originate_global_t::monitor_early_media_fail, originate_global_t::monitor_early_media_ring, early_state::mutex, ringback::mux_buf, switch_event_header::name, switch_event_header::next, switch_codec_implementation::number_of_channels, early_state::oglobals, originate_global_t::originate_status, originate_status_t::peer_channel, peer_eligible, originate_status_t::peer_session, originate_status_t::per_channel_delay_start, originate_status_t::per_channel_progress_timelimit_sec, originate_status_t::per_channel_timelimit_sec, switch_caller_profile::pool, originate_global_t::pool, originate_global_t::progress, QUOTED_ESC_COMMA, early_state::ready, originate_global_t::return_ring_ready, originate_global_t::ring_ready, early_state::ringback, originate_global_t::ringback_ok, switch_frame::samples, switch_codec_implementation::samples_per_packet, originate_global_t::sending_ringback, originate_global_t::sent_ring, originate_global_t::session, setup_ringback(), ringback::silence, SMF_NONE, SOF_FORKED_DIAL, SOF_NO_EFFECTIVE_ANI, SOF_NO_EFFECTIVE_ANIII, SOF_NO_EFFECTIVE_CID_NAME, SOF_NO_EFFECTIVE_CID_NUM, SOF_NO_LIMITS, SOF_NOBLOCK, SOF_NONE, switch_file_handle::speed, switch_assert, SWITCH_B_SDP_VARIABLE, SWITCH_BLANK_STRING, switch_buffer_create_dynamic(), switch_buffer_destroy(), switch_buffer_inuse(), switch_buffer_peek(), switch_buffer_read(), switch_buffer_read_loop(), switch_buffer_toss(), SWITCH_BYPASS_MEDIA_VARIABLE, SWITCH_CALL_TIMEOUT_VARIABLE, switch_caller_profile_clone(), switch_caller_profile_dup(), switch_caller_profile_new(), SWITCH_CAUSE_ATTENDED_TRANSFER, SWITCH_CAUSE_CALL_REJECTED, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION, SWITCH_CAUSE_INVALID_PROFILE, SWITCH_CAUSE_LOSE_RACE, SWITCH_CAUSE_NO_ANSWER, SWITCH_CAUSE_NONE, SWITCH_CAUSE_NORMAL_UNSPECIFIED, SWITCH_CAUSE_ORIGINATOR_CANCEL, SWITCH_CAUSE_PICKED_OFF, SWITCH_CAUSE_PROGRESS_TIMEOUT, SWITCH_CAUSE_SUCCESS, SWITCH_CAUSE_USER_BUSY, switch_channel_add_state_handler(), switch_channel_add_variable_var_check(), switch_channel_answer, switch_channel_api_on(), SWITCH_CHANNEL_API_ON_ORIGINATE_VARIABLE, SWITCH_CHANNEL_API_ON_POST_ORIGINATE_VARIABLE, SWITCH_CHANNEL_API_ON_PRE_ORIGINATE_VARIABLE, switch_channel_audio_sync, switch_channel_caller_extension_masquerade(), switch_channel_cause2str(), SWITCH_CHANNEL_CHANNEL_LOG, switch_channel_clear_flag(), switch_channel_dequeue_dtmf(), switch_channel_down_nosig, switch_channel_execute_on(), SWITCH_CHANNEL_EXECUTE_ON_ORIGINATE_VARIABLE, SWITCH_CHANNEL_EXECUTE_ON_POST_ORIGINATE_VARIABLE, SWITCH_CHANNEL_EXECUTE_ON_PRE_ORIGINATE_VARIABLE, switch_channel_get_caller_profile(), switch_channel_get_cause(), switch_channel_get_name(), switch_channel_get_state(), switch_channel_get_uuid(), switch_channel_get_variable, switch_channel_hangup, switch_channel_has_dtmf(), switch_channel_media_ready, switch_channel_media_up, switch_channel_pass_callee_id(), switch_channel_pre_answer, switch_channel_process_export(), switch_channel_ready, switch_channel_restart(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_name(), switch_channel_set_originatee_caller_profile(), switch_channel_set_private(), switch_channel_set_profile_var(), switch_channel_set_timestamps(), switch_channel_set_variable, switch_channel_set_variable_var_check(), switch_channel_state_change_pending(), switch_channel_test_flag(), switch_channel_up, switch_channel_up_nosig, switch_channel_var_true(), switch_channel_variable_first(), switch_channel_variable_last(), switch_channel_wait_for_state_timeout(), switch_cond_next(), switch_copy_string(), switch_core_codec_destroy(), switch_core_codec_ready(), switch_core_destroy_memory_pool, switch_core_file_close(), switch_core_file_read(), switch_core_file_seek(), switch_core_get_variable(), switch_core_new_memory_pool, switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_impl(), switch_core_session_get_uuid(), switch_core_session_locate, switch_core_session_outgoing_channel(), switch_core_session_read_frame(), switch_core_session_read_lock(), switch_core_session_receive_message, switch_core_session_reset(), switch_core_session_running(), switch_core_session_rwunlock(), switch_core_session_sprintf(), switch_core_session_thread_launch(), switch_core_session_write_frame(), switch_core_strdup, SWITCH_CPF_HIDE_NAME, SWITCH_CPF_HIDE_NUMBER, SWITCH_CPF_NONE, SWITCH_CPF_SCREEN, SWITCH_DEFAULT_CLID_NAME, SWITCH_DEFAULT_CLID_NUMBER, SWITCH_DEFAULT_TIMEOUT, switch_dial_handle_get_global_vars(), switch_dial_handle_get_peers(), switch_dial_handle_get_total(), switch_dial_handle_get_vars(), SWITCH_ENT_ORIGINATE_DELIM, switch_epoch_time_now(), switch_event_add_header_string(), SWITCH_EVENT_CHANNEL_DATA, switch_event_create_brackets(), switch_event_create_plain(), switch_event_del_header, switch_event_destroy(), switch_event_dup(), switch_event_get_header, switch_event_merge(), switch_event_serialize(), SWITCH_EXPORT_VARS_VARIABLE, SWITCH_FALSE, switch_false(), switch_find_end_paren(), switch_generate_sln_silence(), switch_goto_status, SWITCH_HANGUP_AFTER_BRIDGE_VARIABLE, SWITCH_HOLDING_UUID_VARIABLE, SWITCH_INT64_T_FMT, SWITCH_IO_FLAG_NONE, switch_is_number(), switch_ivr_enterprise_originate(), switch_ivr_generate_json_cdr(), switch_ivr_generate_xml_cdr(), switch_ivr_media(), switch_ivr_parse_all_events(), switch_ivr_session_transfer(), switch_ivr_sleep(), switch_ivr_stop_tone_detect_session(), switch_ivr_transfer_recordings(), switch_ivr_uuid_bridge(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, SWITCH_LOG_INFO, SWITCH_LOG_NOTICE, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_MESSAGE_INDICATE_CLEAR_PROGRESS, switch_micro_time_now(), switch_mutex_init(), switch_mutex_lock(), SWITCH_MUTEX_NESTED, switch_mutex_unlock(), SWITCH_ORIGINATE_SIGNAL_BOND_VARIABLE, switch_process_import(), SWITCH_PROXY_MEDIA_VARIABLE, SWITCH_READ_ACCEPTABLE, SWITCH_RECOMMENDED_BUFFER_SIZE, switch_safe_free, switch_sanitize_number(), switch_separate_string(), switch_set_flag, SWITCH_SIGNAL_BOND_VARIABLE, switch_snprintf(), SWITCH_SOFT_HOLDING_UUID_VARIABLE, SWITCH_STACK_BOTTOM, SWITCH_STACK_PUSH, SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_MEMERR, SWITCH_STATUS_SUCCESS, switch_str_nil, switch_stristr(), switch_thread_create(), switch_thread_join(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_stacksize_set(), SWITCH_TRUE, switch_true(), switch_xml_free(), switch_xml_toxml, switch_yield, switch_zmalloc, originate_status_t::tagged, teletone_destroy_session(), to, ringback::ts, early_state::ttl, UNQUOTED_ESC_COMMA, switch_caller_profile::uuid, switch_event_header::value, wait_for_cause(), and zstr.

Referenced by CoreSession::CoreSession(), enterprise_originate_thread(), fs_switch_ivr_originate(), CoreSession::originate(), and switch_ivr_orig_and_bridge().

{
        //originate_status_t originate_status[MAX_PEERS] = { {0} };
        switch_originate_flag_t dftflags = SOF_NONE, myflags;
        char *pipe_names[MAX_PEERS] = { 0 };
        char *data = NULL;
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        switch_channel_t *caller_channel = NULL;
        char *peer_names[MAX_PEERS] = { 0 };
        switch_event_t *peer_vars[MAX_PEERS] = { 0 };
        switch_core_session_t *new_session = NULL, *peer_session = NULL;
        switch_caller_profile_t *new_profile = NULL, *caller_caller_profile;
        char *chan_type = NULL, *chan_data;
        switch_channel_t *peer_channel = NULL;
        ringback_t ringback = { 0 };
        time_t start, global_start;
        switch_time_t last_retry_start = 0;
        switch_frame_t *read_frame = NULL;
        int r = 0, i, and_argc = 0, or_argc = 0;
        int32_t sleep_ms = 1000, try = 0, retries = 1, retry_timelimit_sec = 0;
        int32_t min_retry_period_ms = sleep_ms;
        switch_codec_t write_codec = { 0 };
        switch_frame_t write_frame = { 0 };
        char *odata, *var;
        switch_call_cause_t reason = SWITCH_CAUSE_NONE;
        switch_call_cause_t force_reason = SWITCH_CAUSE_NONE;
        uint8_t to = 0;
        char *var_val;
        const char *ringback_data = NULL;
        switch_event_t *var_event = NULL;
        int8_t fail_on_single_reject = 0;
        int8_t hangup_on_single_reject = 0;
        char *fail_on_single_reject_var = NULL;
        char *loop_data = NULL;
        uint32_t progress_timelimit_sec = 0;
        const char *cid_tmp, *lc;
        originate_global_t oglobals = { 0 };
        int cdr_total = 0;
        int local_clobber = 0;
        const char *cancel_key = NULL;
        const char *holding = NULL;
        const char *soft_holding = NULL;
        early_state_t early_state = { 0 };
        int read_packet = 0;
        int check_reject = 1;
        switch_codec_implementation_t read_impl = { 0 };
        const char *ani_override = NULL;
        const char *aniii_override = NULL;
        const char *ent_aleg_uuid = NULL;
        switch_core_session_t *a_session = session, *l_session = NULL;
        char *event_string;
        
        if (!bridgeto || dh) {
                bridgeto = "";
        }
        
        if (session) {
                caller_channel = switch_core_session_get_channel(session);

                if (switch_false(switch_channel_get_variable(caller_channel, "preserve_originated_vars"))) {
                        switch_channel_set_variable(caller_channel, "originated_legs", NULL);
                        switch_channel_set_variable(caller_channel, "originate_causes", NULL);
                }
        }


        if (strstr(bridgeto, SWITCH_ENT_ORIGINATE_DELIM)) {
                return switch_ivr_enterprise_originate(session, bleg, cause, bridgeto, timelimit_sec, table, cid_name_override, cid_num_override,
                                                                                           caller_profile_override, ovars, flags, cancel_cause, NULL);
        }

        oglobals.check_vars = SWITCH_TRUE;
        oglobals.ringback_ok = 1;
        oglobals.bridge_early_media = -1;
        oglobals.file = NULL;
        oglobals.error_file = NULL;
        switch_core_new_memory_pool(&oglobals.pool);

        if (caller_profile_override) {
                oglobals.caller_profile_override = switch_caller_profile_dup(oglobals.pool, caller_profile_override);
        } else if (session) {
                switch_caller_profile_t *cp = switch_channel_get_caller_profile(caller_channel);

                if (cp) {
                        oglobals.caller_profile_override = switch_caller_profile_dup(oglobals.pool, cp);
                }
        }

        if (session) {
                const char *to_var, *bypass_media = NULL, *proxy_media = NULL;
                switch_channel_set_flag(caller_channel, CF_ORIGINATOR);
                oglobals.session = session;

                switch_channel_execute_on(caller_channel, SWITCH_CHANNEL_EXECUTE_ON_PRE_ORIGINATE_VARIABLE);
                switch_channel_api_on(caller_channel, SWITCH_CHANNEL_API_ON_PRE_ORIGINATE_VARIABLE);

                switch_core_session_get_read_impl(session, &read_impl);

                if ((to_var = switch_channel_get_variable(caller_channel, SWITCH_CALL_TIMEOUT_VARIABLE))) {
                        timelimit_sec = atoi(to_var);
                }

                proxy_media = switch_channel_get_variable(caller_channel, SWITCH_PROXY_MEDIA_VARIABLE);
                bypass_media = switch_channel_get_variable(caller_channel, SWITCH_BYPASS_MEDIA_VARIABLE);

                if (!zstr(proxy_media)) {
                        if (switch_true(proxy_media)) {
                                switch_channel_set_flag(caller_channel, CF_PROXY_MEDIA);
                        } else if (switch_channel_test_flag(caller_channel, CF_PROXY_MEDIA)) {
                                switch_channel_clear_flag(caller_channel, CF_PROXY_MEDIA);
                        }
                }

                if (bypass_media && switch_channel_test_flag(caller_channel, CF_EARLY_MEDIA) && !switch_channel_test_flag(caller_channel, CF_ANSWERED)) {
                        switch_core_session_message_t msg = { 0 };

                        msg.message_id = SWITCH_MESSAGE_INDICATE_CLEAR_PROGRESS;
                        msg.from = __FILE__;
                        switch_core_session_receive_message(session, &msg);
                }


                if (!zstr(bypass_media) && !switch_channel_test_flag(caller_channel, CF_PROXY_MEDIA)) {
                        if (switch_true(bypass_media)) {
                                switch_channel_set_flag(caller_channel, CF_PROXY_MODE);
                        } else if (switch_channel_test_flag(caller_channel, CF_PROXY_MODE)) {
                                if (!switch_channel_test_flag(caller_channel, CF_ANSWERED) && switch_channel_test_flag(caller_channel, CF_EARLY_MEDIA)) {
                                        switch_channel_set_variable(caller_channel, SWITCH_B_SDP_VARIABLE, NULL);
                                        switch_channel_answer(caller_channel);
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
                                                                          "Must answer channel %s due to SIP PARADOX\n", switch_channel_get_name(caller_channel));
                                }
                                switch_channel_set_variable(caller_channel, SWITCH_B_SDP_VARIABLE, NULL);
                                switch_ivr_media(switch_core_session_get_uuid(session), SMF_NONE);
                        }
                }

                if (switch_channel_test_flag(caller_channel, CF_PROXY_MODE) && switch_channel_test_flag(caller_channel, CF_ANSWERED)) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                          "Channel is already up, delaying proxy mode 'till both legs are answered.\n");
                        switch_channel_set_variable(caller_channel, "bypass_media_after_bridge", "true");
                        switch_channel_set_variable(caller_channel, SWITCH_BYPASS_MEDIA_VARIABLE, NULL);
                        switch_channel_clear_flag(caller_channel, CF_PROXY_MODE);
                }
        }

        if (timelimit_sec <= 0) {
                timelimit_sec = SWITCH_DEFAULT_TIMEOUT;
        }


        oglobals.idx = IDX_NADA;
        oglobals.early_ok = 1;

        *bleg = NULL;

        switch_zmalloc(write_frame.data, SWITCH_RECOMMENDED_BUFFER_SIZE);
        write_frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE;

        odata = strdup(bridgeto);

        if (!odata) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Memory Error!\n");
                status = SWITCH_STATUS_MEMERR;
                goto done;
        }

        data = odata;


        /* Some channel are created from an originating channel and some aren't so not all outgoing calls have a way to get params
           so we will normalize dialstring params and channel variables (when there is an originator) into an event that we
           will use as a pseudo hash to consult for params as needed.
         */

        if (ovars) {
                var_event = ovars;
        } else {
                if (switch_event_create_plain(&var_event, SWITCH_EVENT_CHANNEL_DATA) != SWITCH_STATUS_SUCCESS) {
                        abort();
                }
        }

        ent_aleg_uuid = switch_event_get_header(var_event, "ent_originate_aleg_uuid");

        if (caller_channel) {
                switch_channel_process_export(caller_channel, NULL, var_event, SWITCH_EXPORT_VARS_VARIABLE);
        }

        /* strip leading spaces */
        while (data && *data && *data == ' ') {
                data++;
        }

        if ((ovars && switch_true(switch_event_get_header(ovars,"origination_nested_vars"))) ||
                (caller_channel && switch_true(switch_channel_get_variable(caller_channel, "origination_nested_vars")))
                || switch_true(switch_core_get_variable("origination_nested_vars")) || switch_stristr("origination_nested_vars=true", data)) {
                oglobals.check_vars = SWITCH_FALSE;
        }

        if (dh) {
                switch_event_t *vp = switch_dial_handle_get_global_vars(dh);
                if (vp) {
                        if (var_event && var_event != ovars) {
                                switch_event_destroy(&var_event);
                        }
                        switch_event_dup(&var_event, vp);
                }
        }

        /* extract channel variables, allowing multiple sets of braces */
        if (*data == '<') {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Parsing ultra-global variables\n");
                while (*data == '<') {
                        char *parsed = NULL;

                        if (switch_event_create_brackets(data, '<', '>', ',', &var_event, &parsed, SWITCH_FALSE) != SWITCH_STATUS_SUCCESS || !parsed) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Parse Error!\n");
                                switch_goto_status(SWITCH_STATUS_GENERR, done);
                        }

                        data = parsed;
                }
        }

        /* extract channel variables, allowing multiple sets of braces */
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Parsing global variables\n");
        while (*data == '{') {
                char *parsed = NULL;

                if (switch_event_create_brackets(data, '{', '}', ',', &var_event, &parsed, SWITCH_FALSE) != SWITCH_STATUS_SUCCESS || !parsed) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Parse Error!\n");
                        switch_goto_status(SWITCH_STATUS_GENERR, done);
                }

                data = parsed;
        }
        
        if (dh && var_event && switch_event_serialize(var_event, &event_string, SWITCH_FALSE) == SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Global Vars\n======================\n%s\n", event_string);
                switch_safe_free(event_string);
        }
        
        /* strip leading spaces (again) */
        while (data && *data && *data == ' ') {
                data++;
        }

        if (zstr(data) && !dh) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "No origination URL specified!\n");
                status = SWITCH_STATUS_GENERR;
                goto done;
        }

        if (!(flags & SOF_NOBLOCK) && var_event && (var = switch_event_get_header(var_event, "originate_delay_start"))) {
                int tmp = atoi(var);
                if (tmp > 0) {
                        while (tmp && (!cancel_cause || *cancel_cause == 0)) {
                                switch_cond_next();
                                tmp--;
                        }
                }
        }

        if (oglobals.session) {
                switch_event_header_t *hi;
                const char *cdr_total_var;
                const char *cdr_var;
                const char *json_cdr_var;

                if (switch_channel_var_true(caller_channel, "originate_xfer_zombie")) {
                        switch_channel_set_flag(caller_channel, CF_XFER_ZOMBIE);
                        oglobals.early_ok = 0;
                        oglobals.ignore_early_media = 1;
                }

                if ((cdr_var = switch_channel_get_variable(caller_channel, "failed_xml_cdr_prefix"))) {
                        char buf[128] = "";
                        switch_snprintf(buf, sizeof(buf), "%s_total", cdr_var);
                        if ((cdr_total_var = switch_channel_get_variable(caller_channel, buf))) {
                                int tmp = atoi(cdr_total_var);
                                if (tmp > 0) {
                                        cdr_total = tmp;
                                }
                        }
                }

                if ((json_cdr_var = switch_channel_get_variable(caller_channel, "failed_json_cdr_prefix"))) {
                        char buf[128] = "";
                        switch_snprintf(buf, sizeof(buf), "%s_total", json_cdr_var);
                        if ((cdr_total_var = switch_channel_get_variable(caller_channel, buf))) {
                                int tmp = atoi(cdr_total_var);
                                if (tmp > 0) {
                                        cdr_total = tmp;
                                }
                        }
                }

                /* Copy all the missing applicable channel variables from A-leg into the event */
                if ((hi = switch_channel_variable_first(caller_channel))) {
                        for (; hi; hi = hi->next) {
                                int ok = 0;
                                if (!strcasecmp((char *) hi->name, "group_confirm_key")) {
                                        ok = 1;
                                } else if (!strcasecmp((char *) hi->name, "group_confirm_file")) {
                                        ok = 1;
                                } else if (!strcasecmp((char *) hi->name, "group_confirm_read_timeout")) {
                                        ok = 1;
                                } else if (!strcasecmp((char *) hi->name, "group_confirm_cancel_timeout")) {
                                        ok = 1;
                                } else if (!strcasecmp((char *) hi->name, "group_confirm_timeout")) {
                                        ok = 1;
                                } else if (!strcasecmp((char *) hi->name, "forked_dial")) {
                                        ok = 1;
                                } else if (!strcasecmp((char *) hi->name, "fail_on_single_reject")) {
                                        ok = 1;
                                } else if (!strcasecmp((char *) hi->name, "hangup_on_single_reject")) {
                                        ok = 1;
                                } else if (!strcasecmp((char *) hi->name, "ignore_early_media")) {
                                        ok = 1;
                                } else if (!strcasecmp((char *) hi->name, "bridge_early_media")) {
                                        ok = 1;
                                } else if (!strcasecmp((char *) hi->name, "originate_continue_on_timeout")) {
                                        ok = 1;
                                } else if (!strcasecmp((char *) hi->name, "ignore_ring_ready")) {
                                        ok = 1;
                                } else if (!strcasecmp((char *) hi->name, "monitor_early_media_ring")) {
                                        ok = 1;
                                } else if (!strcasecmp((char *) hi->name, "monitor_early_media_ring_total")) {
                                        ok = 1;
                                } else if (!strcasecmp((char *) hi->name, "monitor_early_media_fail")) {
                                        ok = 1;
                                } else if (!strcasecmp((char *) hi->name, "return_ring_ready")) {
                                        ok = 1;
                                } else if (!strcasecmp((char *) hi->name, "ring_ready")) {
                                        ok = 1;
                                } else if (!strcasecmp((char *) hi->name, "instant_ringback")) {
                                        ok = 1;
                                } else if (!strcasecmp((char *) hi->name, "progress_timeout")) {
                                        ok = 1;
                                } else if (!strcasecmp((char *) hi->name, "language")) {
                                        ok = 1;
                                }

                                if (ok && !switch_event_get_header(var_event, hi->name)) {
                                        switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, (char *) hi->name, (char *) hi->value);
                                }
                        }
                        switch_channel_variable_last(caller_channel);
                }
                /*
                   if ((hi = switch_channel_variable_first(caller_channel))) {
                   for (; hi; hi = switch_core_hash_next(&hi)) {
                   switch_core_hash_this(hi, &vvar, NULL, &vval);
                   if (vvar && vval) {
                   switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, (void *) vvar, (char *) vval);
                   }
                   }
                   switch_channel_variable_last(caller_channel);
                   }
                 */
        }

        if (caller_channel) {           /* ringback is only useful when there is an originator */
                ringback_data = NULL;
                cancel_key = switch_channel_get_variable(caller_channel, "origination_cancel_key");

                if (switch_channel_test_flag(caller_channel, CF_ANSWERED)) {
                        ringback_data = switch_channel_get_variable(caller_channel, "transfer_ringback");
                }

                if (!ringback_data) {
                        ringback_data = switch_channel_get_variable(caller_channel, "ringback");
                }

                switch_channel_set_variable(caller_channel, "originate_disposition", "failure");
                switch_channel_set_variable(caller_channel, "DIALSTATUS", "INVALIDARGS");

                if (switch_channel_test_flag(caller_channel, CF_PROXY_MODE) || switch_channel_test_flag(caller_channel, CF_PROXY_MEDIA)) {
                        ringback_data = NULL;
                }
        }
#if 0
        /* changing behaviour ignore_early_media=true must also be explicitly set for previous behaviour */
        if (ringback_data) {
                oglobals.early_ok = 0;
        }
#endif

        if ((var = switch_event_get_header(var_event, "group_confirm_timeout"))) {
                // has precedence over group_confirm_cancel_timeout
                if (switch_is_number(var)) {
                        oglobals.confirm_timeout = atoi(var);
                        if (oglobals.confirm_timeout == 0) {
                                oglobals.cancel_timeout = SWITCH_TRUE;
                        }
                }
        } else if (switch_true(switch_event_get_header(var_event, "group_confirm_cancel_timeout"))) {
                oglobals.cancel_timeout = SWITCH_TRUE;
        }

        if ((var = switch_event_get_header(var_event, "group_confirm_early_ok"))) {
                oglobals.early_ok = switch_true(var);
        }

        if ((var = switch_event_get_header(var_event, "group_confirm_key"))) {
                switch_copy_string(oglobals.key, var, sizeof(oglobals.key));
                if ((var = switch_event_get_header(var_event, "group_confirm_file"))) {
                        oglobals.file = strdup(var);
                }
                if ((var = switch_event_get_header(var_event, "group_confirm_error_file"))) {
                        oglobals.error_file = strdup(var);
                }
                if ((var = switch_event_get_header(var_event, "group_confirm_read_timeout"))) {
                        int tmp = atoi(var);

                        if (tmp >= 0) {
                                oglobals.confirm_read_timeout = tmp;
                        }

                }
        }
        /* When using the AND operator, the fail_on_single_reject flag may be set in order to indicate that a single
           rejections should terminate the attempt rather than a timeout, answer, or rejection by all.
           If the value is set to 'true' any fail cause will end the attempt otherwise it can contain a comma (,) separated
           list of cause names which should be considered fatal
         */
        if ((var = switch_event_get_header(var_event, "hangup_on_single_reject"))) {
                hangup_on_single_reject = switch_true(var);
        }

        if ((var = switch_event_get_header(var_event, "fail_on_single_reject")) || hangup_on_single_reject) {
                if (var) {
                        fail_on_single_reject_var = strdup(var);
                }

                if (switch_true(var)) {
                        fail_on_single_reject = 1;
                } else {
                        fail_on_single_reject = -1;
                }
        }

        if ((!zstr(oglobals.file)) && (!strcmp(oglobals.file, "undef"))) {
                switch_safe_free(oglobals.file);
                oglobals.file = NULL;
        }
        if ((!zstr(oglobals.error_file)) && (!strcmp(oglobals.error_file, "undef"))) {
                switch_safe_free(oglobals.error_file);
                oglobals.error_file = NULL;
        }

        if ((var_val = switch_event_get_header(var_event, "bridge_early_media"))) {
                if (switch_true(var_val)) {
                        oglobals.early_ok = 0;
                        oglobals.ignore_early_media = 3;
                }
        }

        if ((var_val = switch_event_get_header(var_event, "ignore_early_media"))) {
                if (switch_true(var_val)) {
                        oglobals.early_ok = 0;
                        oglobals.ignore_early_media = 1;
                } else if (!strcmp(var_val, "consume")) {
                        oglobals.early_ok = 0;
                        oglobals.ignore_early_media = 4;
                } else if (!strcmp(var_val, "ring_ready")) {
                        oglobals.early_ok = 0;
                        oglobals.ignore_early_media = 2;
                }
        }

        if ((var_val = switch_event_get_header(var_event, "originate_continue_on_timeout")) && switch_true(var_val)) {
                oglobals.continue_on_timeout = 1;
        }

        if ((var_val = switch_event_get_header(var_event, "ignore_ring_ready")) && switch_true(var_val)) {
                oglobals.ignore_ring_ready = 1;
        }

        if ((var_val = switch_event_get_header(var_event, "monitor_early_media_ring")) && switch_true(var_val)) {
                oglobals.early_ok = 0;
                oglobals.monitor_early_media_ring = 1;
        }

        if ((var_val = switch_event_get_header(var_event, "monitor_early_media_fail")) && switch_true(var_val)) {
                oglobals.early_ok = 0;
                oglobals.monitor_early_media_fail = 1;
        }

        if ((var_val = switch_event_get_header(var_event, "return_ring_ready")) && switch_true(var_val)) {
                oglobals.return_ring_ready = 1;
        }

        if ((var_val = switch_event_get_header(var_event, "ring_ready")) && switch_true(var_val)) {
                oglobals.ring_ready = 1;
        }

        if ((var_val = switch_event_get_header(var_event, "instant_ringback")) && switch_true(var_val)) {
                oglobals.instant_ringback = 1;
        }

        if ((var_val = switch_event_get_header(var_event, "originate_timeout"))) {
                int tmp = atoi(var_val);
                if (tmp > 0) {
                        timelimit_sec = (uint32_t) tmp;
                }
        }

        if ((var_val = switch_event_get_header(var_event, "progress_timeout"))) {
                int tmp = atoi(var_val);
                if (tmp > 0) {
                        progress_timelimit_sec = (uint32_t) tmp;
                }
        }

        if ((var_val = switch_event_get_header(var_event, "originate_retry_timeout")) && switch_true(var_val)) {
                int32_t tmp;
                tmp = atoi(var_val);
                if (tmp > 0) {
                        retry_timelimit_sec = tmp;
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
                                "Invalid originate_retry_timeout setting of %s ignored, value must be > 0\n", var_val);
                }
        }

        if ((var_val = switch_event_get_header(var_event, "originate_retries")) && switch_true(var_val)) {
                int32_t tmp;
                tmp = atoi(var_val);
                /* allow large number of retries if timeout is set */
                if (tmp > 0 && (retry_timelimit_sec > 0 || tmp < 101)) {
                        retries = tmp;
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
                                                          "Invalid originate_retries setting of %d ignored, value must be between 1 and 100\n", tmp);
                }
        }

        if ((var_val = switch_event_get_header(var_event, "originate_retry_sleep_ms")) && switch_true(var_val)) {
                int32_t tmp;
                tmp = atoi(var_val);
                if (tmp >= 500 && tmp <= 60000) {
                        sleep_ms = tmp;
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
                                                          "Invalid originate_retry_sleep_ms setting of %d ignored, value must be between 500 and 60000\n", tmp);
                }
        }

        if ((var_val = switch_event_get_header(var_event, "originate_retry_min_period_ms")) && switch_true(var_val)) {
                int32_t tmp;
                tmp = atoi(var_val);
                if (tmp >= 500 && tmp <= 300000) {
                        min_retry_period_ms = tmp;
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
                                                          "Invalid originate_retry_min_period_ms setting of %d ignored, value must be between 500 and 300000\n", tmp);
                }
        }

        /* variable to force ANI / ANIII */
        ani_override = switch_event_get_header(var_event, "origination_ani");
        aniii_override = switch_event_get_header(var_event, "origination_aniii");

        if ((cid_tmp = switch_event_get_header(var_event, "origination_caller_id_name"))) {
                cid_name_override = cid_tmp;
        }

        if (cid_name_override) {
                if (!cid_tmp) {
                        switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "origination_caller_id_name", cid_name_override);
                }
        } else {
                cid_name_override = switch_event_get_header(var_event, "origination_caller_id_name");
        }

        if ((cid_tmp = switch_event_get_header(var_event, "origination_caller_id_number"))) {
                cid_num_override = cid_tmp;
        }

        if (cid_num_override) {
                if (!cid_tmp) {
                        switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "origination_caller_id_number", cid_num_override);
                }
        } else {
                cid_num_override = switch_event_get_header(var_event, "origination_caller_id_number");
        }

        if (flags & SOF_NO_LIMITS) {
                dftflags |= SOF_NO_LIMITS;
        }

        if (ani_override) {
                dftflags |= SOF_NO_EFFECTIVE_ANI;
        }

        if (aniii_override) {
                dftflags |= SOF_NO_EFFECTIVE_ANIII;
        }

        if (cid_num_override) {
                dftflags |= SOF_NO_EFFECTIVE_CID_NUM;
        }

        if (cid_name_override) {
                dftflags |= SOF_NO_EFFECTIVE_CID_NAME;
        }

        if (!progress_timelimit_sec) {
                progress_timelimit_sec = timelimit_sec;
        }

        switch_epoch_time_now(&global_start);
        last_retry_start = switch_micro_time_now();

        for (try = 0; try < retries; try++) {

                if (try > 0) {
                        int64_t elapsed = switch_epoch_time_now(NULL) - global_start;

                        /* check if retry time limit has been exceeded */
                        if (retry_timelimit_sec > 0) {
                                if (elapsed > retry_timelimit_sec) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE,
                                                                          "Elapsed = %"SWITCH_INT64_T_FMT", originate retry timeout.\n", elapsed);
                                        break;
                                } else if (cancel_cause && *cancel_cause != 0) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Originate cancelled\n");
                                        break;
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                          "Elapsed = %"SWITCH_INT64_T_FMT", originate retry not timed out yet\n", elapsed);
                                }
                        }

                        /* don't allow retry to start too quickly since last attempt */
                        if (min_retry_period_ms > sleep_ms) {
                                int64_t retry_sleep_ms = min_retry_period_ms - sleep_ms - ((switch_micro_time_now() - last_retry_start) / 1000);
                                if (retry_sleep_ms > 0 && retry_sleep_ms <= 300000) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Minimum retry period has not elapsed yet, waiting %"SWITCH_INT64_T_FMT" ms\n", retry_sleep_ms);
                                        if (caller_channel) {
                                                switch_ivr_sleep(oglobals.session, retry_sleep_ms, SWITCH_TRUE, NULL);
                                                if (!switch_channel_ready(caller_channel)) {
                                                        status = SWITCH_STATUS_FALSE;
                                                        goto done;
                                                }
                                        } else {
                                                switch_yield(retry_sleep_ms * 1000);
                                        }
                                }
                        }
                }

                switch_safe_free(loop_data);
                loop_data = strdup(data);
                switch_assert(loop_data);

                if (dh) {
                        or_argc = switch_dial_handle_get_total(dh);
                } else {
                        or_argc = switch_separate_string(loop_data, '|', pipe_names, (sizeof(pipe_names) / sizeof(pipe_names[0])));
                }
                
                if ((flags & SOF_NOBLOCK) && or_argc > 1) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Only calling the first element in the list in this mode.\n");
                        or_argc = 1;
                }
                
                if (or_argc <= 0) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Nothing to do\n");
                        goto outer_for;
                }
                
                for (r = 0; r < or_argc && (!cancel_cause || *cancel_cause == 0); r++) {
                        char *p, *end = NULL;
                        int q = 0, alt = 0;

                        check_reject = 1;

                        oglobals.hups = 0;

                        reason = SWITCH_CAUSE_NONE;
                        memset(peer_names, 0, sizeof(peer_names));
                        peer_session = NULL;
                        memset(oglobals.originate_status, 0, sizeof(oglobals.originate_status));
                        new_profile = NULL;
                        new_session = NULL;
                        chan_type = NULL;
                        chan_data = NULL;
                        peer_channel = NULL;
                        start = 0;
                        read_frame = NULL;
                        oglobals.ringback_ok = 1;
                        var = NULL;
                        to = 0;
                        oglobals.sent_ring = 0;
                        oglobals.progress = 0;
                        myflags = dftflags;


                        if (try > 0) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Originate attempt %d/%d in %d ms\n", try + 1, retries,
                                                                  sleep_ms);
                                if (caller_channel) {
                                        switch_ivr_sleep(oglobals.session, sleep_ms, SWITCH_TRUE, NULL);
                                        if (!switch_channel_ready(caller_channel)) {
                                                status = SWITCH_STATUS_FALSE;
                                                /* set try and retries to 0 */
                                                try = 0;
                                                retries = 0;
                                                goto done;
                                        }
                                } else {
                                        switch_yield(sleep_ms * 1000);
                                }
                        }

                        if (r == 0) {
                                last_retry_start = switch_micro_time_now();
                        }

                        if (!dh) {
                                p = pipe_names[r];

                                while (p && *p) {
                                        if (!end && *p == '[') {
                                                end = switch_find_end_paren(p, '[', ']');
                                                if (*(p+1) == '^' && *(p + 2) == '^') {
                                                        alt = 1;
                                                } else {
                                                        alt = 0;
                                                }
                                                q = 0;
                                        }

                                        if (*p == '\'') {
                                                q = !q;
                                        }

                                        if (end && p < end && *p == ',' && *(p-1) != '\\') {

                                                if (q || alt) {
                                                        *p = QUOTED_ESC_COMMA;
                                                } else {
                                                        *p = UNQUOTED_ESC_COMMA;
                                                }
                                        }

                                        if (p == end) {
                                                end = NULL;
                                        }

                                        p++;
                                }
                                
                                and_argc = switch_separate_string(pipe_names[r], ',', peer_names, (sizeof(peer_names) / sizeof(peer_names[0])));
                        } else {
                                and_argc = switch_dial_handle_get_peers(dh, r, peer_names, MAX_PEERS);
                                switch_dial_handle_get_vars(dh, r, peer_vars, MAX_PEERS);
                        }
                        
                        if ((flags & SOF_NOBLOCK) && and_argc > 1) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Only calling the first element in the list in this mode.\n");
                                and_argc = 1;
                        }
                        
                        for (i = 0; i < and_argc; i++) {
                                const char *current_variable;
                                switch_event_t *local_var_event = NULL, *originate_var_event = NULL;

                                end = NULL;

                                if (!(chan_type = peer_names[i])) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Empty dial string\n");
                                        switch_goto_status(SWITCH_STATUS_FALSE, done);
                                }


                                /* strip leading spaces */
                                while (chan_type && *chan_type && *chan_type == ' ') {
                                        chan_type++;
                                }

                                /* extract channel variables, allowing multiple sets of braces */

                                if (*chan_type == '[') {
                                        switch_event_create_plain(&local_var_event, SWITCH_EVENT_CHANNEL_DATA);
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Parsing session specific variables\n");
                                }

                                while (*chan_type == '[') {
                                        char *parsed = NULL;
                                        char *bend = switch_find_end_paren(chan_type, '[', ']');

                                        for (p = chan_type + 1; p && p < bend && *p; p++) {
                                                if (*p == QUOTED_ESC_COMMA) {
                                                        *p = ',';
                                                }
                                        }

                                        if (switch_event_create_brackets(chan_type, '[', ']', UNQUOTED_ESC_COMMA,
                                                                                                         &local_var_event, &parsed, SWITCH_FALSE) != SWITCH_STATUS_SUCCESS || !parsed) {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Parse Error!\n");
                                                switch_goto_status(SWITCH_STATUS_GENERR, done);
                                        }

                                        if (chan_type == parsed) {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Parse Error!\n");
                                                switch_goto_status(SWITCH_STATUS_GENERR, done);
                                        } else {
                                                chan_type = parsed;
                                        }
                                }

                                if (peer_vars[i]) {
                                        if (local_var_event) {
                                                switch_event_merge(local_var_event, peer_vars[i]);
                                        } else {
                                                switch_event_dup(&local_var_event, peer_vars[i]);
                                        }

                                        if (dh && local_var_event && switch_event_serialize(local_var_event, &event_string, SWITCH_FALSE) == SWITCH_STATUS_SUCCESS) {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Local Vars for %s\n======================\n%s\n",
                                                                                  peer_names[i], event_string);
                                                switch_safe_free(event_string);
                                        }
                                }
                                
                                /* strip leading spaces (again) */
                                while (chan_type && *chan_type && *chan_type == ' ') {
                                        chan_type++;
                                }

                                if ((chan_data = strchr(chan_type, '/')) != 0) {
                                        *chan_data = '\0';
                                        chan_data++;
                                }

                                if (oglobals.session) {
                                        if (!switch_channel_ready(caller_channel)) {
                                                status = SWITCH_STATUS_FALSE;
                                                if (local_var_event) switch_event_destroy(&local_var_event);
                                                goto done;
                                        }

                                        if ((caller_caller_profile = oglobals.caller_profile_override)) {
                                                new_profile = switch_caller_profile_dup(oglobals.pool, caller_caller_profile);
                                        } else {
                                                new_profile = switch_caller_profile_new(oglobals.pool,
                                                                                                                                NULL,
                                                                                                                                NULL,
                                                                                                                                cid_name_override, cid_num_override, NULL, ani_override, aniii_override, NULL, __FILE__, NULL, chan_data);
                                        }

                                        new_profile->uuid = SWITCH_BLANK_STRING;
                                        new_profile->chan_name = SWITCH_BLANK_STRING;
                                        new_profile->destination_number = switch_core_strdup(new_profile->pool, chan_data);

                                        if (ani_override) {
                                                new_profile->ani = switch_core_strdup(new_profile->pool, ani_override);
                                        }
                                        if (aniii_override) {
                                                new_profile->aniii = switch_core_strdup(new_profile->pool, aniii_override);
                                        }
                                        if (cid_name_override) {
                                                new_profile->caller_id_name = switch_core_strdup(new_profile->pool, cid_name_override);
                                        }
                                        if (cid_num_override) {
                                                new_profile->caller_id_number = switch_core_strdup(new_profile->pool, cid_num_override);
                                        }
                                } else {
                                        if (oglobals.caller_profile_override) {
                                                new_profile = switch_caller_profile_dup(oglobals.pool, oglobals.caller_profile_override);
                                                new_profile->destination_number = switch_core_strdup(new_profile->pool, switch_str_nil(chan_data));
                                                new_profile->uuid = SWITCH_BLANK_STRING;
                                                new_profile->chan_name = SWITCH_BLANK_STRING;
                                        } else {
                                                if (!cid_name_override) {
                                                        cid_name_override = SWITCH_DEFAULT_CLID_NAME;
                                                }
                                                if (!cid_num_override) {
                                                        cid_num_override = SWITCH_DEFAULT_CLID_NUMBER;
                                                }

                                                new_profile = switch_caller_profile_new(oglobals.pool,
                                                                                                                                NULL,
                                                                                                                                NULL,
                                                                                                                                cid_name_override, cid_num_override, NULL, ani_override, aniii_override, NULL, __FILE__, NULL, chan_data);
                                        }
                                }

                                if (zstr(new_profile->destination_number)) {
                                        new_profile->destination_number = switch_core_strdup(new_profile->pool, "service");
                                }

                                new_profile->callee_id_name = switch_core_strdup(new_profile->pool, "Outbound Call");
                                new_profile->callee_id_number = switch_sanitize_number(switch_core_strdup(new_profile->pool, new_profile->destination_number));

                                oglobals.originate_status[i].caller_profile = NULL;
                                oglobals.originate_status[i].peer_channel = NULL;
                                oglobals.originate_status[i].peer_session = NULL;

                                new_session = NULL;

                                if (and_argc > 1 || or_argc > 1) {
                                        myflags |= SOF_FORKED_DIAL;
                                }

                                if (var_event) {
                                        const char *vvar;
                                        if ((vvar = switch_event_get_header(var_event, "forked_dial")) && switch_true(vvar)) {
                                                myflags |= SOF_FORKED_DIAL;
                                        }
                                        if ((vvar = switch_event_get_header(var_event, "no_throttle_limits")) && switch_true(vvar)) {
                                                myflags |= SOF_NO_LIMITS;
                                        }
                                }


                                /* Valid in both {} and [] with [] taking precedence */

                                /* make a special var event with mixture of the {} and the [] vars to pass down as global vars to the outgoing channel
                                   so if something like the user channel does another originate our options will be passed down properly
                                 */

                                switch_event_dup(&originate_var_event, var_event);

                                if (local_var_event) {
                                        switch_event_merge(originate_var_event, local_var_event);
                                }

                                if ((current_variable = switch_event_get_header(originate_var_event, "origination_ani"))) {
                                        new_profile->ani = switch_core_strdup(new_profile->pool, current_variable);
                                        myflags |= SOF_NO_EFFECTIVE_ANI;
                                }

                                if ((current_variable = switch_event_get_header(originate_var_event, "origination_aniii"))) {
                                        new_profile->aniii = switch_core_strdup(new_profile->pool, current_variable);
                                        myflags |= SOF_NO_EFFECTIVE_ANIII;
                                }

                                if ((current_variable = switch_event_get_header(originate_var_event, "origination_caller_id_number"))) {
                                        new_profile->caller_id_number = switch_core_strdup(new_profile->pool, current_variable);
                                        myflags |= SOF_NO_EFFECTIVE_CID_NUM;
                                }

                                if ((current_variable = switch_event_get_header(originate_var_event, "origination_caller_id_name"))) {
                                        new_profile->caller_id_name = switch_core_strdup(new_profile->pool, current_variable);
                                        myflags |= SOF_NO_EFFECTIVE_CID_NAME;
                                }

                                if ((current_variable = switch_event_get_header(originate_var_event, "origination_privacy"))) {
                                        new_profile->flags = SWITCH_CPF_NONE;

                                        if (switch_stristr("screen", current_variable)) {
                                                switch_set_flag(new_profile, SWITCH_CPF_SCREEN);
                                        }

                                        if (switch_stristr("hide_name", current_variable)) {
                                                switch_set_flag(new_profile, SWITCH_CPF_HIDE_NAME);
                                        }

                                        if (switch_stristr("hide_number", current_variable)) {
                                                switch_set_flag(new_profile, SWITCH_CPF_HIDE_NUMBER);
                                        }
                                }

                                switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "originate_early_media", oglobals.early_ok ? "true" : "false");


                                if (caller_channel && switch_true(switch_channel_get_variable(caller_channel, "push_channel_name"))) {
                                        char *new_name = switch_core_session_sprintf(session, "%s__B", switch_channel_get_name(caller_channel));
                                        switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "origination_channel_name", new_name);
                                        new_name = switch_core_session_sprintf(session, "_%s", switch_channel_get_name(caller_channel));
                                        switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, "sip_h_X-FS-Channel-Name", new_name);
                                }


                                reason = switch_core_session_outgoing_channel(oglobals.session, originate_var_event, chan_type,
                                                                                                                          new_profile, &new_session, NULL, myflags, cancel_cause);
                                switch_event_destroy(&originate_var_event);

                                if (reason != SWITCH_CAUSE_SUCCESS) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Cannot create outgoing channel of type [%s] cause: [%s]\n",
                                                                          chan_type, switch_channel_cause2str(reason));
                                        if (local_var_event) switch_event_destroy(&local_var_event);

                                        if (fail_on_single_reject_var) {
                                                const char *cause_str = switch_channel_cause2str(reason);
                                                int neg = *fail_on_single_reject_var == '!';
                                                int pos = !!switch_stristr(cause_str, fail_on_single_reject_var);

                                                if (neg) {
                                                        pos = !pos;
                                                }

                                                check_reject = 0;

                                                if (fail_on_single_reject == 1 || pos) {
                                                        force_reason = reason;
                                                        status = SWITCH_STATUS_FALSE;
                                                        goto outer_for;
                                                }
                                        }
                                        continue;
                                }

                                if (switch_core_session_read_lock(new_session) != SWITCH_STATUS_SUCCESS) {
                                        status = SWITCH_STATUS_FALSE;
                                        if (local_var_event) switch_event_destroy(&local_var_event);
                                        goto done;
                                }

                                oglobals.originate_status[i].peer_channel = switch_core_session_get_channel(new_session);
                                oglobals.originate_status[i].caller_profile = switch_channel_get_caller_profile(oglobals.originate_status[i].peer_channel);
                                oglobals.originate_status[i].peer_session = new_session;

                                switch_channel_set_flag(oglobals.originate_status[i].peer_channel, CF_ORIGINATING);

                                if (caller_channel) {
                                        switch_channel_set_variable(oglobals.originate_status[i].peer_channel, "call_uuid", switch_channel_get_variable(caller_channel, "call_uuid"));
                                }


                                if (local_var_event) {
                                        const char *device_id = switch_event_get_header(local_var_event, "device_id");
                                        switch_channel_set_profile_var(oglobals.originate_status[i].peer_channel, "device_id", device_id);
                                }

                                if ((lc = switch_event_get_header(var_event, "local_var_clobber"))) {
                                        local_clobber = switch_true(lc);
                                }

                                if (switch_channel_test_flag(oglobals.originate_status[i].peer_channel, CF_NO_PRESENCE)) {
                                        if (var_event) {
                                                switch_event_del_header(var_event, "presence_id");
                                        }
                                        if (local_var_event) {
                                                switch_event_del_header(local_var_event, "presence_id");
                                        }
                                }


                                if (local_clobber) {
                                        if (var_event) {
                                                switch_event_header_t *header;
                                                /* install the vars from the {} params */
                                                for (header = var_event->headers; header; header = header->next) {
                                                        switch_channel_set_variable_var_check(oglobals.originate_status[i].peer_channel, header->name, header->value, oglobals.check_vars);
                                                }
                                        }
                                }

                                /* copy local originate vars to the channel */
                                if (local_var_event) {
                                        switch_event_header_t *header;
                                        for (header = local_var_event->headers; header; header = header->next) {
                                                switch_channel_set_variable_var_check(oglobals.originate_status[i].peer_channel, header->name, header->value, oglobals.check_vars);
                                        }
                                        switch_event_destroy(&local_var_event);
                                }

                                if (!local_clobber) {
                                        if (var_event) {
                                                switch_event_header_t *header;
                                                /* install the vars from the {} params */
                                                for (header = var_event->headers; header; header = header->next) {
                                                        switch_channel_set_variable_var_check(oglobals.originate_status[i].peer_channel, header->name, header->value, oglobals.check_vars);
                                                }
                                        }
                                }

                                if (oglobals.originate_status[i].peer_channel) {
                                        const char *vvar;

                                        if (switch_true(switch_channel_get_variable(oglobals.originate_status[i].peer_channel, "leg_required"))) {
                                                oglobals.originate_status[i].tagged = 1;
                                        }

                                        if ((vvar = switch_channel_get_variable(oglobals.originate_status[i].peer_channel, "origination_channel_name"))) {
                                                switch_channel_set_name(oglobals.originate_status[i].peer_channel, vvar);
                                        }

                                        if ((vvar = switch_channel_get_variable(oglobals.originate_status[i].peer_channel, "origination_callee_id_name"))) {
                                                switch_channel_set_profile_var(oglobals.originate_status[i].peer_channel, "callee_id_name", vvar);
                                        }

                                        if ((vvar = switch_channel_get_variable(oglobals.originate_status[i].peer_channel, "origination_callee_id_number"))) {
                                                switch_channel_set_profile_var(oglobals.originate_status[i].peer_channel, "callee_id_number", vvar);
                                        }

                                        if ((vvar = switch_channel_get_variable(oglobals.originate_status[i].peer_channel, "leg_timeout"))) {
                                                int val = atoi(vvar);

                                                if (val > 0) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Setting leg timeout to %d\n",
                                                                                          switch_channel_get_name(oglobals.originate_status[i].peer_channel), val);
                                                        oglobals.originate_status[i].per_channel_timelimit_sec = (uint32_t) val;
                                                }
                                        }

                                        if ((vvar = switch_channel_get_variable(oglobals.originate_status[i].peer_channel, "leg_progress_timeout"))) {
                                                int val = atoi(vvar);
                                                if (val > 0) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Setting leg progress timeout to %d\n",
                                                                                          switch_channel_get_name(oglobals.originate_status[i].peer_channel), val);
                                                        oglobals.originate_status[i].per_channel_progress_timelimit_sec = (uint32_t) val;
                                                }
                                        }

                                        if ((vvar = switch_channel_get_variable(oglobals.originate_status[i].peer_channel, "leg_delay_start"))) {
                                                int val = atoi(vvar);
                                                if (val > 0) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Setting leg delay start to %d\n",
                                                                                          switch_channel_get_name(oglobals.originate_status[i].peer_channel), val);
                                                        oglobals.originate_status[i].per_channel_delay_start = (uint32_t) val;

                                                        if (oglobals.originate_status[i].per_channel_progress_timelimit_sec != 0) {
                                                                oglobals.originate_status[i].per_channel_progress_timelimit_sec += oglobals.originate_status[i].per_channel_delay_start;
                                                        }

                                                        if (oglobals.originate_status[i].per_channel_timelimit_sec != 0) {
                                                                oglobals.originate_status[i].per_channel_timelimit_sec += oglobals.originate_status[i].per_channel_delay_start;
                                                        }
                                                }
                                        }

                                        if (!zstr(ent_aleg_uuid)) {
                                                l_session = switch_core_session_locate(ent_aleg_uuid);
                                                a_session = l_session;
                                        }

                                        if (a_session) {
                                                switch_channel_t *channel = switch_core_session_get_channel(a_session);
                                                char *val =
                                                        switch_core_session_sprintf(a_session, "%s;%s;%s",
                                                                                                                switch_core_session_get_uuid(oglobals.originate_status[i].peer_session),
                                                                                                                switch_str_nil(switch_channel_get_variable(oglobals.originate_status[i].peer_channel, "callee_id_name")),
                                                                                                                switch_str_nil(switch_channel_get_variable(oglobals.originate_status[i].peer_channel, "callee_id_number")));


                                                switch_channel_set_variable(oglobals.originate_status[i].peer_channel, "originating_leg_uuid", switch_core_session_get_uuid(a_session));

                                                switch_channel_add_variable_var_check(channel, "originated_legs", val, SWITCH_FALSE, SWITCH_STACK_PUSH);

                                        }

                                        if (l_session) {
                                                switch_core_session_rwunlock(l_session);
                                                l_session = NULL;
                                        }

                                        switch_channel_set_variable(oglobals.originate_status[i].peer_channel, "originate_endpoint", chan_type);
                                        switch_channel_execute_on(oglobals.originate_status[i].peer_channel, SWITCH_CHANNEL_EXECUTE_ON_ORIGINATE_VARIABLE);
                                        switch_channel_api_on(oglobals.originate_status[i].peer_channel, SWITCH_CHANNEL_API_ON_ORIGINATE_VARIABLE);
                                }

                                if (table) {
                                        switch_channel_add_state_handler(oglobals.originate_status[i].peer_channel, table);
                                }

                                if (oglobals.monitor_early_media_ring || oglobals.monitor_early_media_fail || oglobals.ignore_early_media == 4) {
                                        switch_channel_set_flag(oglobals.originate_status[i].peer_channel, CF_CONSUME_ON_ORIGINATE);
                                }

                                switch_channel_add_state_handler(oglobals.originate_status[i].peer_channel, &originate_state_handlers);

                                if ((flags & SOF_NOBLOCK) && oglobals.originate_status[i].peer_session) {
                                        status = SWITCH_STATUS_SUCCESS;
                                        *bleg = oglobals.originate_status[i].peer_session;
                                        *cause = SWITCH_CAUSE_SUCCESS;
                                        goto outer_for;
                                }

                                if (!switch_core_session_running(oglobals.originate_status[i].peer_session)) {
                                        if (oglobals.originate_status[i].per_channel_delay_start) {
                                                switch_channel_set_flag(oglobals.originate_status[i].peer_channel, CF_BLOCK_STATE);
                                        }
                                        switch_core_session_thread_launch(oglobals.originate_status[i].peer_session);
                                }
                        }

                        switch_epoch_time_now(&start);

                        for (;;) {
                                uint32_t valid_channels = 0;
                                for (i = 0; i < and_argc; i++) {
                                        int state;
                                        time_t elapsed;

                                        if (!oglobals.originate_status[i].peer_channel) {
                                                continue;
                                        }

                                        state = switch_channel_get_state(oglobals.originate_status[i].peer_channel);

                                        if (state < CS_HANGUP) {
                                                valid_channels++;
                                        } else {
                                                continue;
                                        }

                                        if (state >= CS_ROUTING) {
                                                goto endfor1;
                                        }

                                        if (caller_channel && !switch_channel_ready(caller_channel)) {
                                                goto notready;
                                        }

                                        elapsed = switch_epoch_time_now(NULL) - start;

                                        if (elapsed > (time_t) timelimit_sec) {
                                                to++;
                                                oglobals.idx = IDX_TIMEOUT;
                                                goto notready;
                                        }

                                        if (!oglobals.sent_ring && !oglobals.ignore_ring_ready &&
                                                !oglobals.progress && (progress_timelimit_sec && elapsed > (time_t) progress_timelimit_sec)) {
                                                to++;
                                                oglobals.idx = IDX_TIMEOUT;
                                                if (force_reason == SWITCH_CAUSE_NONE) {
                                                        force_reason = SWITCH_CAUSE_PROGRESS_TIMEOUT;
                                                }
                                                goto notready;
                                        }

                                        switch_cond_next();
                                }

                                check_per_channel_timeouts(&oglobals, and_argc, start, &force_reason);


                                if (valid_channels == 0) {
                                        status = SWITCH_STATUS_GENERR;
                                        goto done;
                                }

                        }

                  endfor1:

                        if (caller_channel) {
                                if (switch_channel_test_flag(caller_channel, CF_PROXY_MODE) ||
                                        switch_channel_test_flag(caller_channel, CF_PROXY_MEDIA) || switch_channel_test_flag(caller_channel, CF_DISABLE_RINGBACK)) {
                                        ringback_data = NULL;
                                }
                        }


#if 0
                        /* changing behaviour ignore_early_media=true must also be explicitly set for previous behaviour */
                        if (ringback_data) {
                                oglobals.early_ok = 0;
                        }
#endif

                        if (ringback_data) {
                                oglobals.sending_ringback = 1;
                        } else {
                                oglobals.ringback_ok = 0;
                        }

                        if (caller_channel) {
                                soft_holding = switch_channel_get_variable(caller_channel, SWITCH_SOFT_HOLDING_UUID_VARIABLE);
                        }

                        while ((!caller_channel || switch_channel_ready(caller_channel) || switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE)) &&
                                        check_channel_status(&oglobals, and_argc, &force_reason, start)) {
                                time_t elapsed = switch_epoch_time_now(NULL) - start;
                                read_packet = 0;

                                if (cancel_cause && *cancel_cause > 0) {
                                        if (force_reason == SWITCH_CAUSE_NONE) {
                                                force_reason = *cancel_cause;
                                        }
                                        oglobals.idx = IDX_CANCEL;
                                        goto notready;
                                }

                                check_per_channel_timeouts(&oglobals, and_argc, start, &force_reason);

                                if (oglobals.session) {
                                        switch_ivr_parse_all_events(oglobals.session);
                                }

                                if (!oglobals.sent_ring && !oglobals.progress && (progress_timelimit_sec && elapsed > (time_t) progress_timelimit_sec)) {
                                        oglobals.idx = IDX_TIMEOUT;
                                        if (force_reason == SWITCH_CAUSE_NONE) {
                                                force_reason = SWITCH_CAUSE_PROGRESS_TIMEOUT;
                                        }
                                        goto notready;
                                }

                                if ((to = (uint8_t) (elapsed >= (time_t) timelimit_sec)) || (fail_on_single_reject && oglobals.hups)) {
                                        int ok = 0;

                                        if (fail_on_single_reject_var) {
                                                if (!switch_true(fail_on_single_reject_var)) {
                                                        ok = 1;

                                                        for (i = 0; i < and_argc; i++) {
                                                                switch_channel_t *pchannel;
                                                                const char *cause_str;

                                                                if (!oglobals.originate_status[i].peer_session) {
                                                                        continue;
                                                                }
                                                                pchannel = switch_core_session_get_channel(oglobals.originate_status[i].peer_session);

                                                                if (switch_channel_down_nosig(pchannel)) {
                                                                        int neg, pos;
                                                                        cause_str = switch_channel_cause2str(switch_channel_get_cause(pchannel));
                                                                        neg = *fail_on_single_reject_var == '!';
                                                                        pos = !!switch_stristr(cause_str, fail_on_single_reject_var);

                                                                        if (neg) {
                                                                                pos = !pos;
                                                                        }

                                                                        if (pos) {
                                                                                ok = 0;
                                                                                break;
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                        if (!ok) {
                                                oglobals.idx = IDX_TIMEOUT;
                                                goto notready;
                                        }
                                }

                                /* read from the channel while we wait if the audio is up on it */
                                if (oglobals.session &&
                                        !switch_channel_test_flag(caller_channel, CF_PROXY_MODE) &&
                                        !switch_channel_test_flag(caller_channel, CF_PROXY_MEDIA) &&
                                        //!switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE) &&
                                        switch_channel_up(caller_channel) &&
                                        (oglobals.ringback_ok
                                         || (switch_channel_test_flag(caller_channel, CF_ANSWERED) || switch_channel_test_flag(caller_channel, CF_EARLY_MEDIA)))) {

                                        switch_status_t tstatus = SWITCH_STATUS_SUCCESS;
                                        int silence = 0;

                                        if (caller_channel && cancel_key) {
                                                if (switch_channel_has_dtmf(caller_channel)) {
                                                        switch_dtmf_t dtmf = { 0, 0 };
                                                        if (switch_channel_dequeue_dtmf(caller_channel, &dtmf) == SWITCH_STATUS_SUCCESS) {
                                                                if (dtmf.digit == *cancel_key) {
                                                                        oglobals.idx = IDX_KEY_CANCEL;
                                                                        goto notready;
                                                                }
                                                        }
                                                }
                                        }

                                        if (switch_channel_media_ready(caller_channel)) {
                                                tstatus = switch_core_session_read_frame(oglobals.session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
                                                if (!SWITCH_READ_ACCEPTABLE(tstatus)) {
                                                        if (soft_holding) {
                                                                switch_channel_set_flag(caller_channel, CF_XFER_ZOMBIE);
                                                        }

                                                        if (switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE)) {
                                                                goto do_continue;
                                                        }
                                                        break;
                                                }

                                                read_packet++;
                                        } else {
                                                read_frame = NULL;
                                        }


                                        if (oglobals.ringback_ok && (oglobals.ring_ready || oglobals.instant_ringback ||
                                                                                                 oglobals.sending_ringback > 1 || oglobals.bridge_early_media > -1)) {
                                                if (oglobals.ringback_ok == 1) {
                                                        switch_status_t rst;

                                                        rst = setup_ringback(&oglobals, oglobals.originate_status, and_argc, ringback_data, &ringback, &write_frame, &write_codec);

                                                        if (oglobals.bridge_early_media > -1) {
                                                                switch_threadattr_t *thd_attr = NULL;
                                                                switch_threadattr_create(&thd_attr, switch_core_session_get_pool(session));
                                                                switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
                                                                early_state.oglobals = &oglobals;
                                                                //early_state.originate_status = oglobals.originate_status;
                                                                early_state.ready = 1;
                                                                early_state.ringback = &ringback;
                                                                early_state.ttl = and_argc;
                                                                switch_mutex_init(&early_state.mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));
                                                                switch_buffer_create_dynamic(&early_state.buffer, 1024, 1024, 0);
                                                                switch_thread_create(&oglobals.ethread, thd_attr, early_thread_run, &early_state, switch_core_session_get_pool(session));
                                                        }


                                                        switch (rst) {
                                                        case SWITCH_STATUS_SUCCESS:
                                                                oglobals.ringback_ok++;
                                                                break;
                                                        case SWITCH_STATUS_FALSE:
                                                                goto notready;
                                                                break;
                                                        case SWITCH_STATUS_BREAK:
                                                                status = SWITCH_STATUS_FALSE;
                                                                goto done;
                                                                break;
                                                        default:
                                                                ringback_data = NULL;
                                                                oglobals.ringback_ok = 0;
                                                                oglobals.sending_ringback = 0;
                                                                break;
                                                        }

                                                        goto do_continue;
                                                }

                                                if (oglobals.bridge_early_media > -1) {
                                                        write_frame.datalen = 0;
                                                        switch_mutex_lock(early_state.mutex);
                                                        if (ringback.asis) {
                                                                uint16_t mlen;
                                                                switch_size_t buflen = switch_buffer_inuse(early_state.buffer);
                                                                if (buflen > sizeof(uint16_t)) {
                                                                        switch_buffer_peek(early_state.buffer, &mlen, sizeof(uint16_t));
                                                                        if (buflen >= (mlen + sizeof(uint16_t))) {
                                                                                switch_buffer_toss(early_state.buffer, sizeof(uint16_t));
                                                                                write_frame.datalen = (uint32_t)switch_buffer_read(early_state.buffer, write_frame.data, mlen);
                                                                        }
                                                                }
                                                        } else {
                                                                if (write_frame.codec && switch_buffer_inuse(early_state.buffer) >= write_frame.codec->implementation->decoded_bytes_per_packet) {
                                                                        write_frame.datalen = (uint32_t)switch_buffer_read(early_state.buffer, write_frame.data,
                                                                                                                                                         write_frame.codec->implementation->decoded_bytes_per_packet);
                                                                }
                                                        }
                                                        switch_mutex_unlock(early_state.mutex);
                                                } else if (ringback.fh) {
                                                        switch_size_t mlen, olen;
                                                        unsigned int pos = 0;

                                                        if (ringback.asis) {
                                                                mlen = write_frame.codec->implementation->encoded_bytes_per_packet;
                                                        } else {
                                                                mlen = write_frame.codec->implementation->samples_per_packet;
                                                        }

                                                        olen = mlen;

                                                        //if (ringback.fh->resampler && ringback.fh->resampler->rfactor > 1) {
                                                        //olen = (switch_size_t) (olen * ringback.fh->resampler->rfactor);
                                                        //}

                                                        switch_core_file_read(ringback.fh, write_frame.data, &olen);

                                                        if (olen == 0) {
                                                                olen = mlen;
                                                                ringback.fh->speed = 0;
                                                                switch_core_file_seek(ringback.fh, &pos, 0, SEEK_SET);
                                                                switch_core_file_read(ringback.fh, write_frame.data, &olen);
                                                                if (olen == 0) {
                                                                        break;
                                                                }
                                                        }
                                                        write_frame.datalen = (uint32_t) (ringback.asis ? olen : olen * 2 * ringback.fh->channels);
                                                        write_frame.samples = (uint32_t) olen;

                                                } else if (ringback.audio_buffer) {
                                                        if ((write_frame.datalen = (uint32_t) switch_buffer_read_loop(ringback.audio_buffer,
                                                                                                                                                                                  write_frame.data,
                                                                                                                                                                                  write_frame.codec->implementation->decoded_bytes_per_packet)) <=
                                                                0) {

                                                                if (soft_holding) {
                                                                        switch_channel_set_flag(caller_channel, CF_XFER_ZOMBIE);
                                                                        goto do_continue;
                                                                }

                                                                break;
                                                        }
                                                } else if (ringback.silence) {
                                                        silence = ringback.silence;
                                                }
                                        } else {
                                                silence = 600;
                                        }

                                        if ((ringback.fh || silence || ringback.audio_buffer || oglobals.bridge_early_media > -1) && write_frame.codec && write_frame.codec->implementation && write_frame.datalen) {
                                                if (silence) {
                                                        write_frame.datalen = read_impl.decoded_bytes_per_packet;
                                                        switch_generate_sln_silence((int16_t *) write_frame.data, write_frame.datalen / 2, write_frame.codec->implementation->number_of_channels, silence);
                                                }

                                                if (switch_core_session_write_frame(oglobals.session, &write_frame, SWITCH_IO_FLAG_NONE, 0) != SWITCH_STATUS_SUCCESS) {
                                                        if (soft_holding) {
                                                                switch_channel_set_flag(caller_channel, CF_XFER_ZOMBIE);
                                                        }
                                                        if (switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE)) {
                                                                goto do_continue;
                                                        }
                                                        break;
                                                }
                                        }

                                }

                        do_continue:

                                if (!read_packet) {
                                        switch_yield(20000);
                                }
                        }

                  notready:

                        if (caller_channel) {
                                holding = switch_channel_get_variable(caller_channel, SWITCH_HOLDING_UUID_VARIABLE);
                                switch_channel_set_variable(caller_channel, SWITCH_HOLDING_UUID_VARIABLE, NULL);

                                if (soft_holding && switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE)) {
                                        holding = soft_holding;
                                        soft_holding = NULL;
                                        switch_channel_set_variable(caller_channel, SWITCH_SOFT_HOLDING_UUID_VARIABLE, NULL);
                                }
                        }

                        if (caller_channel && !switch_channel_ready(caller_channel) && !switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE)) {
                                oglobals.idx = IDX_CANCEL;
                        }

                        if (oglobals.session && (ringback_data || !(switch_channel_test_flag(caller_channel, CF_PROXY_MODE) ||
                                                                                                                switch_channel_test_flag(caller_channel, CF_PROXY_MEDIA)))) {
                                switch_core_session_reset(oglobals.session, SWITCH_FALSE, SWITCH_TRUE);
                        }

                        if (holding) {
                                if (oglobals.idx > IDX_NADA) {
                                        peer_session = oglobals.originate_status[oglobals.idx].peer_session;
                                        peer_channel = oglobals.originate_status[oglobals.idx].peer_channel;
                                        oglobals.originate_status[oglobals.idx].peer_channel = NULL;
                                } else if (and_argc == 1) {
                                        peer_session = oglobals.originate_status[0].peer_session;
                                        peer_channel = oglobals.originate_status[0].peer_channel;
                                        oglobals.originate_status[0].peer_channel = NULL;
                                } else {
                                        for (i = 0; i < and_argc; i++) {
                                                if (!peer_eligible(oglobals.originate_status[i].peer_channel)) {
                                                        continue;
                                                }
                                                if (switch_channel_media_ready(oglobals.originate_status[i].peer_channel)) {
                                                        peer_session = oglobals.originate_status[i].peer_session;
                                                        peer_channel = oglobals.originate_status[i].peer_channel;
                                                        oglobals.originate_status[i].peer_channel = NULL;
                                                        goto end_search;
                                                }
                                        }
                                        for (i = 0; i < and_argc; i++) {
                                                if (!peer_eligible(oglobals.originate_status[i].peer_channel)) {
                                                        continue;
                                                }
                                                if (switch_channel_up_nosig(oglobals.originate_status[i].peer_channel)) {
                                                        peer_session = oglobals.originate_status[i].peer_session;
                                                        peer_channel = oglobals.originate_status[i].peer_channel;
                                                        oglobals.originate_status[i].peer_channel = NULL;
                                                        break;
                                                }
                                        }
                                }

                          end_search:

                                if (peer_channel && switch_channel_down_nosig(peer_channel)) {
                                        switch_core_session_rwunlock(peer_session);
                                        peer_session = NULL;
                                        peer_channel = NULL;

                                }

                                if (oglobals.idx == IDX_TIMEOUT || to || oglobals.idx == IDX_KEY_CANCEL || oglobals.idx == IDX_CANCEL ||
                                        (!peer_session && oglobals.idx == IDX_NADA)) {
                                        const char *dest = NULL;
                                        const char *context = NULL;
                                        const char *dialplan = NULL;
                                        switch_core_session_t *holding_session;

                                        if (caller_channel) {
                                                if (zstr(context)) {
                                                        context = switch_channel_get_variable(caller_channel, "context");
                                                }
                                                if (zstr(dialplan)) {
                                                        dialplan = switch_channel_get_variable(caller_channel, "dialplan");
                                                }
                                        }

                                        if (zstr(context)) {
                                                context = "default";
                                        }

                                        if (zstr(context)) {
                                                dialplan = "XML";
                                        }

                                        if ((holding_session = switch_core_session_locate(holding))) {
                                                switch_channel_t *holding_channel = switch_core_session_get_channel(holding_session);
                                                switch_status_t mstatus = SWITCH_STATUS_FALSE;

                                                if (caller_channel) {
                                                        if ((mstatus = switch_channel_caller_extension_masquerade(caller_channel, holding_channel, 0)) == SWITCH_STATUS_SUCCESS) {
                                                                switch_channel_restart(holding_channel);
                                                        }
                                                }

                                                if (mstatus != SWITCH_STATUS_SUCCESS) {
                                                        if (peer_channel) {
                                                                dest = switch_channel_get_variable(peer_channel, "destination_number");
                                                                context = switch_channel_get_variable(peer_channel, "context");
                                                                dialplan = switch_channel_get_variable(peer_channel, "dialplan");
                                                        } else if (caller_channel) {
                                                                dest = switch_channel_get_variable(caller_channel, "destination_number");
                                                        }
                                                        if (dest) {
                                                                switch_ivr_session_transfer(holding_session, dest, dialplan, context);
                                                        }
                                                }

                                                switch_core_session_rwunlock(holding_session);
                                                holding = NULL;
                                                holding_session = NULL;
                                        }

                                        if (peer_channel) {
                                                switch_channel_hangup(peer_channel, SWITCH_CAUSE_ATTENDED_TRANSFER);
                                                switch_core_session_rwunlock(peer_session);
                                        }
                                        if (force_reason == SWITCH_CAUSE_NONE) {
                                                force_reason = SWITCH_CAUSE_ATTENDED_TRANSFER;
                                        }
                                } else if (zstr(soft_holding)) {

                                        if (peer_channel && switch_channel_ready(peer_channel)) {
                                                switch_core_session_t *holding_session;

                                                if (force_reason == SWITCH_CAUSE_NONE) {
                                                        force_reason = SWITCH_CAUSE_ATTENDED_TRANSFER;
                                                }

                                                if ((holding_session = switch_core_session_locate(holding))) {
                                                        switch_channel_set_variable(switch_core_session_get_channel(holding_session), SWITCH_HANGUP_AFTER_BRIDGE_VARIABLE, "true");
                                                        switch_core_session_rwunlock(holding_session);
                                                }
                                                switch_channel_set_flag(peer_channel, CF_LAZY_ATTENDED_TRANSFER);
                                                switch_ivr_uuid_bridge(holding, switch_core_session_get_uuid(peer_session));
                                                holding = NULL;
                                                oglobals.idx = IDX_XFER;
                                                if (caller_channel && switch_channel_up_nosig(caller_channel) && !switch_channel_test_flag(caller_channel, CF_INTERCEPTED)) {
                                                        switch_channel_hangup(caller_channel, SWITCH_CAUSE_ATTENDED_TRANSFER);
                                                }
                                                caller_channel = NULL;
                                                oglobals.session = NULL;
                                                session = NULL;
                                                switch_core_session_rwunlock(peer_session);
                                        } else {
                                                switch_core_session_t *holding_session;

                                                if ((holding_session = switch_core_session_locate(holding))) {
                                                        switch_channel_t *holding_channel = switch_core_session_get_channel(holding_session);

                                                        if (caller_channel && switch_channel_ready(caller_channel)) {
                                                                switch_channel_set_variable(holding_channel, SWITCH_HANGUP_AFTER_BRIDGE_VARIABLE, "true");
                                                                switch_ivr_uuid_bridge(holding, switch_core_session_get_uuid(session));
                                                                holding = NULL;
                                                        } else {
                                                                switch_channel_hangup(holding_channel, SWITCH_CAUSE_NORMAL_UNSPECIFIED);
                                                        }
                                                        switch_core_session_rwunlock(holding_session);
                                                }
                                        }
                                }

                                peer_session = NULL;
                                peer_channel = NULL;
                        }

                        for (i = 0; i < and_argc; i++) {
                                if (!peer_eligible(oglobals.originate_status[i].peer_channel)) {
                                        continue;
                                }

                                if (i != oglobals.idx) {
                                        holding = NULL;

                                        if (oglobals.idx == IDX_TIMEOUT || to) {
                                                reason = SWITCH_CAUSE_NO_ANSWER;
                                        } else {
                                                if (oglobals.idx == IDX_CANCEL) {
                                                        reason = SWITCH_CAUSE_ORIGINATOR_CANCEL;
                                                } else {
                                                        if (and_argc > 1) {
                                                                reason = SWITCH_CAUSE_LOSE_RACE;
                                                        } else if (!switch_channel_ready(oglobals.originate_status[i].peer_channel)) {
                                                                wait_for_cause(oglobals.originate_status[i].peer_channel);
                                                                if (switch_channel_down_nosig(oglobals.originate_status[i].peer_channel)) {
                                                                        reason = switch_channel_get_cause(oglobals.originate_status[i].peer_channel);
                                                                }
                                                        } else {
                                                                reason = SWITCH_CAUSE_NO_ANSWER;
                                                        }
                                                }
                                        }
                                        if (switch_channel_up_nosig(oglobals.originate_status[i].peer_channel)) {
                                                if (caller_channel && i == 0) {
                                                        holding = switch_channel_get_variable(caller_channel, SWITCH_SOFT_HOLDING_UUID_VARIABLE);
                                                        switch_channel_set_variable(caller_channel, SWITCH_SOFT_HOLDING_UUID_VARIABLE, NULL);
                                                }

                                                if (holding && oglobals.idx != IDX_TIMEOUT && oglobals.idx != IDX_KEY_CANCEL && oglobals.idx < 0) {
                                                        switch_core_session_t *holding_session;

                                                        if ((holding_session = switch_core_session_locate(holding))) {
                                                                switch_channel_t *holding_channel = switch_core_session_get_channel(holding_session);

                                                                switch_channel_set_variable(holding_channel, SWITCH_HANGUP_AFTER_BRIDGE_VARIABLE, "true");

                                                                if (caller_channel && switch_true(switch_channel_get_variable(caller_channel, "recording_follow_transfer"))) {
                                                                        switch_ivr_transfer_recordings(session, oglobals.originate_status[i].peer_session);
                                                                }

                                                                if (switch_true(switch_channel_get_variable(holding_channel, "recording_follow_transfer"))) {
                                                                        switch_ivr_transfer_recordings(holding_session, oglobals.originate_status[i].peer_session);
                                                                }

                                                                switch_core_session_rwunlock(holding_session);
                                                        }
                                                        switch_channel_set_flag(oglobals.originate_status[i].peer_channel, CF_LAZY_ATTENDED_TRANSFER);
                                                        switch_ivr_uuid_bridge(holding, switch_core_session_get_uuid(oglobals.originate_status[i].peer_session));
                                                        holding = NULL;
                                                } else {
                                                        if (force_reason == SWITCH_CAUSE_LOSE_RACE || reason == SWITCH_CAUSE_LOSE_RACE) {
                                                                switch_channel_set_variable(oglobals.originate_status[i].peer_channel, "group_dial_status", "loser");
                                                        }
                                                        switch_channel_hangup(oglobals.originate_status[i].peer_channel, force_reason ? force_reason : reason);
                                                }
                                        }
                                }
                        }



                        if (oglobals.idx > IDX_NADA) {
                                if ((peer_session = oglobals.originate_status[oglobals.idx].peer_session)) {
                                        peer_channel = switch_core_session_get_channel(oglobals.originate_status[oglobals.idx].peer_session);
                                }
                        } else {
                                status = SWITCH_STATUS_FALSE;
                                if (caller_channel && peer_channel) {
                                        switch_process_import(oglobals.session, peer_channel, "import", NULL);
                                }
                                peer_channel = NULL;
                                goto done;
                        }

                        if (caller_channel) {

                                if (switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE) && !switch_channel_up(caller_channel)) {
                                        if (switch_channel_media_up(peer_channel)) {
                                                oglobals.idx = IDX_XFER;
                                                reason = force_reason = SWITCH_CAUSE_ATTENDED_TRANSFER;
                                                switch_channel_execute_on(peer_channel, "execute_on_orphaned_bleg");
                                                switch_channel_api_on(peer_channel, "api_on_orphaned_bleg");
                                        }
                                } else if (switch_channel_test_flag(peer_channel, CF_ANSWERED)) {
                                        switch_channel_pass_callee_id(peer_channel, caller_channel);
                                        if (switch_channel_test_flag(caller_channel, CF_PROXY_MODE)) {
                                                status = SWITCH_STATUS_SUCCESS;
                                        } else {
                                                status = switch_channel_answer(caller_channel);
                                        }
                                } else if (switch_channel_test_flag(peer_channel, CF_EARLY_MEDIA)) {
                                        if (switch_channel_test_flag(caller_channel, CF_PROXY_MODE)) {
                                                status = SWITCH_STATUS_SUCCESS;
                                        } else {
                                                switch_channel_pass_callee_id(peer_channel, caller_channel);
                                                status = switch_channel_pre_answer(caller_channel);
                                        }
                                } else {
                                        status = SWITCH_STATUS_SUCCESS;
                                }

                                if (status != SWITCH_STATUS_SUCCESS) {
                                        switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(peer_channel), SWITCH_LOG_DEBUG, "%s Media Establishment Failed.\n",
                                                                          switch_channel_get_name(caller_channel));
                                        switch_channel_hangup(peer_channel, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION);
                                }
                        }

                        if (switch_channel_test_flag(peer_channel, CF_ANSWERED) ||
                                (oglobals.early_ok && switch_channel_test_flag(peer_channel, CF_EARLY_MEDIA)) ||
                                (oglobals.return_ring_ready && switch_channel_test_flag(peer_channel, CF_RING_READY))
                                ) {
                                *bleg = peer_session;

                                if (oglobals.monitor_early_media_ring || oglobals.monitor_early_media_fail) {
                                        switch_ivr_stop_tone_detect_session(peer_session);
                                        switch_channel_set_private(peer_channel, "_oglobals_", NULL);
                                }

                                status = SWITCH_STATUS_SUCCESS;
                        } else {
                                status = SWITCH_STATUS_FALSE;
                        }

                  done:

                        *cause = SWITCH_CAUSE_NONE;

                        if (caller_channel && !switch_channel_ready(caller_channel)) {
                                status = SWITCH_STATUS_FALSE;
                        }

                        if (status == SWITCH_STATUS_SUCCESS) {
                                if (caller_channel) {
                                        switch_channel_set_variable(caller_channel, "originate_disposition", "call accepted");
                                        if (peer_channel) {
                                                switch_process_import(oglobals.session, peer_channel, "import", NULL);

                                                if (switch_channel_test_flag(peer_channel, CF_ANSWERED)) {
                                                        switch_channel_set_variable(caller_channel, "DIALSTATUS", "EARLY");
                                                } else {
                                                        switch_channel_set_variable(caller_channel, "DIALSTATUS", "ANSWER");
                                                }

                                        }
                                }
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(oglobals.session), SWITCH_LOG_DEBUG, "Originate Resulted in Success: [%s] Peer UUID: %s\n",
                                                                  switch_channel_get_name(peer_channel), switch_channel_get_uuid(peer_channel));
                                *cause = SWITCH_CAUSE_SUCCESS;

                        } else {
                                const char *cdr_var = NULL;
                                const char *json_cdr_var = NULL;

                                switch_xml_t cdr = NULL;
                                cJSON *json_cdr = NULL;

                                char *json_text;
                                char *xml_text;
                                char buf[128] = "", buf2[128] = "";

                                if (caller_channel) {
                                        cdr_var = switch_channel_get_variable(caller_channel, "failed_xml_cdr_prefix");
                                }

                                if (caller_channel) {
                                        json_cdr_var = switch_channel_get_variable(caller_channel, "failed_json_cdr_prefix");
                                }

                                if (peer_channel) {
                                        wait_for_cause(peer_channel);
                                        *cause = switch_channel_get_cause(peer_channel);
                                } else {
                                        for (i = 0; i < and_argc; i++) {
                                                if (!oglobals.originate_status[i].peer_channel) {
                                                        continue;
                                                }
                                                *cause = switch_channel_get_cause(oglobals.originate_status[i].peer_channel);
                                                break;
                                        }
                                }

                                if (cdr_var) {
                                        for (i = 0; i < and_argc; i++) {
                                                switch_channel_t *channel;

                                                if (!oglobals.originate_status[i].peer_session) {
                                                        continue;
                                                }

                                                channel = switch_core_session_get_channel(oglobals.originate_status[i].peer_session);

                                                switch_channel_wait_for_state_timeout(channel, CS_REPORTING, 5000);

                                                if (!switch_channel_test_flag(channel, CF_TIMESTAMP_SET)) {
                                                        switch_channel_set_timestamps(channel);
                                                }

                                                if (switch_ivr_generate_xml_cdr(oglobals.originate_status[i].peer_session, &cdr) == SWITCH_STATUS_SUCCESS) {
                                                        if ((xml_text = switch_xml_toxml(cdr, SWITCH_FALSE))) {
                                                                switch_snprintf(buf, sizeof(buf), "%s_%d", cdr_var, ++cdr_total);
                                                                switch_channel_set_variable(caller_channel, buf, xml_text);
                                                                switch_safe_free(xml_text);
                                                        }
                                                        switch_xml_free(cdr);
                                                        cdr = NULL;
                                                }

                                        }
                                        switch_snprintf(buf, sizeof(buf), "%s_total", cdr_var);
                                        switch_snprintf(buf2, sizeof(buf2), "%d", cdr_total ? cdr_total : 0);
                                        switch_channel_set_variable(caller_channel, buf, buf2);
                                }

                                if (json_cdr_var) {
                                        for (i = 0; i < and_argc; i++) {
                                                switch_channel_t *channel;

                                                if (!oglobals.originate_status[i].peer_session) {
                                                        continue;
                                                }

                                                channel = switch_core_session_get_channel(oglobals.originate_status[i].peer_session);

                                                switch_channel_wait_for_state_timeout(channel, CS_REPORTING, 5000);

                                                if (!switch_channel_test_flag(channel, CF_TIMESTAMP_SET)) {
                                                        switch_channel_set_timestamps(channel);
                                                }

                                                if (switch_ivr_generate_json_cdr(oglobals.originate_status[i].peer_session, &json_cdr, SWITCH_TRUE) == SWITCH_STATUS_SUCCESS) {
                                                        json_text = cJSON_PrintUnformatted(json_cdr);
                                                        switch_snprintf(buf, sizeof(buf), "%s_%d", json_cdr_var, ++cdr_total);
                                                        switch_channel_set_variable(caller_channel, buf, json_text);
                                                        // switch_safe_free(json_text);
                                                        cJSON_Delete(json_cdr);
                                                        json_cdr = NULL;
                                                }

                                        }
                                        switch_snprintf(buf, sizeof(buf), "%s_total", json_cdr_var);
                                        switch_snprintf(buf2, sizeof(buf2), "%d", cdr_total ? cdr_total : 0);
                                        switch_channel_set_variable(caller_channel, buf, buf2);
                                }

                                if (caller_channel && switch_channel_test_flag(caller_channel, CF_INTERCEPTED)) {
                                        *cause = SWITCH_CAUSE_PICKED_OFF;
                                }

                                if (!*cause) {
                                        if (reason) {
                                                *cause = reason;
                                        } else if (caller_channel) {
                                                *cause = switch_channel_get_cause(caller_channel);
                                        } else {
                                                *cause = SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
                                                for (i = 0; i < and_argc; i++) {
                                                        if (!peer_eligible(oglobals.originate_status[i].peer_channel)) {
                                                                continue;
                                                        }

                                                        wait_for_cause(oglobals.originate_status[i].peer_channel);

                                                        if (switch_channel_down_nosig(oglobals.originate_status[i].peer_channel)) {
                                                                *cause = switch_channel_get_cause(oglobals.originate_status[i].peer_channel);
                                                                break;
                                                        }

                                                }
                                        }
                                }

                                if (*cause == SWITCH_CAUSE_SUCCESS || *cause == SWITCH_CAUSE_NONE) {
                                        *cause = SWITCH_CAUSE_ORIGINATOR_CANCEL;
                                }

                                if (oglobals.idx == IDX_CANCEL) {
                                        *cause = SWITCH_CAUSE_ORIGINATOR_CANCEL;
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(oglobals.session), SWITCH_LOG_DEBUG,
                                                                          "Originate Cancelled by originator termination Cause: %d [%s]\n", *cause, switch_channel_cause2str(*cause));

                                } else if (oglobals.idx == IDX_TIMEOUT) {
                                        *cause = SWITCH_CAUSE_NO_ANSWER;
                                } else {
                                        if (oglobals.idx == IDX_XFER) {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(oglobals.session), SWITCH_LOG_DEBUG,
                                                                                  "Originate Resulted in Attended Transfer Cause: %d [%s]\n", *cause, switch_channel_cause2str(*cause));
                                        } else {

                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(oglobals.session), SWITCH_LOG_DEBUG,
                                                                                  "Originate Resulted in Error Cause: %d [%s]\n", *cause, switch_channel_cause2str(*cause));
                                        }
                                }
                        }

                        if (caller_channel) {
                                switch_channel_set_variable(caller_channel, "originate_disposition", switch_channel_cause2str(*cause));

                                switch (*cause) {
                                case SWITCH_CAUSE_ORIGINATOR_CANCEL:
                                        switch_channel_set_variable(caller_channel, "DIALSTATUS", "CANCEL");
                                        break;
                                case SWITCH_CAUSE_USER_BUSY:
                                        switch_channel_set_variable(caller_channel, "DIALSTATUS", "BUSY");
                                        break;
                                case SWITCH_CAUSE_NO_ANSWER:
                                        switch_channel_set_variable(caller_channel, "DIALSTATUS", "NOANSWER");
                                        break;
                                case SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER:
                                case SWITCH_CAUSE_INVALID_PROFILE:
                                        switch_channel_set_variable(caller_channel, "DIALSTATUS", "INVALIDARGS");
                                        break;
                                case SWITCH_CAUSE_CALL_REJECTED:
                                        switch_channel_set_variable(caller_channel, "DIALSTATUS", "DONTCALL");
                                        break;
                                default:
                                        switch_channel_set_variable(caller_channel, "DIALSTATUS", switch_channel_cause2str(*cause));
                                        break;
                                }
                        }

                        early_state.ready = 0;

                        if (oglobals.ethread) {
                                switch_status_t st;
                                switch_thread_join(&st, oglobals.ethread);
                        }

                        if (early_state.buffer) {
                                switch_buffer_destroy(&early_state.buffer);
                        }

                        if (ringback.fh) {
                                switch_core_file_close(ringback.fh);
                                ringback.fh = NULL;
                        } else if (ringback.audio_buffer) {
                                teletone_destroy_session(&ringback.ts);
                                switch_safe_free(ringback.mux_buf);
                                switch_buffer_destroy(&ringback.audio_buffer);
                        }

                        if (oglobals.session) {
                                switch_core_session_reset(oglobals.session, SWITCH_FALSE, SWITCH_TRUE);
                        }

                        if (switch_core_codec_ready(&write_codec)) {
                                switch_core_codec_destroy(&write_codec);
                        }

                        for (i = 0; i < and_argc; i++) {
                                switch_channel_state_t state;
                                switch_core_session_t *peer_session;
                                char *val;

                                if (!oglobals.originate_status[i].peer_channel) {
                                        continue;
                                }

                                if (session) {
                                        val = switch_core_session_sprintf(oglobals.originate_status[i].peer_session, "%s;%s",
                                                                                                          switch_core_session_get_uuid(oglobals.originate_status[i].peer_session),
                                                                                                          switch_channel_cause2str(switch_channel_get_cause(oglobals.originate_status[i].peer_channel)));

                                        switch_channel_add_variable_var_check(switch_core_session_get_channel(session), "originate_causes", val, SWITCH_FALSE, SWITCH_STACK_PUSH);
                                }

                                if (status == SWITCH_STATUS_SUCCESS) {
                                        switch_channel_clear_flag(oglobals.originate_status[i].peer_channel, CF_ORIGINATING);
                                        if (bleg && *bleg && *bleg == oglobals.originate_status[i].peer_session) {
                                                continue;
                                        }
                                } else if ((state = switch_channel_get_state(oglobals.originate_status[i].peer_channel)) < CS_HANGUP &&
                                                   switch_channel_test_flag(oglobals.originate_status[i].peer_channel, CF_ORIGINATING)) {
                                        if (!(state == CS_RESET || switch_channel_test_flag(oglobals.originate_status[i].peer_channel, CF_TRANSFER) ||
                                                  switch_channel_test_flag(oglobals.originate_status[i].peer_channel, CF_REDIRECT) ||
                                                  switch_channel_test_flag(oglobals.originate_status[i].peer_channel, CF_BRIDGED))) {
                                                if (caller_channel && switch_channel_test_flag(caller_channel, CF_INTERCEPTED)) {
                                                        switch_channel_set_flag(oglobals.originate_status[i].peer_channel, CF_INTERCEPT);
                                                }
                                                switch_channel_hangup(oglobals.originate_status[i].peer_channel, *cause);
                                        }
                                }
                                switch_channel_clear_flag(oglobals.originate_status[i].peer_channel, CF_ORIGINATING);

                                peer_session = oglobals.originate_status[i].peer_session;
                                oglobals.originate_status[i].down_session = oglobals.originate_status[i].peer_session;
                                oglobals.originate_status[i].peer_session = NULL;
                                oglobals.originate_status[i].peer_channel = NULL;

                                switch_core_session_rwunlock(peer_session);
                        }

                        if (status == SWITCH_STATUS_SUCCESS || oglobals.idx == IDX_XFER) {
                                goto outer_for;
                        } else {
                                int ok = 1;

                                if (fail_on_single_reject && check_reject && !switch_true(fail_on_single_reject_var)) {
                                        for (i = 0; i < and_argc; i++) {
                                                switch_channel_t *pchannel;
                                                const char *cause_str;

                                                if (!oglobals.originate_status[i].down_session) {
                                                        continue;
                                                }

                                                pchannel = switch_core_session_get_channel(oglobals.originate_status[i].down_session);
                                                wait_for_cause(pchannel);

                                                if (switch_channel_down_nosig(pchannel)) {
                                                        int neg, pos;

                                                        cause_str = switch_channel_cause2str(switch_channel_get_cause(pchannel));

                                                        neg = *fail_on_single_reject_var == '!';
                                                        pos = !!switch_stristr(cause_str, fail_on_single_reject_var);

                                                        if (neg) {
                                                                pos = !pos;
                                                        }

                                                        if (pos) {
                                                                ok = 0;
                                                                break;
                                                        }
                                                }
                                        }
                                }

                                if (!ok) {
                                        goto outer_for;
                                }

                                if (to && !oglobals.continue_on_timeout) {
                                        goto outer_for;
                                }
                        }
                }
        }
  outer_for:
        switch_safe_free(loop_data);
        switch_safe_free(odata);
        switch_safe_free(oglobals.file);
        switch_safe_free(oglobals.error_file);

        if (bleg && status != SWITCH_STATUS_SUCCESS) {
                *bleg = NULL;
        }

        if (bleg && !*bleg && status == SWITCH_STATUS_SUCCESS) {
                status = SWITCH_STATUS_FALSE;
        }

        if (bleg && *bleg) {
                switch_channel_t *bchan = switch_core_session_get_channel(*bleg);

                if (session && caller_channel) {
                        switch_caller_profile_t *cloned_profile, *peer_profile = switch_channel_get_caller_profile(switch_core_session_get_channel(*bleg));

                        if (peer_profile) {
                                if ((cloned_profile = switch_caller_profile_clone(session, peer_profile)) != 0) {
                                        switch_channel_set_originatee_caller_profile(caller_channel, cloned_profile);
                                }
                        }

                        switch_channel_set_variable(caller_channel, SWITCH_SIGNAL_BOND_VARIABLE, switch_core_session_get_uuid(*bleg));
                        // Now main SWITCH_SIGNAL_BOND_VARIABLE is populated, don't need this one anymore...
                        switch_channel_set_variable(caller_channel, SWITCH_ORIGINATE_SIGNAL_BOND_VARIABLE, NULL);
                }


                switch_channel_execute_on(bchan, SWITCH_CHANNEL_EXECUTE_ON_POST_ORIGINATE_VARIABLE);
                switch_channel_api_on(bchan, SWITCH_CHANNEL_API_ON_POST_ORIGINATE_VARIABLE);


                while(switch_channel_state_change_pending(bchan)) {
                        switch_cond_next();
                }

                switch_channel_audio_sync(bchan);

                if (caller_channel) {
                        switch_channel_audio_sync(caller_channel);
                }
        }

        if (oglobals.session) {
                switch_ivr_parse_all_events(oglobals.session);
        }

        if (oglobals.session && status == SWITCH_STATUS_SUCCESS) {
                switch_ivr_sleep(oglobals.session, 0, SWITCH_TRUE, NULL);
        }

        if (var_event && var_event != ovars) {
                switch_event_destroy(&var_event);
        }

        switch_safe_free(write_frame.data);
        switch_safe_free(fail_on_single_reject_var);

        if (force_reason != SWITCH_CAUSE_NONE) {
                *cause = force_reason;
        }

        if (caller_channel) {

                switch_channel_execute_on(caller_channel, SWITCH_CHANNEL_EXECUTE_ON_POST_ORIGINATE_VARIABLE);
                switch_channel_api_on(caller_channel, SWITCH_CHANNEL_API_ON_POST_ORIGINATE_VARIABLE);

                switch_channel_clear_flag(caller_channel, CF_ORIGINATOR);
                switch_channel_clear_flag(caller_channel, CF_XFER_ZOMBIE);

                if (hangup_on_single_reject) {
                        switch_channel_hangup(caller_channel, *cause);
                }
        }


        switch_core_destroy_memory_pool(&oglobals.pool);

        return status;
}

switch_ivr_park()

switch_status_t switch_ivr_park	(	switch_core_session_t *	session,
		switch_input_args_t *	args
	)

Definition at line 946 of file switch_ivr.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_CONTROLLED, CF_PARK, CF_RECOVERED, CF_SERVICE, CF_UNICAST, switch_frame::codec, CS_RESET, switch_frame::data, switch_frame::datalen, switch_codec_implementation::decoded_bytes_per_packet, switch_dtmf_t::digit, switch_input_args_t::dmachine, switch_input_args_t::input_callback, memset(), switch_codec_implementation::microseconds_per_packet, switch_codec_implementation::number_of_channels, switch_unicast_conninfo::read_codec, switch_unicast_conninfo::remote_addr, switch_frame::samples, switch_codec_implementation::samples_per_second, SFF_CNG, switch_unicast_conninfo::socket, SUF_NATIVE, switch_assert, SWITCH_CAUSE_NORMAL_CLEARING, switch_channel_clear_flag(), switch_channel_dequeue_dtmf(), switch_channel_event_set_data(), switch_channel_get_private(), switch_channel_get_state(), 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_variable, switch_channel_str2cause(), switch_channel_test_flag(), SWITCH_CODEC_FLAG_DECODE, SWITCH_CODEC_FLAG_ENCODE, switch_cond_next(), switch_core_codec_decode(), switch_core_codec_destroy(), switch_core_codec_init, switch_core_session_dequeue_event(), switch_core_session_dequeue_private_event(), switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_codec(), switch_core_session_get_read_impl(), switch_core_session_read_frame(), switch_core_session_write_frame(), switch_epoch_time_now(), SWITCH_EVENT_CHANNEL_PARK, SWITCH_EVENT_CHANNEL_UNPARK, switch_event_create, switch_event_destroy(), switch_event_fire, SWITCH_FALSE, switch_generate_sln_silence(), switch_goto_status, SWITCH_INPUT_TYPE_DTMF, SWITCH_INPUT_TYPE_EVENT, SWITCH_IO_FLAG_NONE, switch_ivr_deactivate_unicast(), switch_ivr_dmachine_feed(), switch_ivr_dmachine_ping(), switch_ivr_parse_all_events(), switch_ivr_parse_event(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, SWITCH_LOG_NOTICE, switch_log_printf(), SWITCH_PARK_AFTER_BRIDGE_VARIABLE, SWITCH_READ_ACCEPTABLE, SWITCH_RECOMMENDED_BUFFER_SIZE, switch_safe_free, SWITCH_SEND_SILENCE_WHEN_IDLE_VARIABLE, switch_socket_sendto(), SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_NOOP, SWITCH_STATUS_SUCCESS, switch_test_flag, switch_yield, switch_zmalloc, to, and unicast_thread_launch().

Referenced by switch_core_standard_on_park().

{
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_frame_t *read_frame = NULL;
        int stream_id = 0;
        switch_event_t *event;
        switch_unicast_conninfo_t *conninfo = NULL;
        uint32_t rate = 0;
        uint32_t bpf = 0;
        const char *to;
        int timeout = 0;
        time_t expires = 0;
        switch_codec_implementation_t read_impl = { 0 };
        switch_call_cause_t timeout_cause = SWITCH_CAUSE_NORMAL_CLEARING;
        switch_codec_t codec = { 0 };
        int sval = 0;
        const char *var;
        switch_frame_t write_frame = { 0 };
        unsigned char *abuf = NULL;
        switch_codec_implementation_t imp = { 0 };



        if (switch_channel_test_flag(channel, CF_RECOVERED) && switch_channel_test_flag(channel, CF_CONTROLLED)) {
                switch_channel_clear_flag(channel, CF_CONTROLLED);
        }

        if (switch_channel_test_flag(channel, CF_CONTROLLED)) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot park channels that are under control already.\n");
                return SWITCH_STATUS_FALSE;
        }

        if (switch_channel_get_state(channel) == CS_RESET) {
                return SWITCH_STATUS_FALSE;
        }

        arg_recursion_check_start(args);

        if ((to = switch_channel_get_variable(channel, "park_timeout"))) {
                char *cause_str;

                if ((cause_str = strchr(to, ':'))) {
                        timeout_cause = switch_channel_str2cause(cause_str + 1);
                }

                if ((timeout = atoi(to)) >= 0) {
                        expires = switch_epoch_time_now(NULL) + timeout;
                }
                switch_channel_set_variable(channel, "park_timeout", NULL);
                switch_channel_set_variable(channel, SWITCH_PARK_AFTER_BRIDGE_VARIABLE, NULL);
        }

        switch_channel_set_flag(channel, CF_CONTROLLED);
        switch_channel_set_flag(channel, CF_PARK);

        if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_PARK) == SWITCH_STATUS_SUCCESS) {
                switch_channel_event_set_data(channel, event);
                switch_event_fire(&event);
        }

        while (switch_channel_ready(channel) && switch_channel_test_flag(channel, CF_CONTROLLED) && switch_channel_test_flag(channel, CF_PARK)) {

                if (!rate && switch_channel_media_ready(channel)) {
                        switch_core_session_get_read_impl(session, &read_impl);
                        rate = read_impl.actual_samples_per_second;
                        bpf = read_impl.decoded_bytes_per_packet;

                        if (rate && (var = switch_channel_get_variable(channel, SWITCH_SEND_SILENCE_WHEN_IDLE_VARIABLE)) && (sval = atoi(var))) {
                                switch_core_session_get_read_impl(session, &imp);

                                if (switch_core_codec_init(&codec,
                                                                   "L16",
                                                                   NULL,
                                                                   NULL,
                                                                   imp.actual_samples_per_second,
                                                                   imp.microseconds_per_packet / 1000,
                                                                   imp.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_ERROR, "Codec Error L16@%uhz %u channels %dms\n",
                                                                          imp.samples_per_second, imp.number_of_channels, imp.microseconds_per_packet / 1000);
                                        switch_goto_status(SWITCH_STATUS_FALSE, end);
                                }


                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Codec Activated L16@%uhz %u channels %dms\n",
                                                                  imp.samples_per_second, imp.number_of_channels, imp.microseconds_per_packet / 1000);

                                write_frame.codec = &codec;
                                switch_zmalloc(abuf, SWITCH_RECOMMENDED_BUFFER_SIZE);
                                write_frame.data = abuf;
                                write_frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE;
                                write_frame.datalen = imp.decoded_bytes_per_packet;
                                write_frame.samples = write_frame.datalen / sizeof(int16_t);
                        }
                }

                if (rate) {
                        if (switch_channel_test_flag(channel, CF_SERVICE)) {
                                switch_cond_next();
                                status = SWITCH_STATUS_SUCCESS;
                        } else {
                                status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, stream_id);
                        }
                } else {
                        switch_yield(20000);

                        if (switch_core_session_dequeue_private_event(session, &event) == SWITCH_STATUS_SUCCESS) {
                                switch_ivr_parse_event(session, event);
                                switch_event_destroy(&event);
                        }

                        status = SWITCH_STATUS_SUCCESS;
                }

                if (!SWITCH_READ_ACCEPTABLE(status)) {
                        break;
                }

                if (rate && write_frame.data && sval) {
                        switch_generate_sln_silence((int16_t *) write_frame.data, write_frame.samples, read_impl.number_of_channels, sval);
                        switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0);
                }

                if (expires && switch_epoch_time_now(NULL) >= expires) {
                        switch_channel_hangup(channel, timeout_cause);
                        break;
                }

                if (switch_channel_test_flag(channel, CF_UNICAST)) {
                        if (!switch_channel_media_ready(channel)) {
                                if (switch_channel_pre_answer(channel) != SWITCH_STATUS_SUCCESS) {
                                        switch_goto_status(SWITCH_STATUS_FALSE, end);
                                }
                        }

                        if (!conninfo) {
                                if (!(conninfo = switch_channel_get_private(channel, "unicast"))) {
                                        switch_channel_clear_flag(channel, CF_UNICAST);
                                }

                                if (conninfo) {
                                        unicast_thread_launch(conninfo);
                                }
                        }

                        if (conninfo) {
                                switch_size_t len = 0;
                                uint32_t flags = 0;
                                switch_byte_t decoded[SWITCH_RECOMMENDED_BUFFER_SIZE];
                                uint32_t dlen = sizeof(decoded);
                                switch_status_t tstatus;
                                switch_byte_t *sendbuf = NULL;
                                uint32_t sendlen = 0;

                                switch_assert(read_frame);

                                if (switch_test_flag(read_frame, SFF_CNG)) {
                                        sendlen = bpf;
                                        switch_assert(sendlen <= SWITCH_RECOMMENDED_BUFFER_SIZE);
                                        memset(decoded, 255, sendlen);
                                        sendbuf = decoded;
                                        tstatus = SWITCH_STATUS_SUCCESS;
                                } else {
                                        if (switch_test_flag(conninfo, SUF_NATIVE)) {
                                                tstatus = SWITCH_STATUS_NOOP;
                                        } else {
                                                switch_codec_t *read_codec = switch_core_session_get_read_codec(session);
                                                tstatus = switch_core_codec_decode(read_codec,
                                                                                                                   &conninfo->read_codec,
                                                                                                                   read_frame->data,
                                                                                                                   read_frame->datalen, read_impl.actual_samples_per_second, decoded, &dlen, &rate, &flags);
                                        }
                                        switch (tstatus) {
                                        case SWITCH_STATUS_NOOP:
                                        case SWITCH_STATUS_BREAK:
                                                sendbuf = read_frame->data;
                                                sendlen = read_frame->datalen;
                                                tstatus = SWITCH_STATUS_SUCCESS;
                                                break;
                                        case SWITCH_STATUS_SUCCESS:
                                                sendbuf = decoded;
                                                sendlen = dlen;
                                                tstatus = SWITCH_STATUS_SUCCESS;
                                                break;
                                        default:
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Codec Error\n");
                                                switch_ivr_deactivate_unicast(session);
                                                break;
                                        }
                                }

                                if (tstatus == SWITCH_STATUS_SUCCESS) {
                                        len = sendlen;
                                        if (switch_socket_sendto(conninfo->socket, conninfo->remote_addr, 0, (void *) sendbuf, &len) != SWITCH_STATUS_SUCCESS) {
                                                switch_ivr_deactivate_unicast(session);
                                        }
                                }
                        }
                }

                switch_ivr_parse_all_events(session);


                if (switch_channel_has_dtmf(channel)) {
                        switch_dtmf_t dtmf = { 0 };

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

                        switch_channel_dequeue_dtmf(channel, &dtmf);

                        if (args) {
                                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) {
                                        if ((status = args->input_callback(session, (void *) &dtmf, SWITCH_INPUT_TYPE_DTMF, args->buf, args->buflen)) != SWITCH_STATUS_SUCCESS) {
                                                break;
                                        }
                                }
                        }
                }

                if (switch_core_session_dequeue_event(session, &event, SWITCH_FALSE) == SWITCH_STATUS_SUCCESS) {
                        if (args && args->input_callback) {
                                switch_status_t ostatus;

                                if ((ostatus = args->input_callback(session, event, SWITCH_INPUT_TYPE_EVENT, args->buf, args->buflen)) != SWITCH_STATUS_SUCCESS) {
                                        status = ostatus;
                                        break;
                                }
                        } else {
                                switch_channel_event_set_data(channel, event);
                                switch_event_fire(&event);
                        }
                }

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


        }

 end:

        arg_recursion_check_stop(args);

        if (write_frame.codec) {
                switch_core_codec_destroy(&codec);
        }

        switch_safe_free(abuf);

        switch_channel_clear_flag(channel, CF_CONTROLLED);
        switch_channel_clear_flag(channel, CF_PARK);

        if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_UNPARK) == SWITCH_STATUS_SUCCESS) {
                switch_channel_event_set_data(channel, event);
                switch_event_fire(&event);
        }

        if (switch_channel_test_flag(channel, CF_UNICAST)) {
                switch_ivr_deactivate_unicast(session);
        }

        return status;
}

switch_ivr_parse_all_events()

switch_status_t switch_ivr_parse_all_events

(

switch_core_session_t *

session

)

Parse all commands from an event.

Parameters

session

the session on which to parse the events

Returns

SWITCH_STATUS_SUCCESS if successful

Definition at line 913 of file switch_ivr.c.

References CF_BLOCK_BROADCAST_UNTIL_MEDIA, CF_PROXY_MODE, switch_channel_clear_flag(), switch_channel_media_up, SWITCH_CHANNEL_SESSION_LOG, switch_channel_test_flag(), switch_core_session_get_channel(), switch_core_session_get_name, switch_core_session_stack_count(), switch_ivr_parse_all_messages(), switch_ivr_parse_next_event(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_MAX_STACKS, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by check_channel_status(), switch_core_session_run(), switch_ivr_collect_digits_callback(), switch_ivr_collect_digits_count(), switch_ivr_gentones(), switch_ivr_multi_threaded_bridge(), switch_ivr_originate(), switch_ivr_park(), switch_ivr_play_file(), switch_ivr_record_file_event(), switch_ivr_session_echo(), switch_ivr_sleep(), switch_ivr_speak_text_handle(), and switch_ivr_wait_for_answer().

{
        switch_channel_t *channel;
        uint32_t stack_count = 0;
        if ((stack_count = switch_core_session_stack_count(session, 0)) > SWITCH_MAX_STACKS) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error %s too many stacked extensions [depth=%d]\n",
                                                  switch_core_session_get_name(session), stack_count);
                return SWITCH_STATUS_FALSE;
        }

        switch_core_session_stack_count(session, 1);

        switch_ivr_parse_all_messages(session);

        channel = switch_core_session_get_channel(session);

        if (!switch_channel_test_flag(channel, CF_PROXY_MODE) && switch_channel_test_flag(channel, CF_BLOCK_BROADCAST_UNTIL_MEDIA)) {
                if (switch_channel_media_up(channel)) {
                        switch_channel_clear_flag(channel, CF_BLOCK_BROADCAST_UNTIL_MEDIA);
                } else {
                        goto done;
                }
        }

        while (switch_ivr_parse_next_event(session) == SWITCH_STATUS_SUCCESS) {}

 done:
        switch_core_session_stack_count(session, -1);
        
        return SWITCH_STATUS_SUCCESS;
}

switch_ivr_parse_all_messages()

switch_status_t switch_ivr_parse_all_messages

(

switch_core_session_t *

session

)

Definition at line 847 of file switch_ivr.c.

References switch_core_session_dequeue_message(), switch_core_session_free_message(), switch_core_session_receive_message, switch_ivr_parse_all_signal_data(), switch_ivr_process_indications(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by audio_bridge_thread(), enterprise_originate_ringback_thread(), originate_on_consume_media_transmit(), read_rtp_packet(), signal_bridge_on_hibernate(), switch_core_session_run(), switch_ivr_multi_threaded_bridge(), switch_ivr_parse_all_events(), switch_ivr_play_file(), switch_ivr_speak_text_handle(), and switch_ivr_wait_for_answer().

{
        switch_core_session_message_t *message;
        int i = 0;

        switch_ivr_parse_all_signal_data(session);

        while (switch_core_session_dequeue_message(session, &message) == SWITCH_STATUS_SUCCESS) {
                i++;

                if (switch_ivr_process_indications(session, message) == SWITCH_STATUS_SUCCESS) {
                        switch_core_session_free_message(&message);
                } else {
                        switch_core_session_receive_message(session, message);
                        message = NULL;
                }
        }

        return i ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
}

switch_ivr_parse_all_signal_data()

switch_status_t switch_ivr_parse_all_signal_data

(

switch_core_session_t *

session

)

Definition at line 905 of file switch_ivr.c.

References SWITCH_FALSE, switch_ivr_parse_signal_data(), and SWITCH_TRUE.

Referenced by switch_ivr_parse_all_messages().

                                                                                                 {
        return switch_ivr_parse_signal_data(session, SWITCH_TRUE, SWITCH_FALSE);
}

switch_ivr_parse_event()

switch_status_t switch_ivr_parse_event	(	_In_ switch_core_session_t *	session,
		_In_ switch_event_t *	event
	)

Parse command from an event.

Parameters

session	the session on which to parse the event
event	the event to parse

Returns

SWITCH_STATUS_SUCCESS if successful

switch_ivr_parse_next_event()

switch_status_t switch_ivr_parse_next_event

(

switch_core_session_t *

session

)

Definition at line 796 of file switch_ivr.c.

References switch_channel_event_set_data(), switch_core_session_dequeue_private_event(), switch_core_session_get_channel(), switch_event_fire, switch_event_prep_for_delivery, SWITCH_EVENT_PRIVATE_COMMAND, switch_ivr_parse_event(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by audio_bridge_thread(), and switch_ivr_parse_all_events().

{
        switch_event_t *event;
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (switch_core_session_dequeue_private_event(session, &event) == SWITCH_STATUS_SUCCESS) {
                status = switch_ivr_parse_event(session, event);
                event->event_id = SWITCH_EVENT_PRIVATE_COMMAND;
                switch_event_prep_for_delivery(event);
                switch_channel_event_set_data(switch_core_session_get_channel(session), event);
                switch_event_fire(&event);
        }

        return status;

}

switch_ivr_parse_next_signal_data()

switch_status_t switch_ivr_parse_next_signal_data

(

switch_core_session_t *

session

)

Definition at line 909 of file switch_ivr.c.

References SWITCH_FALSE, and switch_ivr_parse_signal_data().

                                                                                                  {
        return switch_ivr_parse_signal_data(session, SWITCH_FALSE, SWITCH_FALSE);
}

switch_ivr_parse_signal_data()

switch_status_t switch_ivr_parse_signal_data	(	switch_core_session_t *	session,
		switch_bool_t	all,
		switch_bool_t	only_session_thread
	)

Definition at line 869 of file switch_ivr.c.

References CF_SIGNAL_DATA, switch_core_session_message::from, switch_core_session_message::message_id, switch_core_session_message::pointer_arg, switch_channel_clear_flag(), switch_channel_set_flag, switch_channel_test_flag(), switch_core_session_dequeue_signal_data(), switch_core_session_get_channel(), switch_core_session_in_thread(), switch_core_session_receive_message, SWITCH_MESSAGE_INDICATE_SIGNAL_DATA, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_channel_check_signal(), switch_ivr_parse_all_signal_data(), and switch_ivr_parse_next_signal_data().

{
        void *data;
        switch_core_session_message_t msg = { 0 };
        int i = 0;
        switch_channel_t *channel = switch_core_session_get_channel(session);

        if (only_session_thread && !switch_core_session_in_thread(session)) {
                return SWITCH_STATUS_FALSE;
        }

        if (switch_channel_test_flag(channel, CF_SIGNAL_DATA)) {
                return SWITCH_STATUS_FALSE;
        }

        switch_channel_set_flag(channel, CF_SIGNAL_DATA);

        msg.message_id = SWITCH_MESSAGE_INDICATE_SIGNAL_DATA;
        msg.from = __FILE__;

        while (switch_core_session_dequeue_signal_data(session, &data) == SWITCH_STATUS_SUCCESS) {
                i++;

                msg.pointer_arg = data;
                switch_core_session_receive_message(session, &msg);

                data = NULL;
                if (!all)
                        break;
        }

        switch_channel_clear_flag(channel, CF_SIGNAL_DATA);

        return i ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
}

switch_ivr_pause_detect_speech()

switch_status_t switch_ivr_pause_detect_speech

(

switch_core_session_t *

session

)

Pause background Speech detection on a session.

Parameters

session

The session to pause detection on

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 5245 of file switch_ivr_async.c.

References speech_thread_handle::ah, switch_channel_get_private(), switch_core_asr_pause(), switch_core_session_get_channel(), SWITCH_SPEECH_KEY, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by CoreSession::detectSpeech(), switch_ivr_play_and_collect_input(), and switch_ivr_play_and_detect_speech().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);

        if (sth) {
                switch_core_asr_pause(sth->ah);
                return SWITCH_STATUS_SUCCESS;
        }
        return SWITCH_STATUS_FALSE;
}

switch_ivr_play_and_detect_speech()

switch_status_t switch_ivr_play_and_detect_speech	(	switch_core_session_t *	session,
		const char *	file,
		const char *	mod_name,
		const char *	grammar,
		char **	result,
		uint32_t	input_timeout,
		switch_input_args_t *	args
	)

play a file to the session while doing speech recognition.

Parameters

session	the session to play and detect on
file	the path to the file
mod_name	the module name of the ASR library
grammar	the grammar text, URI, or local file name
result	of speech recognition, allocated from the session pool
input_timeout	time to wait for input
args	arguements to pass for callbacks etc

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 4882 of file switch_ivr_async.c.

References arg_recursion_check_start, arg_recursion_check_stop, switch_input_args_t::buf, switch_input_args_t::buflen, switch_input_args_t::dmachine, play_and_detect_speech_state_t::done, switch_input_args_t::input_callback, play_and_detect_speech_state_t::original_args, PLAY_AND_DETECT_DONE, PLAY_AND_DETECT_DONE_RECOGNIZING, play_and_detect_input_callback(), switch_input_args_t::read_frame_callback, play_and_detect_speech_state_t::result, switch_channel_get_name(), switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_var_true(), switch_core_session_get_channel(), SWITCH_FALSE, switch_ivr_detect_speech(), switch_ivr_detect_speech_start_input_timers(), switch_ivr_dmachine_last_ping(), switch_ivr_pause_detect_speech(), switch_ivr_play_file(), switch_ivr_sleep(), switch_ivr_stop_detect_speech(), SWITCH_LOG_INFO, switch_log_printf(), SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, and switch_input_args_t::user_data.

Referenced by CoreSession::playAndDetectSpeech().

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        int recognizing = 0;
        switch_input_args_t myargs = { 0 };
        play_and_detect_speech_state_t state = { 0, "", NULL };
        switch_channel_t *channel = switch_core_session_get_channel(session);

        arg_recursion_check_start(args);

        if (result == NULL) {
                goto done;
        }

        if (!input_timeout) input_timeout = 5000;

        /* start speech detection */
        if ((status = switch_ivr_detect_speech(session, mod_name, grammar, "", NULL, NULL)) != SWITCH_STATUS_SUCCESS) {
                /* map SWITCH_STATUS_FALSE to SWITCH_STATUS_GENERR to indicate grammar load failed
                SWITCH_STATUS_NOT_INITALIZED will be passed back to indicate ASR resource problem */
                if (status == SWITCH_STATUS_FALSE) {
                        status = SWITCH_STATUS_GENERR;
                }
                goto done;
        }
        recognizing = 1;

        /* play the prompt, looking for detection result */

        if (args) {
                state.original_args = args;
                myargs.dmachine = args->dmachine;
                myargs.read_frame_callback = args->read_frame_callback;
                myargs.user_data = args->user_data;
        }

        myargs.input_callback = play_and_detect_input_callback;
        myargs.buf = &state;
        myargs.buflen = sizeof(state);

        status = switch_ivr_play_file(session, NULL, file, &myargs);

        if (args && args->dmachine && switch_ivr_dmachine_last_ping(args->dmachine) != SWITCH_STATUS_SUCCESS) {
                state.done |= PLAY_AND_DETECT_DONE;
                goto done;
        }

        if (status != SWITCH_STATUS_BREAK && status != SWITCH_STATUS_SUCCESS) {
                status = SWITCH_STATUS_FALSE;
                goto done;
        }

        /* wait for result if not done */
        if (!state.done) {
                switch_ivr_detect_speech_start_input_timers(session);
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "(%s) WAITING FOR RESULT\n", switch_channel_get_name(channel));
                while (!state.done && switch_channel_ready(channel)) {
                        status = switch_ivr_sleep(session, input_timeout, SWITCH_FALSE, &myargs);

                        if (args && args->dmachine && switch_ivr_dmachine_last_ping(args->dmachine) != SWITCH_STATUS_SUCCESS) {
                                state.done |= PLAY_AND_DETECT_DONE;
                                goto done;
                        }

                        if (status != SWITCH_STATUS_BREAK && status != SWITCH_STATUS_SUCCESS) {
                                status = SWITCH_STATUS_FALSE;
                                goto done;
                        }
                }
        }

done:
        if (recognizing && !(state.done & PLAY_AND_DETECT_DONE_RECOGNIZING)) {
                switch_ivr_pause_detect_speech(session);
        }
        if (recognizing && switch_channel_var_true(channel, "play_and_detect_speech_close_asr")) {
                switch_ivr_stop_detect_speech(session);
        }

        if (state.done) {
                status = SWITCH_STATUS_SUCCESS;
        }
        if (result) {
                *result = state.result;
        }

        arg_recursion_check_stop(args);

        return status;
}

switch_ivr_play_file()

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

Parameters

session	the session to play the file too
fh	file handle to use (NULL for builtin one)
file	the path to the file
args	arguements to pass for callbacks etc

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 1244 of file switch_ivr_play_say.c.

References switch_codec_implementation::actual_samples_per_second, arg_recursion_check_start, arg_recursion_check_stop, switch_file_handle::audio_buffer, switch_directories::base_dir, switch_input_args_t::buf, switch_frame::buflen, buflen, switch_input_args_t::buflen, CF_BREAK, CF_HOLD, CF_VIDEO, switch_frame::channels, switch_file_handle::channels, switch_frame::codec, cur, switch_file_handle::cur_channels, switch_frame::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, FILE_BLOCKSIZE, FILE_BUFSIZE, FILE_STARTSAMPLES, switch_codec_implementation::iananame, switch_codec::implementation, switch_input_args_t::input_callback, memset(), switch_codec_implementation::microseconds_per_packet, switch_file_handle::native_rate, switch_codec_implementation::number_of_channels, switch_file_handle::offset_pos, switch_file_handle::params, pool, switch_file_handle::prebuf, switch_file_handle::prefix, switch_frame::rate, switch_input_args_t::read_frame_callback, switch_timer::samplecount, switch_file_handle::samplerate, switch_frame::samples, switch_file_handle::samples, switch_file_handle::samples_in, switch_codec_implementation::samples_per_packet, switch_codec_implementation::samples_per_second, switch_file_handle::sp_audio_buffer, switch_file_handle::speed, switch_assert, 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_buffer_create_dynamic(), switch_buffer_destroy(), switch_buffer_inuse(), switch_buffer_read(), switch_buffer_write(), switch_buffer_zero(), switch_change_sln_volume(), switch_change_sln_volume_granular(), switch_channel_audio_sync, switch_channel_clear_flag(), switch_channel_dequeue_dtmf(), switch_channel_event_set_data(), switch_channel_get_name(), switch_channel_get_variable, switch_channel_has_dtmf(), switch_channel_media_ready, switch_channel_pre_answer, switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_private(), 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_codec_ready(), switch_core_file_close(), switch_core_file_get_string(), switch_core_file_has_video(), switch_core_file_open, switch_core_file_read(), switch_core_file_seek(), switch_core_media_set_video_file(), switch_core_service_session, switch_core_session_dequeue_event(), switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_codec(), switch_core_session_get_read_impl(), switch_core_session_io_rwunlock(), switch_core_session_io_write_lock(), switch_core_session_read_frame(), switch_core_session_reset(), switch_core_session_sprintf(), switch_core_session_strdup, switch_core_session_write_frame(), switch_core_thread_session_end(), switch_core_timer_destroy(), switch_core_timer_init(), switch_core_timer_next(), switch_core_timer_sync(), switch_event_add_header_string(), switch_event_create, switch_event_destroy(), switch_event_fire, switch_event_merge(), SWITCH_EVENT_PLAYBACK_START, SWITCH_EVENT_PLAYBACK_STOP, SWITCH_FALSE, SWITCH_FILE_BREAK_ON_CHANGE, SWITCH_FILE_CALLBACK, SWITCH_FILE_DATA_SHORT, SWITCH_FILE_FLAG_READ, SWITCH_FILE_FLAG_VIDEO, SWITCH_FILE_NATIVE, SWITCH_FILE_OPEN, SWITCH_FILE_PAUSE, SWITCH_FILE_SEEK, switch_find_end_paren(), SWITCH_GLOBAL_dirs, SWITCH_INPUT_TYPE_DTMF, SWITCH_INPUT_TYPE_EVENT, SWITCH_IO_FLAG_NONE, SWITCH_IO_FLAG_SINGLE_READ, switch_is_file_path(), switch_ivr_dmachine_feed(), switch_ivr_dmachine_is_parsing(), switch_ivr_dmachine_ping(), switch_ivr_parse_all_events(), switch_ivr_parse_all_messages(), switch_ivr_phrase_macro, switch_ivr_sleep(), switch_ivr_speak_text(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_PATH_SEPARATOR, SWITCH_READ_ACCEPTABLE, SWITCH_RW_WRITE, switch_safe_free, switch_separate_string(), switch_set_flag_locked, SWITCH_STACK_BOTTOM, SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_MORE_DATA, SWITCH_STATUS_NOTFOUND, SWITCH_STATUS_SUCCESS, SWITCH_STATUS_TIMEOUT, switch_str_nil, switch_swap_linear(), switch_test_flag, SWITCH_TRUE, switch_true(), SWITCH_URL_SEPARATOR, switch_yield, switch_zmalloc, switch_frame::timestamp, switch_input_args_t::user_data, switch_file_handle::vol, switch_file_handle::volgranular, and zstr.

Referenced by collect_thread_run(), enterprise_originate_ringback_thread(), fs_ivr_play_file(), fs_ivr_play_file2(), play_and_collect(), CoreSession::streamFile(), switch_ivr_menu_execute(), switch_ivr_phrase_macro_event(), switch_ivr_play_and_collect_input(), switch_ivr_play_and_detect_speech(), switch_ivr_read(), switch_ivr_soft_hold(), and switch_play_and_get_digits().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        int16_t *abuf = NULL;
        switch_dtmf_t dtmf = { 0 };
        uint32_t interval = 0, samples = 0, framelen, sample_start = 0, channels = 1;
        uint32_t ilen = 0;
        switch_size_t olen = 0, llen = 0;
        switch_frame_t write_frame = { 0 };
        switch_timer_t timer = { 0 };
        switch_codec_t codec = { 0 };
        switch_memory_pool_t *pool = switch_core_session_get_pool(session);
        char *codec_name;
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        switch_file_handle_t lfh;
        const char *p;
        //char *title = "", *copyright = "", *software = "", *artist = "", *comment = "", *date = "";
        char *ext;
        char *backup_file = NULL;
        const char *backup_ext;
        const char *prefix;
        const char *timer_name;
        const char *prebuf;
        const char *alt = NULL;
        const char *sleep_val;
        const char *play_delimiter_val;
        char play_delimiter = 0;
        int sleep_val_i = 250;
        int eof = 0;
        switch_size_t bread = 0;
        switch_codec_implementation_t read_impl = { 0 };
        char *file_dup;
        char *argv[128] = { 0 };
        int argc;
        int cur;
        int done = 0;
        int timeout_samples = 0;
        switch_bool_t timeout_as_success = SWITCH_FALSE;
        const char *var;
        int more_data = 0;
        switch_event_t *event;
        uint32_t test_native = 0, last_native = 0;
        uint32_t buflen = 0;
        int flags;
        int cumulative = 0;
        int last_speed = -1;

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

        switch_core_session_get_read_impl(session, &read_impl);

        if ((var = switch_channel_get_variable(channel, "playback_timeout_sec_cumulative"))) {
                int tmp = atoi(var);
                if (tmp > 1) {
                        timeout_samples = read_impl.actual_samples_per_second * tmp;
                        cumulative = 1;
                }

        } else if ((var = switch_channel_get_variable(channel, "playback_timeout_sec"))) {
                int tmp = atoi(var);
                if (tmp > 1) {
                        timeout_samples = read_impl.actual_samples_per_second * tmp;
                }
        }

        if ((var = switch_channel_get_variable(channel, "playback_timeout_as_success"))) {
                if (switch_true(var)) {
                        timeout_as_success = SWITCH_TRUE;
                }
        }
        if ((play_delimiter_val = switch_channel_get_variable(channel, "playback_delimiter"))) {
                play_delimiter = *play_delimiter_val;

                if ((sleep_val = switch_channel_get_variable(channel, "playback_sleep_val"))) {
                        int tmp = atoi(sleep_val);
                        if (tmp >= 0) {
                                sleep_val_i = tmp;
                        }
                }
        }

        prefix = switch_channel_get_variable(channel, "sound_prefix");
        timer_name = switch_channel_get_variable(channel, "timer_name");

        if (zstr(file) || !switch_channel_media_ready(channel)) {
                return SWITCH_STATUS_FALSE;
        }

        arg_recursion_check_start(args);

        if (play_delimiter) {
                file_dup = switch_core_session_strdup(session, file);
                argc = switch_separate_string(file_dup, play_delimiter, argv, (sizeof(argv) / sizeof(argv[0])));
        } else {
                argc = 1;
                argv[0] = (char *) file;
        }

        if (!fh) {
                fh = &lfh;
                memset(fh, 0, sizeof(lfh));
        }

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




        for (cur = 0; switch_channel_ready(channel) && !done && cur < argc; cur++) {
                file = argv[cur];
                eof = 0;

                if (cur) {
                        fh->samples = sample_start = 0;
                        if (sleep_val_i) {
                                status = switch_ivr_sleep(session, sleep_val_i, SWITCH_FALSE, args);
                                                                if(status != SWITCH_STATUS_SUCCESS) {
                                                                                break;
                                                                }
                        }
                }

                status = SWITCH_STATUS_SUCCESS;

                if (strchr(file, ':')) {
                        char *dup;

                        if (!strncasecmp(file, "phrase:", 7)) {
                                char *arg = NULL;
                                const char *lang = switch_channel_get_variable(channel, "language");
                                alt = file + 7;
                                dup = switch_core_session_strdup(session, alt);

                                if (dup) {
                                        if ((arg = strchr(dup, ':'))) {
                                                *arg++ = '\0';
                                        }
                                        if ((status = switch_ivr_phrase_macro(session, dup, arg, lang, args)) != SWITCH_STATUS_SUCCESS) {
                                                break;
                                        }
                                        continue;
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid Args\n");
                                        continue;
                                }
                        } else if (!strncasecmp(file, "say:", 4)) {
                                const char *engine = NULL, *voice = NULL, *text = NULL;

                                alt = file + 4;
                                text = alt;
                                engine = switch_channel_get_variable(channel, "tts_engine");
                                voice = switch_channel_get_variable(channel, "tts_voice");

                                if (engine && text) {
                                        if ((status = switch_ivr_speak_text(session, engine, voice, (char *)text, args)) != SWITCH_STATUS_SUCCESS) {
                                                break;
                                        }
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid Args\n");
                                }

                                continue;
                        }

                }

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

                if (!strstr(file, SWITCH_URL_SEPARATOR)) {
                        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 {

                                if (!(backup_ext = switch_channel_get_variable(channel, "native_backup_extension"))) {
                                        backup_ext = "wav";
                                }

                                ext = read_impl.iananame;
                                backup_file = switch_core_session_sprintf(session, "%s.%s", file, backup_ext);
                                file = switch_core_session_sprintf(session, "%s.%s", file, ext);
                        }
                }

                if ((prebuf = switch_channel_get_variable(channel, "stream_prebuffer"))) {
                        int maybe = atoi(prebuf);
                        if (maybe > 0) {
                                fh->prebuf = maybe;
                        }
                }


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

                flags = SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT;

                if (switch_channel_test_flag(channel, CF_VIDEO)) {
                        flags |= SWITCH_FILE_FLAG_VIDEO;
                        //switch_channel_set_flag_recursive(channel, CF_VIDEO_DECODED_READ);
                }


                for(;;) {
                        if (switch_core_file_open(fh,
                                                                          file,
                                                                          read_impl.number_of_channels,
                                                                          read_impl.actual_samples_per_second, flags, NULL) == SWITCH_STATUS_SUCCESS) {
                                break;
                        }

                        if (backup_file) {
                                file = backup_file;
                                backup_file = NULL;
                        } else {
                                break;
                        }
                }

                if (!switch_test_flag(fh, SWITCH_FILE_OPEN)) {
                        switch_core_session_reset(session, SWITCH_TRUE, SWITCH_FALSE);
                        status = SWITCH_STATUS_NOTFOUND;
                        continue;
                }

                switch_channel_audio_sync(channel);
                switch_core_session_io_write_lock(session);
                switch_channel_set_private(channel, "__fh", fh);
                switch_core_session_io_rwunlock(session);

                if (switch_core_file_has_video(fh, SWITCH_TRUE)) {
                        switch_core_media_set_video_file(session, fh, SWITCH_RW_WRITE);
                }

                if (!abuf) {
                        write_frame.buflen = FILE_STARTSAMPLES * sizeof(*abuf) * fh->channels;
                        switch_zmalloc(abuf, write_frame.buflen);
                        write_frame.data = abuf;
                }

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

                if (switch_core_file_get_string(fh, SWITCH_AUDIO_COL_STR_TITLE, &p) == SWITCH_STATUS_SUCCESS) {
                        //title = switch_core_session_strdup(session, p);
                        switch_channel_set_variable(channel, "RECORD_TITLE", p);
                }

                if (switch_core_file_get_string(fh, SWITCH_AUDIO_COL_STR_COPYRIGHT, &p) == SWITCH_STATUS_SUCCESS) {
                        //copyright = switch_core_session_strdup(session, p);
                        switch_channel_set_variable(channel, "RECORD_COPYRIGHT", p);
                }

                if (switch_core_file_get_string(fh, SWITCH_AUDIO_COL_STR_SOFTWARE, &p) == SWITCH_STATUS_SUCCESS) {
                        //software = switch_core_session_strdup(session, p);
                        switch_channel_set_variable(channel, "RECORD_SOFTWARE", p);
                }

                if (switch_core_file_get_string(fh, SWITCH_AUDIO_COL_STR_ARTIST, &p) == SWITCH_STATUS_SUCCESS) {
                        //artist = switch_core_session_strdup(session, p);
                        switch_channel_set_variable(channel, "RECORD_ARTIST", p);
                }

                if (switch_core_file_get_string(fh, SWITCH_AUDIO_COL_STR_COMMENT, &p) == SWITCH_STATUS_SUCCESS) {
                        //comment = switch_core_session_strdup(session, p);
                        switch_channel_set_variable(channel, "RECORD_COMMENT", p);
                }

                if (switch_core_file_get_string(fh, SWITCH_AUDIO_COL_STR_DATE, &p) == SWITCH_STATUS_SUCCESS) {
                        //date = switch_core_session_strdup(session, p);
                        switch_channel_set_variable(channel, "RECORD_DATE", p);
                }

                interval = read_impl.microseconds_per_packet / 1000;

                codec_name = "L16";

                if (!switch_core_codec_ready((&codec))) {
                        if (switch_core_codec_init(&codec,
                                                                           codec_name,
                                                                           NULL,
                                                                           NULL,
                                                                           fh->samplerate,
                                                                           interval, read_impl.number_of_channels,
                                                                           SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL, pool) == SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session),
                                                                  SWITCH_LOG_DEBUG, "Codec Activated %s@%uhz %u channels %dms\n",
                                                                  codec_name, fh->samplerate, read_impl.number_of_channels, interval);


                        } else {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                  "Raw Codec Activation Failed %s@%uhz %u channels %dms\n", codec_name,
                                                                  fh->samplerate, read_impl.number_of_channels, interval);
                                switch_core_session_io_write_lock(session);
                                switch_channel_set_private(channel, "__fh", NULL);
                                switch_core_session_io_rwunlock(session);

                                switch_core_media_set_video_file(session, NULL, SWITCH_RW_WRITE);

                                switch_core_file_close(fh);

                                switch_core_session_reset(session, SWITCH_TRUE, SWITCH_FALSE);
                                status = SWITCH_STATUS_GENERR;
                                continue;
                        }
                }

                test_native = switch_test_flag(fh, SWITCH_FILE_NATIVE);

                if (test_native) {
                        write_frame.codec = switch_core_session_get_read_codec(session);
                        samples = read_impl.samples_per_packet;
                        framelen = read_impl.encoded_bytes_per_packet;
                        channels = read_impl.number_of_channels;
                        if (framelen == 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_io_write_lock(session);
                                switch_channel_set_private(channel, "__fh", NULL);
                                switch_core_session_io_rwunlock(session);

                                switch_core_media_set_video_file(session, NULL, SWITCH_RW_WRITE);
                                switch_core_file_close(fh);

                                switch_core_session_reset(session, SWITCH_TRUE, SWITCH_FALSE);
                                status = SWITCH_STATUS_GENERR;
                                continue;

                        }
                } else {
                        write_frame.codec = &codec;
                        samples = codec.implementation->samples_per_packet;
                        framelen = codec.implementation->decoded_bytes_per_packet;
                        channels = codec.implementation->number_of_channels;
                }

                last_native = test_native;

                if (timer_name && !timer.samplecount) {
                        uint32_t len;

                        len = samples * 2 * channels;
                        if (switch_core_timer_init(&timer, timer_name, interval, samples, pool) != SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Setup timer failed!\n");
                                switch_core_codec_destroy(&codec);
                                switch_core_session_io_write_lock(session);
                                switch_channel_set_private(channel, "__fh", NULL);
                                switch_core_session_io_rwunlock(session);

                                switch_core_media_set_video_file(session, NULL, SWITCH_RW_WRITE);

                                switch_core_file_close(fh);
                                switch_core_session_reset(session, SWITCH_TRUE, SWITCH_FALSE);
                                status = SWITCH_STATUS_GENERR;
                                continue;
                        }
                        switch_core_timer_sync(&timer); // Sync timer
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                          "Setup timer success %u bytes per %d ms! %d ch\n", len, interval, codec.implementation->number_of_channels);
                }
                write_frame.rate = fh->samplerate;
                write_frame.channels = fh->channels;
                if (timer_name) {
                        /* start a thread to absorb incoming audio */
                        switch_core_service_session(session);
                }

                ilen = samples * channels;

                if (switch_event_create(&event, SWITCH_EVENT_PLAYBACK_START) == SWITCH_STATUS_SUCCESS) {
                        switch_channel_event_set_data(channel, event);
                        if (!strncasecmp(file, "local_stream:", 13)) {
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Playback-File-Type", "local_stream");
                        }
                        if (!strncasecmp(file, "tone_stream:", 12)) {
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Playback-File-Type", "tone_stream");
                        }
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Playback-File-Path", file);
                        if (fh->params) {
                                switch_event_merge(event, fh->params);
                        }
                        switch_event_fire(&event);
                }

                if (!fh->audio_buffer) {
                        switch_buffer_create_dynamic(&fh->audio_buffer, FILE_BLOCKSIZE, FILE_BUFSIZE, 0);
                        switch_assert(fh->audio_buffer);
                }

                for (;;) {
                        int do_speed = 1;
                        int f;

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

                        if ((f = switch_channel_test_flag(channel, CF_BREAK))) {
                                switch_channel_clear_flag(channel, CF_BREAK);
                                if (f == 2) {
                                        done = 1;
                                }
                                status = SWITCH_STATUS_BREAK;
                                break;
                        }

                        switch_ivr_parse_all_events(session);

                        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)) {
                                        switch_channel_dequeue_dtmf(channel, &dtmf);

                                        if (!args->input_callback && !args->buf && !args->dmachine) {
                                                status = SWITCH_STATUS_BREAK;
                                                done = 1;
                                                break;
                                        }


                                        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;

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

                                                switch_event_destroy(&event);
                                        }
                                }

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

                        buflen = FILE_STARTSAMPLES * sizeof(*abuf) * (fh->cur_channels > 0 ? fh->cur_channels : fh->channels); 

                        if (buflen > write_frame.buflen) {
                                abuf = realloc(abuf, buflen);
                                write_frame.data = abuf;
                                write_frame.buflen = buflen;
                        }

                        if (switch_test_flag(fh, SWITCH_FILE_PAUSE)) {
                                if (framelen > FILE_STARTSAMPLES) {
                                        framelen = FILE_STARTSAMPLES;
                                }
                                memset(abuf, 255, framelen);
                                olen = ilen;
                                do_speed = 0;
                        } else if (fh->sp_audio_buffer && (eof || (switch_buffer_inuse(fh->sp_audio_buffer) > (switch_size_t) (framelen)))) {
                                if (!(bread = switch_buffer_read(fh->sp_audio_buffer, abuf, framelen))) {
                                        if (eof) {
                                                break;
                                        } else {
                                                continue;
                                        }
                                }

                                if (bread < framelen) {
                                        memset(abuf + bread, 255, framelen - bread);
                                }

                                olen = switch_test_flag(fh, SWITCH_FILE_NATIVE) ? framelen : ilen;
                                do_speed = 0;
                        } else if (fh->audio_buffer && (eof || (switch_buffer_inuse(fh->audio_buffer) > (switch_size_t) (framelen)))) {
                                if (!(bread = switch_buffer_read(fh->audio_buffer, abuf, framelen))) {
                                        if (eof) {
                                                break;
                                        } else {
                                                continue;
                                        }
                                }

                                fh->offset_pos += (uint32_t)(switch_test_flag(fh, SWITCH_FILE_NATIVE) ? bread : bread / 2);

                                if (bread < framelen) {
                                        memset(abuf + bread, 255, framelen - bread);
                                }

                                olen = switch_test_flag(fh, SWITCH_FILE_NATIVE) ? framelen : ilen;
                        } else {
                                switch_status_t rstatus;

                                if (eof) {
                                        break;
                                }
                                olen = FILE_STARTSAMPLES;
                                if (!switch_test_flag(fh, SWITCH_FILE_NATIVE)) {
                                        olen /= 2;
                                }
                                switch_set_flag_locked(fh, SWITCH_FILE_BREAK_ON_CHANGE);

                                if ((rstatus = switch_core_file_read(fh, abuf, &olen)) == SWITCH_STATUS_BREAK) {
                                        continue;
                                }

                                if (rstatus != SWITCH_STATUS_SUCCESS) {
                                        eof++;
                                        continue;
                                }

                                test_native = switch_test_flag(fh, SWITCH_FILE_NATIVE);

                                if (test_native != last_native) {
                                        if (test_native) {
                                                write_frame.codec = switch_core_session_get_read_codec(session);
                                                framelen = read_impl.encoded_bytes_per_packet;
                                                if (framelen == 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));
                                                        eof++;
                                                        continue;
                                                }
                                        } else {
                                                write_frame.codec = &codec;
                                                framelen = codec.implementation->decoded_bytes_per_packet;
                                        }
                                        switch_buffer_zero(fh->audio_buffer);
                                }

                                last_native = test_native;

                                switch_buffer_write(fh->audio_buffer, abuf, switch_test_flag(fh, SWITCH_FILE_NATIVE) ? olen : olen * 2 * fh->channels);
                                olen = switch_buffer_read(fh->audio_buffer, abuf, framelen);
                                fh->offset_pos += (uint32_t)(olen / 2);

                                if (!switch_test_flag(fh, SWITCH_FILE_NATIVE)) {
                                        olen /= 2;
                                }

                        }

                        if (done || olen <= 0) {
                                break;
                        }

                        if (!switch_test_flag(fh, SWITCH_FILE_NATIVE)) {
                                if (fh->speed > 2) {
                                        fh->speed = 2;
                                } else if (fh->speed < -2) {
                                        fh->speed = -2;
                                }
                        }

                        if (!switch_test_flag(fh, SWITCH_FILE_NATIVE) && fh->audio_buffer && last_speed > -1 && last_speed != fh->speed) {
                                switch_buffer_zero(fh->sp_audio_buffer);
                        }

                        if (switch_test_flag(fh, SWITCH_FILE_SEEK)) {
                                /* file position has changed flush the buffer */
                                switch_buffer_zero(fh->audio_buffer);
                                switch_clear_flag_locked(fh, SWITCH_FILE_SEEK);
                        }


                        if (!switch_test_flag(fh, SWITCH_FILE_NATIVE) && fh->speed && do_speed) {
                                float factor = 0.25f * abs(fh->speed);
                                switch_size_t newlen, supplement, step;
                                short *bp = write_frame.data;
                                switch_size_t wrote = 0;

                                supplement = (int) (factor * olen);
                                if (!supplement) {
                                        supplement = 1;
                                }
                                newlen = (fh->speed > 0) ? olen - supplement : olen + supplement;

                                step = (fh->speed > 0) ? (newlen / supplement) : (olen / supplement);

                                if (!fh->sp_audio_buffer) {
                                        switch_buffer_create_dynamic(&fh->sp_audio_buffer, 1024, 1024, 0);
                                }

                                while ((wrote + step) < newlen) {
                                        switch_buffer_write(fh->sp_audio_buffer, bp, step * 2);
                                        wrote += step;
                                        bp += step;
                                        if (fh->speed > 0) {
                                                bp++;
                                        } else {
                                                float f;
                                                short s;
                                                f = (float) (*bp + *(bp + 1) + *(bp - 1));
                                                f /= 3;
                                                s = (short) f;
                                                switch_buffer_write(fh->sp_audio_buffer, &s, 2);
                                                wrote++;
                                        }
                                }
                                if (wrote < newlen) {
                                        switch_size_t r = newlen - wrote;
                                        switch_buffer_write(fh->sp_audio_buffer, bp, r * 2);
                                }
                                last_speed = fh->speed;
                                continue;
                        }

                        if (olen < llen) {
                                uint8_t *dp = (uint8_t *) write_frame.data;
                                memset(dp + (int) olen, 255, (int) (llen - olen));
                                olen = llen;
                        }

                        if (!more_data) {
                                if (timer_name) {
                                        if (switch_core_timer_next(&timer) != SWITCH_STATUS_SUCCESS) {
                                                break;
                                        }
                                } else {                        /* time off the channel (if you must) */
                                        switch_frame_t *read_frame;
                                        switch_status_t tstatus;

                                        while (switch_channel_ready(channel) && switch_channel_test_flag(channel, CF_HOLD)) {
                                                switch_ivr_parse_all_messages(session);
                                                switch_yield(10000);
                                        }

                                        tstatus = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_SINGLE_READ, 0);


                                        if (!SWITCH_READ_ACCEPTABLE(tstatus)) {
                                                break;
                                        }

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

                                        if (args && (args->read_frame_callback)) {
                                                int ok = 1;
                                                switch_set_flag_locked(fh, SWITCH_FILE_CALLBACK);
                                                if ((status = args->read_frame_callback(session, read_frame, args->user_data)) != SWITCH_STATUS_SUCCESS) {
                                                        ok = 0;
                                                }
                                                switch_clear_flag_locked(fh, SWITCH_FILE_CALLBACK);
                                                if (!ok) {
                                                        break;
                                                }
                                        }
                                }
                        }

                        more_data = 0;
                        write_frame.samples = (uint32_t) olen;

                        if (switch_test_flag(fh, SWITCH_FILE_NATIVE)) {
                                write_frame.datalen = (uint32_t) olen;
                        } else {
                                write_frame.datalen = write_frame.samples * 2;
                        }

                        llen = olen;

                        if (timer_name) {
                                write_frame.timestamp = timer.samplecount;
                        }
#ifndef WIN32
#if SWITCH_BYTE_ORDER == __BIG_ENDIAN
                        if (!switch_test_flag(fh, SWITCH_FILE_NATIVE) && l16) {
                                switch_swap_linear(write_frame.data, (int) write_frame.datalen / 2);
                        }
#endif
#endif
                        if (!switch_test_flag(fh, SWITCH_FILE_NATIVE)) {
                                if (fh->volgranular) {
                                        switch_change_sln_volume_granular(write_frame.data, write_frame.datalen / 2, fh->volgranular);
                                } else if (fh->vol) { /* deprecated 2022-Q1 */
                                        switch_change_sln_volume(write_frame.data, write_frame.datalen / 2, fh->vol);
                                }
                        }

                        /* write silence while dmachine is in reading state */
                        if (args && args->dmachine && switch_ivr_dmachine_is_parsing(args->dmachine)) {
                                memset(write_frame.data, 0, write_frame.datalen);
                        }

                        status = switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0);

                        if (timeout_samples) {
                                timeout_samples -= write_frame.samples;
                                if (timeout_samples <= 0) {
                                        timeout_samples = 0;
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "timeout reached playing file\n");
                                        if (timeout_as_success) {
                                                status = SWITCH_STATUS_SUCCESS;
                                        } else {
                                                status = SWITCH_STATUS_TIMEOUT;
                                        }
                                        done = 1;
                                        break;
                                }
                        }


                        if (status == SWITCH_STATUS_MORE_DATA) {
                                status = SWITCH_STATUS_SUCCESS;
                                more_data = 1;
                                continue;
                        } else if (status != SWITCH_STATUS_SUCCESS) {
                                done = 1;
                                break;
                        }

                        if (done) {
                                break;
                        }
                }

                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "done playing file %s\n", file);
                switch_channel_set_variable_printf(channel, "playback_last_offset_pos", "%d", fh->offset_pos);

                if (read_impl.samples_per_second && fh->native_rate >= 1000) {
                        switch_channel_set_variable_printf(channel, "playback_seconds", "%d", fh->samples_in / fh->native_rate);
                        switch_channel_set_variable_printf(channel, "playback_ms", "%d", fh->samples_in / (fh->native_rate / 1000));
                }

                switch_channel_set_variable_printf(channel, "playback_samples", "%d", fh->samples_in);

                if (switch_event_create(&event, SWITCH_EVENT_PLAYBACK_STOP) == SWITCH_STATUS_SUCCESS) {
                        switch_channel_event_set_data(channel, event);
                        if (!strncasecmp(file, "local_stream:", 13)) {
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Playback-File-Type", "local_stream");
                        }
                        if (!strncasecmp(file, "tone_stream:", 12)) {
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Playback-File-Type", "tone_stream");
                        }
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Playback-File-Path", file);
                        if (status == SWITCH_STATUS_BREAK) {
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Playback-Status", "break");
                        } else {
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Playback-Status", "done");
                        }
                        if (fh->params) {
                                switch_event_merge(event, fh->params);
                        }
                        switch_event_fire(&event);
                }

                switch_core_session_io_write_lock(session);
                switch_channel_set_private(channel, "__fh", NULL);
                switch_core_session_io_rwunlock(session);

                switch_core_media_set_video_file(session, NULL, SWITCH_RW_WRITE);
                switch_core_file_close(fh);

                if (fh->audio_buffer) {
                        switch_buffer_destroy(&fh->audio_buffer);
                }

                if (fh->sp_audio_buffer) {
                        switch_buffer_destroy(&fh->sp_audio_buffer);
                }
        }

        if (switch_core_codec_ready((&codec))) {
                switch_core_codec_destroy(&codec);
        }

        if (timer.samplecount) {
                /* End the audio absorbing thread */
                switch_core_thread_session_end(session);
                switch_core_timer_destroy(&timer);
        }

        switch_safe_free(abuf);

        switch_core_session_reset(session, SWITCH_FALSE, SWITCH_FALSE);

        arg_recursion_check_stop(args);

        if (timeout_samples && cumulative) {
                switch_channel_set_variable_printf(channel, "playback_timeout_sec_cumulative", "%d", timeout_samples / read_impl.actual_samples_per_second);
        }


        return status;
}

switch_ivr_process_indications()

switch_status_t switch_ivr_process_indications	(	switch_core_session_t *	session,
		switch_core_session_message_t *	message
	)

Definition at line 813 of file switch_ivr.c.

References switch_core_session_message::message_id, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER, switch_channel_answer, switch_channel_hangup, switch_channel_pre_answer, switch_channel_ring_ready, switch_core_session_get_channel(), switch_core_session_receive_message, SWITCH_MESSAGE_INDICATE_ANSWER, SWITCH_MESSAGE_INDICATE_PROGRESS, SWITCH_MESSAGE_INDICATE_RESPOND, SWITCH_MESSAGE_INDICATE_RINGING, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_session_flush_message(), and switch_ivr_parse_all_messages().

{
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        switch_channel_t *channel = switch_core_session_get_channel(session);

                switch(message->message_id) {
                case SWITCH_MESSAGE_INDICATE_ANSWER:
                        if (switch_channel_answer(channel) != SWITCH_STATUS_SUCCESS) {
                                switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                        }
                        break;
                case SWITCH_MESSAGE_INDICATE_PROGRESS:
                        if (switch_channel_pre_answer(channel) != SWITCH_STATUS_SUCCESS) {
                                switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                        }
                        break;
                case SWITCH_MESSAGE_INDICATE_RINGING:
                        if (switch_channel_ring_ready(channel) != SWITCH_STATUS_SUCCESS) {
                                switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                        }
                        break;
                case SWITCH_MESSAGE_INDICATE_RESPOND:
                        switch_core_session_receive_message(session, message);
                        status = SWITCH_STATUS_SUCCESS;
                        break;

                default:
                status = SWITCH_STATUS_FALSE;
                        break;
                }

        return status;
}

switch_ivr_record_file()

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

record a file from the session to a file

Parameters

session	the session to record from
fh	file handle to use
file	the path to the file
args	arguements to pass for callbacks etc
limit	max limit to record for (0 for infinite)

Returns

SWITCH_STATUS_SUCCESS if all is well

Referenced by fs_switch_ivr_record_file(), and CoreSession::recordFile().

switch_ivr_record_file_event()

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

record a file from the session to a file

Parameters

session	the session to record from
fh	file handle to use
file	the path to the file
args	arguements to pass for callbacks etc
limit	max limit to record for (0 for infinite)
vars	vars to add to RECORD_START and RECORD_STOP automatically prefixed with Recording-Variable-

Returns

SWITCH_STATUS_SUCCESS if all is well

switch_ivr_record_session()

switch_status_t switch_ivr_record_session	(	switch_core_session_t *	session,
		const char *	file,
		uint32_t	limit,
		switch_file_handle_t *	fh
	)

Record a session to disk.

Parameters

session	the session to record
file	the path to the file
limit	stop recording after this amount of time (in ms, 0 = never stop)
fh	file handle to use (NULL for builtin one)

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 3355 of file switch_ivr_async.c.

References switch_ivr_record_session_event().

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

switch_ivr_record_session_event()

switch_status_t switch_ivr_record_session_event	(	switch_core_session_t *	session,
		const char *	file,
		uint32_t	limit,
		switch_file_handle_t *	fh,
		switch_event_t *	variables
	)

Definition at line 2927 of file switch_ivr_async.c.

References switch_codec_implementation::actual_samples_per_second, switch_directories::base_dir, record_helper::bug, CF_VIDEO, switch_file_handle::channels, record_helper::completion_cause, switch_codec_implementation::decoded_bytes_per_packet, record_helper::fh, record_helper::file, record_helper::final_timeout_ms, switch_core_session_message::from, get_recording_var(), record_helper::hangup_on_error, record_helper::helper_pool, switch_codec_implementation::iananame, record_helper::in_fh, record_helper::initial_timeout_ms, switch_core_session_message::message_id, record_helper::min_sec, record_helper::native, switch_codec_implementation::number_of_channels, record_helper::out_fh, record_helper::packet_len, switch_file_handle::params, path, switch_file_handle::pre_buffer_datalen, record_helper::read_impl, record_callback(), record_helper_create(), record_helper_destroy(), recording_var_true(), switch_file_handle::samplerate, set_completion_cause(), record_helper::silence_threshold, SMBF_ANSWER_REQ, SMBF_BRIDGE_REQ, SMBF_READ_PING, SMBF_READ_STREAM, SMBF_READ_VIDEO_PING, SMBF_READ_VIDEO_STREAM, SMBF_STEREO, SMBF_STEREO_SWAP, SMBF_TAP_NATIVE_READ, SMBF_TAP_NATIVE_WRITE, SMBF_WRITE_STREAM, SMBF_WRITE_VIDEO_STREAM, 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_get_private(), switch_channel_get_variable, switch_channel_hangup, switch_channel_media_up, switch_channel_pre_answer, switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_private(), switch_channel_set_variable, switch_channel_set_variable_printf(), switch_channel_test_flag(), switch_core_alloc, switch_core_file_close(), switch_core_file_handle_dup(), switch_core_file_has_video(), switch_core_file_open, switch_core_file_set_string(), switch_core_media_bug_add(), switch_core_media_bug_set_pre_buffer_framecount(), switch_core_session_get_channel(), switch_core_session_get_partner, switch_core_session_get_pool(), switch_core_session_get_read_codec(), switch_core_session_get_read_impl(), switch_core_session_receive_message, switch_core_session_reset(), switch_core_session_rwunlock(), switch_core_sprintf(), switch_core_strdup, SWITCH_DEFAULT_DIR_PERMS, SWITCH_DEFAULT_FILE_BUFFER_LEN, switch_dir_make_recursive(), switch_epoch_time_now(), switch_event_dup(), switch_event_get_header, SWITCH_FALSE, SWITCH_FILE_DATA_SHORT, SWITCH_FILE_FLAG_VIDEO, SWITCH_FILE_FLAG_WRITE, SWITCH_FILE_NATIVE, SWITCH_FILE_WRITE_APPEND, switch_find_end_paren(), SWITCH_GLOBAL_dirs, switch_goto_status, switch_is_file_path(), switch_is_valid_rate, switch_ivr_stop_record_session(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_MESSAGE_INDICATE_VIDEO_REFRESH_REQ, SWITCH_PATH_SEPARATOR, switch_set_flag, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_MEMERR, SWITCH_STATUS_SUCCESS, switch_str_nil, SWITCH_TRUE, switch_true(), SWITCH_URL_SEPARATOR, to, record_helper::variables, and zstr.

Referenced by switch_ivr_record_session().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        const char *p;
        const char *vval;
        switch_media_bug_t *bug;
        switch_status_t status;
        time_t to = 0;
        switch_media_bug_flag_t flags = SMBF_READ_STREAM | SMBF_WRITE_STREAM | SMBF_READ_PING;
        uint8_t channels;
        switch_codec_implementation_t read_impl = { 0 };
        struct record_helper *rh = NULL;
        int file_flags = SWITCH_FILE_FLAG_WRITE | SWITCH_FILE_DATA_SHORT;
        switch_bool_t hangup_on_error = SWITCH_FALSE;
        char *file_path = NULL;
        char *ext;
        char *in_file = NULL, *out_file = NULL;
        switch_fileperms_t fileperms = SWITCH_DEFAULT_DIR_PERMS;

        if ((p = get_recording_var(channel, vars, "RECORD_HANGUP_ON_ERROR"))) {
                hangup_on_error = switch_true(p);
        }

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

        if (!switch_channel_media_up(channel) || !switch_core_session_get_read_codec(session)) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Can not record session.  Media not enabled on channel\n");
                return SWITCH_STATUS_FALSE;
        }

        switch_core_session_get_read_impl(session, &read_impl);
        channels = read_impl.number_of_channels;

        if ((bug = switch_channel_get_private(channel, file))) {
                if (recording_var_true(channel, vars, "RECORD_TOGGLE_ON_REPEAT")) {
                        return switch_ivr_stop_record_session(session, file);
                }

                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Already recording [%s]\n", file);
                return SWITCH_STATUS_SUCCESS;
        }


        if (recording_var_true(channel, vars, "RECORD_CHECK_BRIDGE")) {
                switch_core_session_t *other_session;
                int exist = 0;
                switch_status_t rstatus = SWITCH_STATUS_SUCCESS;

                if (switch_core_session_get_partner(session, &other_session) == SWITCH_STATUS_SUCCESS) {
                        switch_channel_t *other_channel = switch_core_session_get_channel(other_session);
                        if ((bug = switch_channel_get_private(other_channel, file))) {
                                if (switch_true(switch_channel_get_variable(other_channel, "RECORD_TOGGLE_ON_REPEAT"))) {
                                        rstatus = switch_ivr_stop_record_session(other_session, file);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(other_session), SWITCH_LOG_WARNING, "Already recording [%s]\n", file);
                                }
                                exist = 1;
                        }
                        switch_core_session_rwunlock(other_session);
                }

                if (exist) {
                        return rstatus;
                }
        }

        if ((status = record_helper_create(&rh, session)) != SWITCH_STATUS_SUCCESS) {
                return status;
        }

        if (fh) {
                switch_file_handle_t *newfh;

                if ((status = switch_core_file_handle_dup(fh, &newfh, rh->helper_pool)) != SWITCH_STATUS_SUCCESS) {
                        switch_goto_status(status, err);
                }

                fh = newfh;
        } else {
                if (!(fh = switch_core_alloc(rh->helper_pool, sizeof(*fh)))) {
                        switch_goto_status(SWITCH_STATUS_MEMERR, err);
                }
        }

        if (recording_var_true(channel, vars, "RECORD_WRITE_ONLY")) {
                flags &= ~SMBF_READ_STREAM;
                flags |= SMBF_WRITE_STREAM;
        }

        if (recording_var_true(channel, vars, "RECORD_READ_ONLY")) {
                flags &= ~SMBF_WRITE_STREAM;
                flags |= SMBF_READ_STREAM;
        }

        if (channels == 1) { /* if leg is already stereo this feature is not available */
                if (recording_var_true(channel, vars, "RECORD_STEREO")) {
                        flags |= SMBF_STEREO;
                        flags &= ~SMBF_STEREO_SWAP;
                        channels = 2;
                }

                if (recording_var_true(channel, vars, "RECORD_STEREO_SWAP")) {
                        flags |= SMBF_STEREO;
                        flags |= SMBF_STEREO_SWAP;
                        channels = 2;
                }
        }

        if (recording_var_true(channel, vars, "RECORD_ANSWER_REQ")) {
                flags |= SMBF_ANSWER_REQ;
        }

        if (recording_var_true(channel, vars, "RECORD_BRIDGE_REQ")) {
                flags |= SMBF_BRIDGE_REQ;
        }

        if (recording_var_true(channel, vars, "RECORD_APPEND")) {
                file_flags |= SWITCH_FILE_WRITE_APPEND;
        }

        fh->samplerate = 0;
        if ((vval = get_recording_var(channel, vars, "record_sample_rate"))) {
                int tmp = 0;

                tmp = atoi(vval);

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

        if (!fh->samplerate) {
                fh->samplerate = read_impl.actual_samples_per_second;
        }

        fh->channels = channels;

        if ((vval = get_recording_var(channel, vars, "enable_file_write_buffering"))) {
                int tmp = atoi(vval);

                if (tmp > 0) {
                        fh->pre_buffer_datalen = tmp;
                } else if (switch_true(vval)) {
                        fh->pre_buffer_datalen = SWITCH_DEFAULT_FILE_BUFFER_LEN;
                }

        } else {
                fh->pre_buffer_datalen = SWITCH_DEFAULT_FILE_BUFFER_LEN;
        }

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

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

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

                if (*file == '[') {
                        tfile = switch_core_strdup(rh->helper_pool, file);
                        if ((e = switch_find_end_paren(tfile, '[', ']'))) {
                                *e = '\0';
                                file = e + 1;
                        } else {
                                tfile = NULL;
                        }
                } else {
                        file_path = switch_core_sprintf(rh->helper_pool, "%s%s%s", prefix, SWITCH_PATH_SEPARATOR, file);
                }

                file = switch_core_sprintf(rh->helper_pool, "%s%s%s%s%s", switch_str_nil(tfile), tfile ? "]" : "", prefix, SWITCH_PATH_SEPARATOR, file);
        } else {
                file_path = switch_core_strdup(rh->helper_pool, file);
        }

        if (file_path && !strstr(file_path, SWITCH_URL_SEPARATOR)) {
                char *p;
                char *path = switch_core_strdup(rh->helper_pool, file_path);

                if ((p = strrchr(path, *SWITCH_PATH_SEPARATOR))) {
                        *p = '\0';

                        if (*path == '{') {
                                path = switch_find_end_paren(path, '{', '}') + 1;
                        }
                        if ((vval = get_recording_var(channel, vars, "RECORD_DIR_PERMS"))) {
                                fileperms = strtol(vval, 0, 16);
                        }


                        if (switch_dir_make_recursive(path, fileperms, switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error creating %s\n", path);
                                set_completion_cause(rh, "uri-failure");
                                switch_goto_status(SWITCH_STATUS_GENERR, err);
                        }

                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error finding the folder path section in '%s'\n", path);
                        path = NULL;
                }
        }

        if ((ext = strrchr(file, '.'))) {
                ext++;

                if (switch_channel_test_flag(channel, CF_VIDEO)) {
                        file_flags |= SWITCH_FILE_FLAG_VIDEO;
                }

                if (switch_core_file_open(fh, file, channels, read_impl.actual_samples_per_second, file_flags, NULL) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error opening %s\n", file);
                        if (hangup_on_error) {
                                switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                                switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
                        }
                        set_completion_cause(rh, "uri-failure");
                        switch_goto_status(SWITCH_STATUS_GENERR, err);
                }

                if (fh->params) {
                        if ((p = switch_event_get_header(fh->params,"record_write_only")) && switch_true(p)) {
                                flags &= ~SMBF_READ_STREAM;
                                flags |= SMBF_WRITE_STREAM;
                        }


                        if ((p = switch_event_get_header(fh->params, "record_read_only")) && switch_true(p)) {
                                flags &= ~SMBF_WRITE_STREAM;
                                flags |= SMBF_READ_STREAM;
                        }
                }

                if (switch_core_file_has_video(fh, SWITCH_TRUE)) {
                        //switch_core_media_set_video_file(session, fh, SWITCH_RW_READ);
                        //switch_channel_set_flag_recursive(session->channel, CF_VIDEO_DECODED_READ);

                        if (recording_var_true(channel, vars, "record_concat_video")) {
                                flags |= SMBF_READ_VIDEO_STREAM;
                                flags |= SMBF_WRITE_VIDEO_STREAM;
                        } else if (recording_var_true(channel, vars, "record_bleg_video")) {
                                flags |= SMBF_WRITE_VIDEO_STREAM;
                        } else {
                                flags |= SMBF_READ_VIDEO_STREAM;
                        }
                } else {
                        flags &= ~SMBF_READ_VIDEO_PING;
                        flags &= ~SMBF_READ_VIDEO_STREAM;
                        flags &= ~SMBF_WRITE_VIDEO_STREAM;
                }

        } else {
                int tflags = 0;

                ext = read_impl.iananame;

                in_file = switch_core_sprintf(rh->helper_pool, "%s-in.%s", file, ext);
                out_file = switch_core_sprintf(rh->helper_pool, "%s-out.%s", file, ext);
                rh->in_fh.pre_buffer_datalen = rh->out_fh.pre_buffer_datalen = fh->pre_buffer_datalen;
                channels = 1;
                switch_set_flag(&rh->in_fh, SWITCH_FILE_NATIVE);
                switch_set_flag(&rh->out_fh, SWITCH_FILE_NATIVE);

                if (switch_core_file_open(&rh->in_fh, in_file, channels, read_impl.actual_samples_per_second, file_flags, NULL) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error opening %s\n", in_file);
                        if (hangup_on_error) {
                                switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                                switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
                        }
                        set_completion_cause(rh, "uri-failure");
                        switch_goto_status(SWITCH_STATUS_GENERR, err);
                }

                if (switch_core_file_open(&rh->out_fh, out_file, channels, read_impl.actual_samples_per_second, file_flags, NULL) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error opening %s\n", out_file);
                        switch_core_file_close(&rh->in_fh);
                        if (hangup_on_error) {
                                switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                                switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
                        }
                        set_completion_cause(rh, "uri-failure");
                        switch_goto_status(SWITCH_STATUS_GENERR, err);
                }

                rh->native = 1;
                fh = NULL;

                if ((flags & SMBF_WRITE_STREAM)) {
                        tflags |= SMBF_TAP_NATIVE_WRITE;
                }

                if ((flags & SMBF_READ_STREAM)) {
                        tflags |= SMBF_TAP_NATIVE_READ;
                }

                flags = tflags;
        }

        if ((p = get_recording_var(channel, vars, "RECORD_TITLE"))) {
                vval = (const char *) switch_core_strdup(rh->helper_pool, p);
                if (fh) 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, "RECORD_COPYRIGHT"))) {
                vval = (const char *) switch_core_strdup(rh->helper_pool, p);
                if (fh) 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, "RECORD_SOFTWARE"))) {
                vval = (const char *) switch_core_strdup(rh->helper_pool, p);
                if (fh) 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, "RECORD_ARTIST"))) {
                vval = (const char *) switch_core_strdup(rh->helper_pool, p);
                if (fh) 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, "RECORD_COMMENT"))) {
                vval = (const char *) switch_core_strdup(rh->helper_pool, p);
                if (fh) 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, "RECORD_DATE"))) {
                vval = (const char *) switch_core_strdup(rh->helper_pool, p);
                if (fh) switch_core_file_set_string(fh, SWITCH_AUDIO_COL_STR_DATE, vval);
                switch_channel_set_variable(channel, "RECORD_DATE", NULL);
        }

        if (limit) {
                to = switch_epoch_time_now(NULL) + limit;
        }

        rh->fh = fh;
        rh->file = switch_core_strdup(rh->helper_pool, file);
        rh->packet_len = read_impl.decoded_bytes_per_packet;

        if (file_flags & SWITCH_FILE_WRITE_APPEND) {
                rh->min_sec = 3;
        }

        if ((p = get_recording_var(channel, vars, "RECORD_MIN_SEC"))) {
                int tmp = atoi(p);
                if (tmp >= 0) {
                        rh->min_sec = tmp;
                }
        }

        if ((p = get_recording_var(channel, vars, "RECORD_INITIAL_TIMEOUT_MS"))) {
                int tmp = atoi(p);
                if (tmp >= 0) {
                        rh->initial_timeout_ms = tmp;
                        rh->silence_threshold = 200;
                }
        }

        if ((p = get_recording_var(channel, vars, "RECORD_FINAL_TIMEOUT_MS"))) {
                int tmp = atoi(p);
                if (tmp >= 0) {
                        rh->final_timeout_ms = tmp;
                        rh->silence_threshold = 200;
                }
        }

        if ((p = get_recording_var(channel, vars, "RECORD_SILENCE_THRESHOLD"))) {
                int tmp = atoi(p);
                if (tmp >= 0) {
                        rh->silence_threshold = tmp;
                }
        }

        if (vars) {
                switch_event_dup(&rh->variables, vars);
        }

        rh->hangup_on_error = hangup_on_error;

        if ((status = switch_core_media_bug_add(session, "session_record", file,
                                                                                        record_callback, rh, to, flags, &bug)) != SWITCH_STATUS_SUCCESS) {
                if (switch_channel_ready(channel)) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error adding media bug for file %s\n", file);
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Error adding media bug for file %s\n", file);
                }
                switch_goto_status(status, err);
        }

        if ((p = get_recording_var(channel, vars, "RECORD_PRE_BUFFER_FRAMES"))) {
                int tmp = atoi(p);

                if (tmp > 0) {
                        switch_core_media_bug_set_pre_buffer_framecount(bug, tmp);
                }
        } else {
                switch_core_media_bug_set_pre_buffer_framecount(bug, 25);
        }

        switch_channel_set_private(channel, file, bug);

        if (switch_channel_test_flag(channel, CF_VIDEO)) {
                switch_core_session_message_t msg = { 0 };

                msg.from = __FILE__;
                msg.message_id = SWITCH_MESSAGE_INDICATE_VIDEO_REFRESH_REQ;

                switch_core_session_receive_message(session, &msg);
        }

        return SWITCH_STATUS_SUCCESS;

err:
        if (!zstr(rh->completion_cause)) {
                switch_channel_set_variable_printf(channel, "record_completion_cause", "%s", rh->completion_cause);
        }
        record_helper_destroy(&rh, session);

        return status;
}

switch_ivr_resume_detect_speech()

switch_status_t switch_ivr_resume_detect_speech

(

switch_core_session_t *

session

)

Resume background Speech detection on a session.

Parameters

session

The session to resume detection on

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 5257 of file switch_ivr_async.c.

References speech_thread_handle::ah, switch_channel_audio_sync, switch_channel_get_private(), switch_core_asr_resume(), switch_core_session_get_channel(), SWITCH_SPEECH_KEY, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by CoreSession::detectSpeech(), speech_thread(), and switch_ivr_detect_speech().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        struct speech_thread_handle *sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY);

        if (sth) {
                switch_channel_audio_sync(channel);
                switch_core_asr_resume(sth->ah);
                return SWITCH_STATUS_SUCCESS;
        }
        return SWITCH_STATUS_FALSE;
}

switch_ivr_schedule_broadcast()

uint32_t switch_ivr_schedule_broadcast	(	time_t	runtime,
		const char *	uuid,
		const char *	path,
		switch_media_flag_t	flags
	)

Signal the session to broadcast audio in the future.

Parameters

runtime	when (in epoch time) to run the broadcast
uuid	the uuid of the session to broadcast on
path	the path data of the broadcast "/path/to/file.wav [<timer name>]" or "speak:<engine>|<voice>|<Text to say>"
flags	flags to send to the request (SMF_ECHO_BRIDGED to send the broadcast to both sides of the call)

Returns

the id of the task

Definition at line 5635 of file switch_ivr_async.c.

References __SWITCH_FUNC__, cur, broadcast_helper::flags, broadcast_helper::path, SSHF_FREE_ARG, switch_copy_string(), switch_scheduler_add_task(), switch_zmalloc, and broadcast_helper::uuid_str.

{
        struct broadcast_helper *helper;
        size_t len = sizeof(*helper) + strlen(path) + 1;
        char *cur = NULL;

        switch_zmalloc(cur, len);
        helper = (struct broadcast_helper *) cur;

        cur += sizeof(*helper);
        switch_copy_string(helper->uuid_str, uuid, sizeof(helper->uuid_str));
        helper->flags = flags;

        switch_copy_string(cur, path, len - sizeof(*helper));
        helper->path = cur;

        return switch_scheduler_add_task(runtime, sch_broadcast_callback, (char *) __SWITCH_FUNC__, uuid, 0, helper, SSHF_FREE_ARG);
}

switch_ivr_schedule_hangup()

uint32_t switch_ivr_schedule_hangup	(	time_t	runtime,
		const char *	uuid,
		switch_call_cause_t	cause,
		switch_bool_t	bleg
	)

Hangup an existing session in the future.

Parameters

runtime	the time (int epoch seconds) to transfer the call
uuid	the uuid of the session to hangup
cause	the hanup cause code
bleg	hangup up the B-Leg if possible

Returns

the id of the task

Definition at line 5538 of file switch_ivr_async.c.

References __SWITCH_FUNC__, hangup_helper::bleg, hangup_helper::cause, SSHF_FREE_ARG, switch_copy_string(), switch_scheduler_add_task(), switch_zmalloc, and hangup_helper::uuid_str.

{
        struct hangup_helper *helper;
        size_t len = sizeof(*helper);

        switch_zmalloc(helper, len);

        switch_copy_string(helper->uuid_str, uuid, sizeof(helper->uuid_str));
        helper->cause = cause;
        helper->bleg = bleg;

        return switch_scheduler_add_task(runtime, sch_hangup_callback, (char *) __SWITCH_FUNC__, uuid, 0, helper, SSHF_FREE_ARG);
}

switch_ivr_schedule_transfer()

uint32_t switch_ivr_schedule_transfer	(	time_t	runtime,
		const char *	uuid,
		char *	extension,
		char *	dialplan,
		char *	context
	)

Transfer an existing session to another location in the future.

Parameters

runtime	the time (int epoch seconds) to transfer the call
uuid	the uuid of the session to transfer
extension	the new extension
dialplan	the new dialplan (OPTIONAL, may be NULL)
context	the new context (OPTIONAL, may be NULL)

Returns

the id of the task

Definition at line 5575 of file switch_ivr_async.c.

References __SWITCH_FUNC__, transfer_helper::context, cur, transfer_helper::dialplan, transfer_helper::extension, SSHF_FREE_ARG, switch_copy_string(), switch_scheduler_add_task(), switch_zmalloc, and transfer_helper::uuid_str.

{
        struct transfer_helper *helper;
        size_t len = sizeof(*helper);
        char *cur = NULL;

        if (extension) {
                len += strlen(extension) + 1;
        }

        if (dialplan) {
                len += strlen(dialplan) + 1;
        }

        if (context) {
                len += strlen(context) + 1;
        }

        switch_zmalloc(cur, len);
        helper = (struct transfer_helper *) cur;

        switch_copy_string(helper->uuid_str, uuid, sizeof(helper->uuid_str));

        cur += sizeof(*helper);

        if (extension) {
                switch_copy_string(cur, extension, strlen(extension) + 1);
                helper->extension = cur;
                cur += strlen(helper->extension) + 1;
        }

        if (dialplan) {
                switch_copy_string(cur, dialplan, strlen(dialplan) + 1);
                helper->dialplan = cur;
                cur += strlen(helper->dialplan) + 1;
        }

        if (context) {
                switch_copy_string(cur, context, strlen(context) + 1);
                helper->context = cur;
        }

        return switch_scheduler_add_task(runtime, sch_transfer_callback, (char *) __SWITCH_FUNC__, uuid, 0, helper, SSHF_FREE_ARG);
}

switch_ivr_session_audio()

switch_status_t switch_ivr_session_audio	(	switch_core_session_t *	session,
		const char *	cmd,
		const char *	direction,
		int	level
	)

Definition at line 3727 of file switch_ivr_async.c.

References switch_session_audio_t::read_level, switch_session_audio_t::read_mute, switch_session_audio_t::session, session_audio_callback(), SMBF_NO_PAUSE, SMBF_READ_REPLACE, SMBF_WRITE_REPLACE, switch_channel_get_private(), switch_channel_pre_answer, switch_channel_set_private(), switch_core_media_bug_add(), switch_core_media_bug_get_user_data(), switch_core_media_bug_set_flag(), switch_core_session_alloc, switch_core_session_get_channel(), switch_core_session_get_read_impl(), SWITCH_STATUS_FALSE, SWITCH_STATUS_MEMERR, SWITCH_STATUS_SUCCESS, switch_session_audio_t::write_level, and switch_session_audio_t::write_mute.

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_media_bug_t *bug;
        switch_status_t status;
        switch_session_audio_t *pvt;
        switch_codec_implementation_t read_impl = { 0 };
        int existing = 0, c_read = 0, c_write = 0, flags = SMBF_NO_PAUSE;

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

        switch_core_session_get_read_impl(session, &read_impl);


        if ((bug = switch_channel_get_private(channel, "__audio"))) {
                pvt = switch_core_media_bug_get_user_data(bug);
                existing = 1;
        } else {
                if (!(pvt = switch_core_session_alloc(session, sizeof(*pvt)))) {
                        return SWITCH_STATUS_MEMERR;
                }

                pvt->session = session;
        }


        if (!strcasecmp(direction, "write")) {
                flags = SMBF_WRITE_REPLACE;
                c_write = 1;
        } else if (!strcasecmp(direction, "read")) {
                flags = SMBF_READ_REPLACE;
                c_read = 1;
        } else if (!strcasecmp(direction, "both")) {
                flags = SMBF_READ_REPLACE | SMBF_WRITE_REPLACE;
                c_read = c_write = 1;
        }


        if (!strcasecmp(cmd, "mute")) {
                if (c_read) {
                        pvt->read_mute = level;
                        pvt->read_level = 0;
                }
                if (c_write) {
                        pvt->write_mute = level;
                        pvt->write_level = 0;
                }
        } else if (!strcasecmp(cmd, "level")) {
                if (level < 5 && level > -5) {
                        if (c_read) {
                                pvt->read_level = level;
                        }
                        if (c_write) {
                                pvt->write_level = level;
                        }
                }
        }

        if (existing) {
                switch_core_media_bug_set_flag(bug, flags);
        } else {
                if ((status = switch_core_media_bug_add(session, "audio", cmd,
                                                                                                session_audio_callback, pvt, 0, flags, &bug)) != SWITCH_STATUS_SUCCESS) {
                        return status;
                }

                switch_channel_set_private(channel, "__audio", bug);
        }


        return SWITCH_STATUS_SUCCESS;
}

switch_ivr_session_echo()

switch_status_t switch_ivr_session_echo	(	switch_core_session_t *	session,
		switch_input_args_t *	args
	)

• NEEDDESC -

Parameters

session

the session to act on

Definition at line 703 of file switch_ivr_async.c.

References arg_recursion_check_start, switch_input_args_t::buf, switch_input_args_t::buflen, CF_BREAK, CF_TEXT_ECHO, CF_VIDEO_DECODED_READ, CF_VIDEO_ECHO, switch_dtmf_t::digit, switch_input_args_t::input_callback, switch_channel_clear_flag(), switch_channel_clear_flag_recursive(), switch_channel_dequeue_dtmf(), switch_channel_has_dtmf(), switch_channel_pre_answer, switch_channel_ready, switch_channel_set_flag, switch_channel_set_flag_recursive(), switch_channel_test_flag(), switch_channel_var_true(), switch_core_session_dequeue_event(), switch_core_session_get_channel(), switch_core_session_raw_read(), switch_core_session_read_frame(), switch_core_session_reset(), switch_core_session_video_reset(), switch_core_session_write_frame(), switch_event_destroy(), SWITCH_FALSE, SWITCH_INPUT_TYPE_DTMF, SWITCH_INPUT_TYPE_EVENT, SWITCH_IO_FLAG_NONE, switch_ivr_parse_all_events(), SWITCH_READ_ACCEPTABLE, SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and SWITCH_TRUE.

{
        switch_status_t status;
        switch_frame_t *read_frame;
        switch_channel_t *channel = switch_core_session_get_channel(session);

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

        arg_recursion_check_start(args);
        
        if (switch_channel_var_true(channel, "echo_decode_video")) {
                switch_channel_set_flag_recursive(channel, CF_VIDEO_DECODED_READ);
        }

        if (switch_channel_var_true(channel, "echo_decode_audio")) {
                switch_core_session_raw_read(session);
        }

        switch_channel_set_flag(channel, CF_VIDEO_ECHO);
        switch_channel_set_flag(channel, CF_TEXT_ECHO);

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

                switch_ivr_parse_all_events(session);

                if (args && (args->input_callback || args->buf || args->buflen)) {
                        switch_dtmf_t dtmf = {0};

                        /*
                           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 (!args->input_callback && !args->buf) {
                                        break;
                                }
                                switch_channel_dequeue_dtmf(channel, &dtmf);
                                if (args->input_callback) {
                                        status = args->input_callback(session, (void *) &dtmf, SWITCH_INPUT_TYPE_DTMF, args->buf, args->buflen);
                                } else {
                                        *((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;
                        }
                }

                switch_core_session_write_frame(session, read_frame, SWITCH_IO_FLAG_NONE, 0);

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

        if (switch_channel_var_true(channel, "echo_decode_video")) {
                switch_channel_clear_flag_recursive(channel, CF_VIDEO_DECODED_READ);
        }

        switch_core_session_video_reset(session);
        switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
        switch_channel_clear_flag(channel, CF_TEXT_ECHO);

        return SWITCH_STATUS_SUCCESS;
}

switch_ivr_session_transfer()

switch_status_t switch_ivr_session_transfer	(	_In_ switch_core_session_t *	session,
		const char *	extension,
		const char *	dialplan,
		const char *	context
	)

Transfer an existing session to another location.

Parameters

session	the session to transfer
extension	the new extension
dialplan	the new dialplan (OPTIONAL, may be NULL)
context	the new context (OPTIONAL, may be NULL)

Referenced by fs_switch_ivr_session_transfer(), switch_channel_handle_cause(), switch_ivr_multi_threaded_bridge(), switch_ivr_originate(), switch_play_and_get_digits(), SWITCH_STANDARD_SCHED_FUNC(), CoreSession::transfer(), transfer_after_bridge(), and uuid_bridge_on_soft_execute().

switch_ivr_set_param_detect_speech()

switch_status_t switch_ivr_set_param_detect_speech	(	switch_core_session_t *	session,
		const char *	name,
		const char *	val
	)

Definition at line 5286 of file switch_ivr_async.c.

References speech_thread_handle::ah, switch_channel_get_private(), switch_core_asr_text_param(), switch_core_session_get_channel(), SWITCH_SPEECH_KEY, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by CoreSession::detectSpeech().

{
        struct speech_thread_handle *sth = switch_channel_get_private(switch_core_session_get_channel(session), SWITCH_SPEECH_KEY);
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (sth && sth->ah && name && val) {
                switch_core_asr_text_param(sth->ah, (char *) name, val);
                status = SWITCH_STATUS_SUCCESS;
        }

        return status;
}

switch_ivr_set_xml_chan_vars()

int switch_ivr_set_xml_chan_vars	(	switch_xml_t	xml,
		switch_channel_t *	channel,
		int	off
	)

Definition at line 2838 of file switch_ivr.c.

References switch_event_header::array, switch_event_header::idx, switch_event_header::name, switch_event_header::next, switch_channel_variable_first(), switch_channel_variable_last(), switch_ivr_set_xml_chan_var(), and switch_event_header::value.

Referenced by switch_ivr_generate_xml_cdr().

{

        switch_event_header_t *hi = switch_channel_variable_first(channel);

        if (!hi)
                return off;

        for (; hi; hi = hi->next) {
                if (hi->idx) {
                        int i;

                        for (i = 0; i < hi->idx; i++) {
                                off = switch_ivr_set_xml_chan_var(xml, hi->name, hi->array[i], off);
                        }
                } else {
                        off = switch_ivr_set_xml_chan_var(xml, hi->name, hi->value, off);
                }
        }
        switch_channel_variable_last(channel);

        return off;
}

switch_ivr_set_xml_profile_data()

int switch_ivr_set_xml_profile_data	(	switch_xml_t	xml,
		switch_caller_profile_t *	caller_profile,
		int	off
	)

Definition at line 2599 of file switch_ivr.c.

References switch_caller_profile::ani, switch_caller_profile::aniii, switch_caller_profile::callee_id_name, switch_caller_profile::callee_id_number, switch_caller_profile::caller_id_name, switch_caller_profile::caller_id_number, switch_caller_profile::chan_name, switch_caller_profile::context, switch_caller_profile::destination_number, switch_caller_profile::dialplan, switch_caller_profile::network_addr, profile_node_s::next, switch_caller_profile::rdnis, switch_caller_profile::soft, switch_caller_profile::source, switch_xml_add_child_d(), switch_xml_set_txt_d(), switch_caller_profile::transfer_source, switch_caller_profile::username, switch_caller_profile::uuid, profile_node_s::val, and profile_node_s::var.

Referenced by switch_ivr_generate_xml_cdr().

{
        switch_xml_t param;

        if (!(param = switch_xml_add_child_d(xml, "username", off++))) {
                return -1;
        }
        switch_xml_set_txt_d(param, caller_profile->username);

        if (!(param = switch_xml_add_child_d(xml, "dialplan", off++))) {
                return -1;
        }
        switch_xml_set_txt_d(param, caller_profile->dialplan);

        if (!(param = switch_xml_add_child_d(xml, "caller_id_name", off++))) {
                return -1;
        }
        switch_xml_set_txt_d(param, caller_profile->caller_id_name);

        if (!(param = switch_xml_add_child_d(xml, "caller_id_number", off++))) {
                return -1;
        }
        switch_xml_set_txt_d(param, caller_profile->caller_id_number);

        if (!(param = switch_xml_add_child_d(xml, "callee_id_name", off++))) {
                return -1;
        }
        switch_xml_set_txt_d(param, caller_profile->callee_id_name);

        if (!(param = switch_xml_add_child_d(xml, "callee_id_number", off++))) {
                return -1;
        }
        switch_xml_set_txt_d(param, caller_profile->callee_id_number);

        if (!(param = switch_xml_add_child_d(xml, "ani", off++))) {
                return -1;
        }
        switch_xml_set_txt_d(param, caller_profile->ani);

        if (!(param = switch_xml_add_child_d(xml, "aniii", off++))) {
                return -1;
        }
        switch_xml_set_txt_d(param, caller_profile->aniii);


        if (!(param = switch_xml_add_child_d(xml, "network_addr", off++))) {
                return -1;
        }
        switch_xml_set_txt_d(param, caller_profile->network_addr);

        if (!(param = switch_xml_add_child_d(xml, "rdnis", off++))) {
                return -1;
        }
        switch_xml_set_txt_d(param, caller_profile->rdnis);

        if (!(param = switch_xml_add_child_d(xml, "destination_number", off++))) {
                return -1;
        }
        switch_xml_set_txt_d(param, caller_profile->destination_number);

        if (!(param = switch_xml_add_child_d(xml, "uuid", off++))) {
                return -1;
        }
        switch_xml_set_txt_d(param, caller_profile->uuid);

        if (!(param = switch_xml_add_child_d(xml, "source", off++))) {
                return -1;
        }
        switch_xml_set_txt_d(param, caller_profile->source);

        if (caller_profile->transfer_source) {
                if (!(param = switch_xml_add_child_d(xml, "transfer_source", off++))) {
                        return -1;
                }
                switch_xml_set_txt_d(param, caller_profile->transfer_source);
        }

        if (!(param = switch_xml_add_child_d(xml, "context", off++))) {
                return -1;
        }
        switch_xml_set_txt_d(param, caller_profile->context);

        if (!(param = switch_xml_add_child_d(xml, "chan_name", off++))) {
                return -1;
        }
        switch_xml_set_txt_d(param, caller_profile->chan_name);


        if (caller_profile->soft) {
                profile_node_t *pn;

                for (pn = caller_profile->soft; pn; pn = pn->next) {

                        if (!(param = switch_xml_add_child_d(xml, pn->var, off++))) {
                                return -1;
                        }
                        switch_xml_set_txt_d(param, pn->val);
                }

        }


        return off;
}

switch_ivr_signal_bridge()

switch_status_t switch_ivr_signal_bridge	(	switch_core_session_t *	session,
		switch_core_session_t *	peer_session
	)

Bridge Signalling from one session to another.

Parameters

session	one session
peer_session	the other session

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 1532 of file switch_ivr_bridge.c.

References CF_BRIDGE_ORIGINATOR, CF_BRIDGED, CF_RESET, CF_SIGNAL_BRIDGE_TTL, CF_TRANSFER, check_bridge_export(), CS_HIBERNATE, SWITCH_CAUSE_ORIGINATOR_CANCEL, switch_channel_add_state_handler(), switch_channel_clear_flag(), switch_channel_clear_state_handler(), switch_channel_down_nosig, switch_channel_event_set_data(), switch_channel_get_cause(), switch_channel_hangup, switch_channel_set_flag, switch_channel_set_flag_recursive(), switch_channel_set_state, switch_channel_set_state_flag(), switch_channel_set_variable, switch_channel_test_flag(), switch_channel_up_nosig, switch_core_session_get_channel(), switch_core_session_get_uuid(), switch_event_add_header_string(), SWITCH_EVENT_CHANNEL_EXECUTE, switch_event_create, switch_event_fire, switch_ivr_bridge_display(), SWITCH_SIGNAL_BRIDGE_VARIABLE, SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_standard_on_reset(), switch_ivr_3p_nomedia(), switch_ivr_enterprise_orig_and_bridge(), switch_ivr_multi_threaded_bridge(), switch_ivr_nomedia(), and switch_ivr_orig_and_bridge().

{
        switch_channel_t *caller_channel = switch_core_session_get_channel(session);
        switch_channel_t *peer_channel = switch_core_session_get_channel(peer_session);
        switch_event_t *event;

        if (switch_channel_down_nosig(peer_channel)) {
                switch_channel_hangup(caller_channel, switch_channel_get_cause(peer_channel));
                return SWITCH_STATUS_FALSE;
        }

        if (!switch_channel_up_nosig(caller_channel)) {
                switch_channel_hangup(peer_channel, SWITCH_CAUSE_ORIGINATOR_CANCEL);
                return SWITCH_STATUS_FALSE;
        }

        check_bridge_export(caller_channel, peer_channel);

        switch_channel_set_flag_recursive(caller_channel, CF_SIGNAL_BRIDGE_TTL);
        switch_channel_set_flag_recursive(peer_channel, CF_SIGNAL_BRIDGE_TTL);

        switch_channel_set_variable(caller_channel, SWITCH_SIGNAL_BRIDGE_VARIABLE, switch_core_session_get_uuid(peer_session));
        switch_channel_set_variable(peer_channel, SWITCH_SIGNAL_BRIDGE_VARIABLE, switch_core_session_get_uuid(session));
        switch_channel_set_variable(peer_channel, "call_uuid", switch_core_session_get_uuid(session));

        switch_channel_set_flag_recursive(caller_channel, CF_BRIDGE_ORIGINATOR);
        switch_channel_clear_flag(peer_channel, CF_BRIDGE_ORIGINATOR);

        switch_channel_clear_state_handler(caller_channel, NULL);
        switch_channel_clear_state_handler(peer_channel, NULL);

        switch_channel_add_state_handler(caller_channel, &signal_bridge_state_handlers);
        switch_channel_add_state_handler(peer_channel, &signal_bridge_state_handlers);

        switch_channel_set_variable(caller_channel, "signal_bridge", "true");
        switch_channel_set_variable(peer_channel, "signal_bridge", "true");

        /* fire events that will change the data table from "show channels" */
        if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_EXECUTE) == SWITCH_STATUS_SUCCESS) {
                switch_channel_event_set_data(caller_channel, event);
                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application", "signal_bridge");
                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application-Data", switch_core_session_get_uuid(peer_session));
                switch_event_fire(&event);
        }

        if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_EXECUTE) == SWITCH_STATUS_SUCCESS) {
                switch_channel_event_set_data(peer_channel, event);
                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application", "signal_bridge");
                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application-Data", switch_core_session_get_uuid(session));
                switch_event_fire(&event);
        }

        switch_channel_set_state_flag(caller_channel, CF_RESET);
        switch_channel_set_state_flag(peer_channel, CF_RESET);

        switch_channel_set_state(caller_channel, CS_HIBERNATE);
        switch_channel_set_state(peer_channel, CS_HIBERNATE);

#if 0
        if (switch_channel_test_flag(caller_channel, CF_BRIDGED)) {
                switch_channel_set_flag(caller_channel, CF_TRANSFER);
                switch_channel_set_flag(peer_channel, CF_TRANSFER);
        }
#endif

        switch_ivr_bridge_display(session, peer_session);

        return SWITCH_STATUS_SUCCESS;
}

switch_ivr_sleep()

switch_status_t switch_ivr_sleep	(	switch_core_session_t *	session,
		uint32_t	ms,
		switch_bool_t	sync,
		switch_input_args_t *	args
	)

Wait for time to pass for a specified number of milliseconds.

Parameters

session	the session to wait for.
ms	the number of milliseconds
sync	synchronize the channel's audio before waiting
args	arguements to pass for callbacks etc

Returns

SWITCH_STATUS_SUCCESS if the channel is still up

Definition at line 127 of file switch_ivr.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_BLANK, switch_frame::codec, switch_frame::data, switch_frame::datalen, switch_codec_implementation::decoded_bytes_per_packet, switch_dtmf_t::digit, switch_input_args_t::dmachine, switch_input_args_t::input_callback, switch_codec_implementation::microseconds_per_packet, switch_codec_implementation::number_of_channels, switch_input_args_t::read_frame_callback, switch_frame::samples, SFF_CNG, switch_channel_audio_sync, switch_channel_clear_flag(), switch_channel_dequeue_dtmf(), switch_channel_get_variable, switch_channel_has_dtmf(), switch_channel_media_ready, switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_test_flag(), SWITCH_CODEC_FLAG_DECODE, SWITCH_CODEC_FLAG_ENCODE, switch_core_codec_destroy(), switch_core_codec_init, 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_write_frame(), switch_event_destroy(), SWITCH_FALSE, switch_generate_sln_silence(), switch_goto_status, SWITCH_INPUT_TYPE_DTMF, SWITCH_INPUT_TYPE_EVENT, SWITCH_IO_FLAG_NONE, switch_ivr_dmachine_feed(), switch_ivr_dmachine_ping(), switch_ivr_parse_all_events(), SWITCH_IVR_VERIFY_SILENCE_DIVISOR, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_micro_time_now(), SWITCH_READ_ACCEPTABLE, SWITCH_RECOMMENDED_BUFFER_SIZE, switch_safe_free, SWITCH_SEND_SILENCE_WHEN_IDLE_VARIABLE, switch_set_flag, SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_yield, switch_zmalloc, and switch_input_args_t::user_data.

Referenced by audio_bridge_thread(), collect_thread_run(), fs_switch_ivr_sleep(), originate_on_consume_media_transmit(), CoreSession::sleep(), switch_channel_perform_answer(), switch_ivr_originate(), switch_ivr_phrase_macro_event(), switch_ivr_play_and_collect_input(), switch_ivr_play_and_detect_speech(), and switch_ivr_play_file().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        switch_time_t start = switch_micro_time_now(), now, done = switch_micro_time_now() + (ms * 1000);
        switch_frame_t *read_frame, cng_frame = { 0 };
        int32_t left;
        uint32_t elapsed;
        char data[2] = "";

        switch_frame_t write_frame = { 0 };
        unsigned char *abuf = NULL;
        switch_codec_implementation_t imp = { 0 };
        switch_codec_t codec = { 0 };
        int sval = 0;
        const char *var;

        arg_recursion_check_start(args);

        switch_channel_set_flag(channel, CF_VIDEO_BLANK);

        switch_core_session_get_read_impl(session, &imp);

        /*
           if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_INBOUND && !switch_channel_test_flag(channel, CF_PROXY_MODE) &&
           !switch_channel_media_ready(channel) && !switch_channel_test_flag(channel, CF_SERVICE)) {
           if ((status = switch_channel_pre_answer(channel)) != SWITCH_STATUS_SUCCESS) {
           switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot establish media.\n");
           return SWITCH_STATUS_FALSE;
           }
           }
         */

        if (!switch_channel_media_ready(channel)) {

                for (elapsed=0; switch_channel_ready(channel) && elapsed<(ms/20); elapsed++) {
                        if (switch_channel_test_flag(channel, CF_BREAK)) {
                                switch_channel_clear_flag(channel, CF_BREAK);
                                switch_goto_status(SWITCH_STATUS_BREAK, end);
                        }

                        switch_yield(20 * 1000);
                }
                switch_goto_status(SWITCH_STATUS_SUCCESS, end);
        }

        if ((var = switch_channel_get_variable(channel, SWITCH_SEND_SILENCE_WHEN_IDLE_VARIABLE))
                && (sval = atoi(var))) {
                SWITCH_IVR_VERIFY_SILENCE_DIVISOR(sval);
        }

        if (ms > 10 && sval) {

                if (switch_core_codec_init(&codec,
                                                                   "L16",
                                                                   NULL,
                                                                   NULL,
                                                                   imp.actual_samples_per_second,
                                                                   imp.microseconds_per_packet / 1000,
                                                                   imp.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_ERROR, "Codec Error L16@%uhz %u channels %dms\n",
                                                          imp.actual_samples_per_second, imp.number_of_channels, imp.microseconds_per_packet / 1000);
                        switch_goto_status(SWITCH_STATUS_FALSE, end);
                }


                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Codec Activated L16@%uhz %u channels %dms\n",
                                                  imp.actual_samples_per_second, imp.number_of_channels, imp.microseconds_per_packet / 1000);

                write_frame.codec = &codec;
                switch_zmalloc(abuf, SWITCH_RECOMMENDED_BUFFER_SIZE);
                write_frame.data = abuf;
                write_frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE;
                write_frame.datalen = imp.decoded_bytes_per_packet;
                write_frame.samples = write_frame.datalen / sizeof(int16_t);

        }

        if (!write_frame.datalen) {
                sval = 0;
        }

        cng_frame.data = data;
        cng_frame.datalen = 2;
        cng_frame.buflen = 2;
        switch_set_flag((&cng_frame), SFF_CNG);

        if (sync) {
                switch_channel_audio_sync(channel);
        }

        if (!ms) {
                switch_goto_status(SWITCH_STATUS_SUCCESS, end);
        }

        for (;;) {
                now = switch_micro_time_now();
                elapsed = (int32_t) ((now - start) / 1000);
                left = ms - elapsed;

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

                if (now > done || left <= 0) {
                        break;
                }


                switch_ivr_parse_all_events(session);


                if (args) {
                        switch_dtmf_t dtmf = {0};

                        /*
                           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 (!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) {
                                        switch_status_t ostatus = args->input_callback(session, event, SWITCH_INPUT_TYPE_EVENT, args->buf, args->buflen);
                                        if (ostatus != 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 (read_frame && args && (args->read_frame_callback)) {
                        if ((status = args->read_frame_callback(session, read_frame, args->user_data)) != SWITCH_STATUS_SUCCESS) {
                                break;
                        }
                }

                if (sval && write_frame.datalen) {
                        switch_generate_sln_silence((int16_t *) write_frame.data, write_frame.samples, imp.number_of_channels, sval);
                        switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0);
                } else {
                        switch_core_session_write_frame(session, &cng_frame, SWITCH_IO_FLAG_NONE, 0);
                }
        }


 end:

        switch_channel_clear_flag(channel, CF_VIDEO_BLANK);

        arg_recursion_check_stop(args);

        if (write_frame.codec) {
                switch_core_codec_destroy(&codec);
        }

        switch_safe_free(abuf);

        return status;
}

switch_ivr_speak_text()

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.

Parameters

session	the session to speak on
tts_name	the desired tts module
voice_name	the desired voice
text	the text to speak
args	arguements to pass for callbacks etc

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 3026 of file switch_ivr_play_say.c.

References switch_codec_implementation::actual_samples_per_second, arg_recursion_check_start, arg_recursion_check_stop, switch_frame::codec, cached_speech_handle::codec, memset(), switch_codec_implementation::microseconds_per_packet, switch_codec_implementation::number_of_channels, pool, switch_speech_handle::samples, cached_speech_handle::sh, SWITCH_CACHE_SPEECH_HANDLES_OBJ_NAME, SWITCH_CACHE_SPEECH_HANDLES_VARIABLE, switch_channel_get_private(), switch_channel_get_variable, switch_channel_pre_answer, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_private(), SWITCH_CODEC_FLAG_DECODE, SWITCH_CODEC_FLAG_ENCODE, switch_copy_string(), switch_core_codec_destroy(), switch_core_codec_init, switch_core_service_session, switch_core_session_alloc, switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_impl(), switch_core_session_reset(), switch_core_speech_close(), switch_core_speech_open(), switch_core_speech_text_param_tts(), switch_core_thread_session_end(), switch_core_timer_destroy(), switch_core_timer_init(), switch_core_timer_sync(), SWITCH_FALSE, switch_ivr_clear_speech_cache(), switch_ivr_speak_text_handle(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_SPEECH_FLAG_NONE, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, SWITCH_TRUE, switch_true(), cached_speech_handle::timer, cached_speech_handle::tts_name, and cached_speech_handle::voice_name.

Referenced by fs_switch_ivr_speak_text(), CoreSession::speak(), switch_ivr_phrase_macro_event(), and switch_ivr_play_file().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        uint32_t rate = 0;
        int interval = 0;
        uint32_t channels;
        switch_frame_t write_frame = { 0 };
        switch_timer_t ltimer, *timer;
        switch_codec_t lcodec, *codec;
        switch_memory_pool_t *pool = switch_core_session_get_pool(session);
        char *codec_name;
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        switch_speech_handle_t lsh, *sh;
        switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_NONE;
        const char *timer_name, *var;
        cached_speech_handle_t *cache_obj = NULL;
        int need_create = 1, need_alloc = 1;
        switch_codec_implementation_t read_impl = { 0 };
        switch_core_session_get_read_impl(session, &read_impl);

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

        arg_recursion_check_start(args);

        sh = ↰
        codec = &lcodec;
        timer = &ltimer;

        if ((var = switch_channel_get_variable(channel, SWITCH_CACHE_SPEECH_HANDLES_VARIABLE)) && switch_true(var)) {
                if ((cache_obj = (cached_speech_handle_t *) switch_channel_get_private(channel, SWITCH_CACHE_SPEECH_HANDLES_OBJ_NAME))) {
                        need_create = 0;
                        if (!strcasecmp(cache_obj->tts_name, tts_name)) {
                                need_alloc = 0;
                        } else {
                                switch_ivr_clear_speech_cache(session);
                        }
                }

                if (!cache_obj) {
                        cache_obj = (cached_speech_handle_t *) switch_core_session_alloc(session, sizeof(*cache_obj));
                }
                if (need_alloc) {
                        switch_copy_string(cache_obj->tts_name, tts_name, sizeof(cache_obj->tts_name));
                        switch_copy_string(cache_obj->voice_name, voice_name, sizeof(cache_obj->voice_name));
                        switch_channel_set_private(channel, SWITCH_CACHE_SPEECH_HANDLES_OBJ_NAME, cache_obj);
                }
                sh = &cache_obj->sh;
                codec = &cache_obj->codec;
                timer = &cache_obj->timer;
        }

        timer_name = switch_channel_get_variable(channel, "timer_name");

        switch_core_session_reset(session, SWITCH_FALSE, SWITCH_FALSE);

        rate = read_impl.actual_samples_per_second;
        interval = read_impl.microseconds_per_packet / 1000;
        channels = read_impl.number_of_channels;

        if (need_create) {
                memset(sh, 0, sizeof(*sh));
                if ((status = switch_core_speech_open(sh, tts_name, voice_name, (uint32_t) rate, interval, read_impl.number_of_channels, &flags, NULL)) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid TTS module %s[%s]!\n", tts_name, voice_name);
                        switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
                        switch_ivr_clear_speech_cache(session);
                        arg_recursion_check_stop(args);
                        return status;
                }
        } else if (cache_obj && strcasecmp(cache_obj->voice_name, voice_name)) {
                switch_copy_string(cache_obj->voice_name, voice_name, sizeof(cache_obj->voice_name));
                switch_core_speech_text_param_tts(sh, "voice", voice_name);
        }

        if (switch_channel_pre_answer(channel) != SWITCH_STATUS_SUCCESS) {
                flags = 0;
                switch_core_speech_close(sh, &flags);
                arg_recursion_check_stop(args);
                return SWITCH_STATUS_FALSE;
        }
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "OPEN TTS %s\n", tts_name);

        codec_name = "L16";

        if (need_create) {
                if (switch_core_codec_init(codec,
                                                                   codec_name,
                                                                   NULL,
                                                                   NULL, (int) rate, interval, channels, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL,
                                                                   pool) == SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Raw Codec Activated\n");
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Raw Codec Activation Failed %s@%uhz 1 channel %dms\n", codec_name,
                                                          rate, interval);
                        flags = 0;
                        switch_core_speech_close(sh, &flags);
                        switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
                        switch_ivr_clear_speech_cache(session);
                        arg_recursion_check_stop(args);
                        return SWITCH_STATUS_GENERR;
                }
        }

        write_frame.codec = codec;

        if (timer_name) {
                if (need_create) {
                        if (switch_core_timer_init(timer, timer_name, interval, (int) sh->samples, pool) != SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Setup timer failed!\n");
                                switch_core_codec_destroy(write_frame.codec);
                                flags = 0;
                                switch_core_speech_close(sh, &flags);
                                switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
                                switch_ivr_clear_speech_cache(session);
                                arg_recursion_check_stop(args);
                                return SWITCH_STATUS_GENERR;
                        }
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Setup timer success %u bytes per %d ms!\n", sh->samples * 2,
                                                          interval);
                }
                switch_core_timer_sync(timer); // Sync timer

                /* start a thread to absorb incoming audio */
                switch_core_service_session(session);

        }

        status = switch_ivr_speak_text_handle(session, sh, write_frame.codec, timer_name ? timer : NULL, text, args);
        flags = 0;

        if (!cache_obj) {
                switch_core_speech_close(sh, &flags);
                switch_core_codec_destroy(codec);
        }

        if (timer_name) {
                /* End the audio absorbing thread */
                switch_core_thread_session_end(session);
                if (!cache_obj) {
                        switch_core_timer_destroy(timer);
                }
        }

        switch_core_session_reset(session, SWITCH_FALSE, SWITCH_TRUE);
        arg_recursion_check_stop(args);

        return status;
}

switch_ivr_speak_text_handle()

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
	)

Definition at line 2744 of file switch_ivr_play_say.c.

References arg_recursion_check_start, arg_recursion_check_stop, switch_input_args_t::buf, switch_frame::buflen, switch_input_args_t::buflen, CF_BREAK, CF_HOLD, switch_speech_handle::channels, switch_frame::codec, switch_frame::data, switch_frame::datalen, switch_dtmf_t::digit, switch_input_args_t::dmachine, switch_codec::implementation, switch_input_args_t::input_callback, memset(), switch_frame::rate, switch_speech_handle::rate, switch_input_args_t::read_frame_callback, switch_timer::samplecount, switch_frame::samples, switch_speech_handle::samples, switch_assert, switch_channel_audio_sync, switch_channel_clear_flag(), switch_channel_dequeue_dtmf(), switch_channel_get_variable, switch_channel_has_dtmf(), switch_channel_pre_answer, switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_test_flag(), switch_core_codec_ready(), switch_core_session_dequeue_event(), switch_core_session_get_channel(), switch_core_session_read_frame(), switch_core_session_write_frame(), switch_core_speech_feed_tts(), switch_core_speech_flush_tts(), switch_core_speech_read_tts(), switch_core_timer_next(), switch_event_destroy(), SWITCH_FALSE, SWITCH_INPUT_TYPE_DTMF, SWITCH_INPUT_TYPE_EVENT, SWITCH_IO_FLAG_NONE, switch_ivr_dmachine_feed(), switch_ivr_dmachine_ping(), switch_ivr_parse_all_events(), switch_ivr_parse_all_messages(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_READ_ACCEPTABLE, SWITCH_RECOMMENDED_BUFFER_SIZE, switch_safe_free, SWITCH_SPEECH_FLAG_BLOCKING, SWITCH_SPEECH_FLAG_NONE, SWITCH_SPEECH_FLAG_PAUSE, SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_MEMERR, SWITCH_STATUS_SUCCESS, switch_test_flag, switch_yield, switch_frame::timestamp, and switch_input_args_t::user_data.

Referenced by switch_ivr_speak_text().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        short abuf[SWITCH_RECOMMENDED_BUFFER_SIZE];
        switch_dtmf_t dtmf = { 0 };
        uint32_t len = 0;
        switch_size_t ilen = 0;
        switch_frame_t write_frame = { 0 };
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_NONE;
        switch_size_t extra = 0;
        char *tmp = NULL;
        const char *star, *pound, *p;
        switch_size_t starlen, poundlen;

        if (!sh) {
                return SWITCH_STATUS_FALSE;
        }

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

        if (!switch_core_codec_ready(codec)) {
                return SWITCH_STATUS_FALSE;
        }

        arg_recursion_check_start(args);

        write_frame.data = abuf;
        write_frame.buflen = sizeof(abuf);

        len = sh->samples * 2 * sh->channels;

        flags = 0;

        if (!(star = switch_channel_get_variable(channel, "star_replace"))) {
                star = "star";
        }
        if (!(pound = switch_channel_get_variable(channel, "pound_replace"))) {
                pound = "pound";
        }
        starlen = strlen(star);
        poundlen = strlen(pound);


        for (p = text; p && *p; p++) {
                if (*p == '*') {
                        extra += starlen;
                } else if (*p == '#') {
                        extra += poundlen;
                }
        }

        if (extra) {
                char *tp;
                switch_size_t mylen = strlen(text) + extra + 1;
                tmp = malloc(mylen);
                if (!tmp) {
                        arg_recursion_check_stop(args);
                        return SWITCH_STATUS_MEMERR;
                }
                memset(tmp, 0, mylen);
                tp = tmp;
                for (p = text; p && *p; p++) {
                        if (*p == '*' ) {
                                snprintf(tp + strlen(tp), sizeof(tp) - strlen(tp), "%s", star);
                                tp += starlen;
                        } else if (*p == '#') {
                                snprintf(tp + strlen(tp), sizeof(tp) - strlen(tp), "%s", pound);
                                tp += poundlen;
                        } else {
                                *tp++ = *p;
                        }
                }

                text = tmp;
        }

        switch_core_speech_feed_tts(sh, text, &flags);
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Speaking text: %s\n", text);
        switch_safe_free(tmp);
        text = NULL;

        write_frame.rate = sh->rate;
        memset(write_frame.data, 0, len);
        write_frame.datalen = len;
        write_frame.samples = len / 2;
        write_frame.codec = codec;

        switch_assert(codec->implementation != NULL);

        switch_channel_audio_sync(channel);


        for (;;) {
                switch_event_t *event;

                ilen = 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 (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 (!args->input_callback && !args->buf && !args->dmachine) {
                                        status = SWITCH_STATUS_BREAK;
                                        break;
                                }
                                if (args->buf && !strcasecmp(args->buf, "_break_")) {
                                        status = SWITCH_STATUS_BREAK;
                                } else {
                                        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) {
                                if (switch_core_session_dequeue_event(session, &event, SWITCH_FALSE) == SWITCH_STATUS_SUCCESS) {
                                        switch_status_t ostatus = args->input_callback(session, event, SWITCH_INPUT_TYPE_EVENT, args->buf, args->buflen);
                                        if (ostatus != SWITCH_STATUS_SUCCESS) {
                                                status = ostatus;
                                        }
                                        switch_event_destroy(&event);
                                }
                        }

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

                if (switch_test_flag(sh, SWITCH_SPEECH_FLAG_PAUSE)) {
                        if (timer) {
                                if (switch_core_timer_next(timer) != SWITCH_STATUS_SUCCESS) {
                                        break;
                                }
                        } else {
                                switch_frame_t *read_frame;
                                switch_status_t tstatus = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);

                                while (switch_channel_ready(channel) && switch_channel_test_flag(channel, CF_HOLD)) {
                                        switch_ivr_parse_all_messages(session);
                                        switch_yield(10000);
                                }

                                if (!SWITCH_READ_ACCEPTABLE(tstatus)) {
                                        break;
                                }

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

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


                flags = SWITCH_SPEECH_FLAG_BLOCKING;
                status = switch_core_speech_read_tts(sh, abuf, &ilen, &flags);

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

                write_frame.datalen = (uint32_t) ilen;
                write_frame.samples = (uint32_t) (ilen / 2 / sh->channels);
                if (timer) {
                        write_frame.timestamp = timer->samplecount;
                }
                if (switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0) != SWITCH_STATUS_SUCCESS) {
                        break;
                }

                if (timer) {
                        if (switch_core_timer_next(timer) != SWITCH_STATUS_SUCCESS) {
                                break;
                        }
                } else {                                /* time off the channel (if you must) */
                        switch_frame_t *read_frame;
                        switch_status_t tstatus = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);

                        while (switch_channel_ready(channel) && switch_channel_test_flag(channel, CF_HOLD)) {
                                switch_ivr_parse_all_messages(session);
                                switch_yield(10000);
                        }

                        if (!SWITCH_READ_ACCEPTABLE(tstatus)) {
                                break;
                        }

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

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

 done:

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "done speaking text\n");
        flags = 0;
        switch_core_speech_flush_tts(sh);

        arg_recursion_check_stop(args);
        return status;
}

switch_ivr_stop_detect_speech()

switch_status_t switch_ivr_stop_detect_speech

(

switch_core_session_t *

session

)

Stop background Speech detection on a session.

Parameters

session

The session to stop detection on

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 5229 of file switch_ivr_async.c.

References speech_thread_handle::bug, speech_on_dtmf(), switch_assert, switch_channel_get_private(), switch_channel_set_private(), switch_core_media_bug_remove(), switch_core_session_get_channel(), SWITCH_SPEECH_KEY, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by CoreSession::detectSpeech(), switch_ivr_detect_speech(), switch_ivr_detect_speech_disable_all_grammars(), switch_ivr_detect_speech_disable_grammar(), switch_ivr_detect_speech_enable_grammar(), switch_ivr_detect_speech_init(), switch_ivr_detect_speech_load_grammar(), switch_ivr_detect_speech_unload_grammar(), and switch_ivr_play_and_detect_speech().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        struct speech_thread_handle *sth;

        switch_assert(channel != NULL);
        if ((sth = switch_channel_get_private(channel, SWITCH_SPEECH_KEY))) {
                switch_channel_set_private(channel, SWITCH_SPEECH_KEY, NULL);
                switch_core_event_hook_remove_recv_dtmf(session, speech_on_dtmf);
                switch_core_media_bug_remove(session, &sth->bug);
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;
}

switch_ivr_stop_displace_session()

switch_status_t switch_ivr_stop_displace_session	(	switch_core_session_t *	session,
		const char *	file
	)

Stop displacing a session.

Parameters

session	the session
file	file name from the switch_ivr_displace_session call

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 987 of file switch_ivr_async.c.

References switch_channel_get_private(), switch_channel_set_private(), switch_core_media_bug_remove(), switch_core_session_get_channel(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_media_bug_t *bug;
        switch_channel_t *channel = switch_core_session_get_channel(session);

        if ((bug = switch_channel_get_private(channel, file))) {
                switch_channel_set_private(channel, file, NULL);
                switch_core_media_bug_remove(session, &bug);
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;
}

switch_ivr_stop_inband_dtmf_generate_session()

switch_status_t switch_ivr_stop_inband_dtmf_generate_session

(

switch_core_session_t *

session

)

Stop generating DTMF inband.

Parameters

session

the session to stop generating

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 4075 of file switch_ivr_async.c.

References switch_channel_get_private(), switch_channel_set_private(), switch_core_media_bug_remove(), switch_core_session_get_channel(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_media_bug_t *bug = switch_channel_get_private(channel, "dtmf_generate");

        if (bug) {
                switch_channel_set_private(channel, "dtmf_generate", NULL);
                switch_core_media_bug_remove(session, &bug);
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;

}

switch_ivr_stop_inband_dtmf_session()

switch_status_t switch_ivr_stop_inband_dtmf_session

(

switch_core_session_t *

session

)

Stop looking for DTMF inband.

Parameters

session

the session to stop looking

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 3841 of file switch_ivr_async.c.

References switch_channel_get_private(), switch_channel_set_private(), switch_core_media_bug_remove(), switch_core_session_get_channel(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_media_bug_t *bug;
        switch_channel_t *channel = switch_core_session_get_channel(session);

        if ((bug = switch_channel_get_private(channel, "dtmf"))) {
                switch_channel_set_private(channel, "dtmf", NULL);
                switch_core_media_bug_remove(session, &bug);
                return SWITCH_STATUS_SUCCESS;
        }
        return SWITCH_STATUS_FALSE;
}

switch_ivr_stop_record_session()

switch_status_t switch_ivr_stop_record_session	(	switch_core_session_t *	session,
		const char *	file
	)

Stop Recording a session.

Parameters

session	the session to stop recording
file	the path to the file

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 1920 of file switch_ivr_async.c.

References record_helper::bug, record_callback(), switch_channel_get_private(), switch_core_media_bug_remove(), switch_core_media_bug_remove_callback(), switch_core_session_get_channel(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_ivr_record_session_event().

{
        switch_media_bug_t *bug;
        switch_channel_t *channel = switch_core_session_get_channel(session);

        if (!strcasecmp(file, "all")) {
                return switch_core_media_bug_remove_callback(session, record_callback);
        } else if ((bug = switch_channel_get_private(channel, file))) {
                switch_core_media_bug_remove(session, &bug);
                return SWITCH_STATUS_SUCCESS;
        }
        return SWITCH_STATUS_FALSE;
}

switch_ivr_stop_session_audio()

switch_status_t switch_ivr_stop_session_audio

(

switch_core_session_t *

session

)

Definition at line 3714 of file switch_ivr_async.c.

References switch_channel_get_private(), switch_channel_set_private(), switch_core_media_bug_remove(), switch_core_session_get_channel(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_media_bug_t *bug;
        switch_channel_t *channel = switch_core_session_get_channel(session);

        if ((bug = switch_channel_get_private(channel, "__audio"))) {
                switch_channel_set_private(channel, "__audio", NULL);
                switch_core_media_bug_remove(session, &bug);
                return SWITCH_STATUS_SUCCESS;
        }
        return SWITCH_STATUS_FALSE;
}

switch_ivr_stop_tone_detect_session()

switch_status_t switch_ivr_stop_tone_detect_session

(

switch_core_session_t *

session

)

Stop looking for TONES.

Parameters

session

the session to stop looking

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 4307 of file switch_ivr_async.c.

References switch_tone_container_t::bug, switch_tone_container_t::detect_fax, switch_tone_container_t::index, switch_tone_container_t::list, switch_channel_get_private(), switch_channel_set_private(), switch_core_media_bug_remove(), switch_core_session_get_channel(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_tone_detect_t::up.

Referenced by switch_ivr_originate().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_tone_container_t *cont = switch_channel_get_private(channel, "_tone_detect_");
        int i = 0;

        if (cont) {
                switch_channel_set_private(channel, "_tone_detect_", NULL);
                for (i = 0; i < cont->index; i++) {
                        cont->list[i].up = 0;
                }
                switch_core_media_bug_remove(session, &cont->bug);
                if (cont->detect_fax) {
                        cont->detect_fax = 0;
                }
                return SWITCH_STATUS_SUCCESS;
        }
        return SWITCH_STATUS_FALSE;
}

switch_ivr_tone_detect_session()

switch_status_t switch_ivr_tone_detect_session	(	switch_core_session_t *	session,
		const char *	key,
		const char *	tone_spec,
		const char *	flags,
		time_t	timeout,
		int	hits,
		const char *	app,
		const char *	data,
		switch_tone_detect_callback_t	callback
	)

Start looking for TONES.

Parameters

session	the session to start looking
key	the name of the tone.
tone_spec	comma sep list of tone freqs
flags	one or both of 'r' and 'w'
timeout	timeout
app	optional application to execute when tone is found
data	optional data for appliaction

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 4327 of file switch_ivr_async.c.

References switch_codec_implementation::actual_samples_per_second, switch_tone_detect_t::app, switch_tone_container_t::bug, switch_tone_container_t::bug_running, switch_ivr_dmachine_binding::callback, switch_tone_detect_t::callback, switch_tone_detect_t::data, switch_tone_detect_t::default_expires, switch_tone_detect_t::default_sleep, switch_tone_container_t::detect_fax, switch_tone_detect_t::expires, teletone_tone_map_t::freqs, switch_tone_detect_t::hits, switch_tone_container_t::index, switch_tone_detect_t::key, switch_tone_container_t::list, switch_tone_detect_t::map, MAX_TONES, memset(), switch_tone_detect_t::mt, switch_ivr_dmachine_binding::next, switch_tone_detect_t::once, teletone_multi_tone_t::sample_rate, switch_tone_container_t::session, switch_tone_detect_t::sleep, SMBF_NO_PAUSE, SMBF_READ_REPLACE, SMBF_WRITE_REPLACE, switch_tone_detect_t::start_time, switch_channel_get_name(), switch_channel_get_private(), switch_channel_get_variable, switch_channel_pre_answer, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_private(), switch_core_media_bug_add(), switch_core_session_alloc, switch_core_session_get_channel(), switch_core_session_get_read_impl(), switch_core_session_strdup, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_micro_time_now(), SWITCH_STATUS_FALSE, SWITCH_STATUS_MEMERR, SWITCH_STATUS_SUCCESS, teletone_multi_tone_init(), tone_detect_callback(), tone_on_dtmf(), switch_tone_detect_t::total_hits, switch_tone_detect_t::up, and zstr.

Referenced by check_channel_status().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_status_t status;
        switch_tone_container_t *cont = switch_channel_get_private(channel, "_tone_detect_");
        char *p, *next;
        int i = 0, ok = 0, detect_fax = 0;
        switch_media_bug_flag_t bflags = 0;
        const char *var;
        switch_codec_implementation_t read_impl = { 0 };
        switch_core_session_get_read_impl(session, &read_impl);


        if (zstr(key)) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "No Key Specified!\n");
                return SWITCH_STATUS_FALSE;
        }

        if (cont) {
                if (cont->index >= MAX_TONES) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Max Tones Reached!\n");
                        return SWITCH_STATUS_FALSE;
                }

                for (i = 0; i < cont->index; i++) {
                        if (!zstr(cont->list[i].key) && !strcasecmp(key, cont->list[i].key)) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Re-enabling %s\n", key);
                                cont->list[i].up = 1;
                                cont->list[i].hits = 0;
                                cont->list[i].sleep = 0;
                                cont->list[i].expires = 0;
                                return SWITCH_STATUS_SUCCESS;
                        }
                }
        }

        if (zstr(tone_spec)) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "No Spec Specified!\n");
                return SWITCH_STATUS_FALSE;
        }

        if (!cont && !(cont = switch_core_session_alloc(session, sizeof(*cont)))) {
                return SWITCH_STATUS_MEMERR;
        }

        if ((var = switch_channel_get_variable(channel, "tone_detect_hits"))) {
                int tmp = atoi(var);
                if (tmp > 0) {
                        hits = tmp;
                }
        }

        if (!hits) hits = 1;

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Adding tone spec %s index %d hits %d\n", tone_spec, cont->index, hits);

        i = 0;
        p = (char *) tone_spec;

        do {
                teletone_process_t this;
                next = strchr(p, ',');
                while (*p == ' ')
                        p++;
                if ((this = (teletone_process_t) atof(p))) {
                        ok++;
                        cont->list[cont->index].map.freqs[i++] = this;
                }
                if (!strncasecmp(p, "1100", 4)) {
                        detect_fax = cont->index;
                }

                if (next) {
                        p = next + 1;
                }
        } while (next);
        cont->list[cont->index].map.freqs[i++] = 0;

        if (!ok) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid tone spec!\n");
                return SWITCH_STATUS_FALSE;
        }

        cont->detect_fax = detect_fax;

        cont->list[cont->index].key = switch_core_session_strdup(session, key);

        if (app) {
                cont->list[cont->index].app = switch_core_session_strdup(session, app);
        }

        if (data) {
                cont->list[cont->index].data = switch_core_session_strdup(session, data);
        }

        cont->list[cont->index].callback = callback;
        cont->list[cont->index].hits = 0;
        cont->list[cont->index].total_hits = hits;
        cont->list[cont->index].start_time = switch_micro_time_now();

        cont->list[cont->index].up = 1;
        memset(&cont->list[cont->index].mt, 0, sizeof(cont->list[cont->index].mt));
        cont->list[cont->index].mt.sample_rate = read_impl.actual_samples_per_second;
        teletone_multi_tone_init(&cont->list[cont->index].mt, &cont->list[cont->index].map);
        cont->session = session;

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

        cont->list[cont->index].default_sleep = 25;
        cont->list[cont->index].default_expires = 250;

        if ((var = switch_channel_get_variable(channel, "tone_detect_sleep"))) {
                int tmp = atoi(var);
                if (tmp > 0) {
                        cont->list[cont->index].default_sleep = tmp;
                }
        }

        if ((var = switch_channel_get_variable(channel, "tone_detect_expires"))) {
                int tmp = atoi(var);
                if (tmp > 0) {
                        cont->list[cont->index].default_expires = tmp;
                }
        }


        if (zstr(flags)) {
                bflags = SMBF_READ_REPLACE;
        } else {
                if (strchr(flags, 'o')) {
                        cont->list[cont->index].once = 1;
                }

                if (strchr(flags, 'r')) {
                        bflags |= SMBF_READ_REPLACE;
                } else if (strchr(flags, 'w')) {
                        bflags |= SMBF_WRITE_REPLACE;
                }
        }

        bflags |= SMBF_NO_PAUSE;

        if (cont->bug_running) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s bug already running\n", switch_channel_get_name(channel));
        } else {
                cont->bug_running = 1;
                if (cont->detect_fax) {
                        switch_core_event_hook_add_send_dtmf(session, tone_on_dtmf);
                        switch_core_event_hook_add_recv_dtmf(session, tone_on_dtmf);
                }

                if ((status = switch_core_media_bug_add(session, "tone_detect", key,
                                                                                                tone_detect_callback, cont, timeout, bflags, &cont->bug)) != SWITCH_STATUS_SUCCESS) {
                        cont->bug_running = 0;
                        return status;
                }
                switch_channel_set_private(channel, "_tone_detect_", cont);
        }

        cont->index++;

        return SWITCH_STATUS_SUCCESS;
}

switch_ivr_transfer_recordings()

switch_status_t switch_ivr_transfer_recordings	(	switch_core_session_t *	orig_session,
		switch_core_session_t *	new_session
	)

Definition at line 1951 of file switch_ivr_async.c.

References record_callback(), switch_channel_get_variable, switch_channel_set_variable, switch_channel_transfer_variable_prefix(), switch_core_media_bug_transfer_callback(), switch_core_session_get_channel(), switch_ivr_record_user_data_dup(), SWITCH_RECORD_POST_PROCESS_EXEC_API_VARIABLE, and SWITCH_RECORD_POST_PROCESS_EXEC_APP_VARIABLE.

Referenced by switch_channel_mark_hold(), and switch_ivr_originate().

{
        const char *var = NULL;
        switch_channel_t *orig_channel = switch_core_session_get_channel(orig_session);
        switch_channel_t *new_channel = switch_core_session_get_channel(new_session);

        if ((var = switch_channel_get_variable(orig_channel, SWITCH_RECORD_POST_PROCESS_EXEC_API_VARIABLE))) {
                switch_channel_set_variable(new_channel, SWITCH_RECORD_POST_PROCESS_EXEC_API_VARIABLE, var);
        }
        switch_channel_transfer_variable_prefix(orig_channel, new_channel, SWITCH_RECORD_POST_PROCESS_EXEC_APP_VARIABLE);

        return switch_core_media_bug_transfer_callback(orig_session, new_session, record_callback, switch_ivr_record_user_data_dup);
}

switch_ivr_transfer_variable()

switch_status_t switch_ivr_transfer_variable	(	switch_core_session_t *	sessa,
		switch_core_session_t *	sessb,
		char *	var
	)

Transfer variables from one session to another.

Parameters

sessa	the original session
sessb	the new session
var	the name of the variable to transfer (NULL for all)

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 2318 of file switch_ivr.c.

References switch_event::headers, switch_event_header::name, switch_event_header::next, switch_channel_get_variable, switch_channel_get_variables(), switch_channel_set_variable, switch_core_session_get_channel(), switch_event_destroy(), SWITCH_STATUS_SUCCESS, and switch_event_header::value.

{
        switch_channel_t *chana = switch_core_session_get_channel(sessa);
        switch_channel_t *chanb = switch_core_session_get_channel(sessb);
        switch_event_t *var_event;

        const char *val = NULL;
        uint8_t prefix = 0;

        if (var && *var == '~') {
                var++;
                prefix = 1;
        }

        if (var && !prefix) {
                if ((val = switch_channel_get_variable(chana, var))) {
                        switch_channel_set_variable(chanb, var, val);
                }
        } else {
                switch_event_header_t *hi;

                switch_channel_get_variables(chana, &var_event);

                for (hi = var_event->headers; hi; hi = hi->next) {
                        char *vvar = hi->name;
                        char *vval = hi->value;
                        if (vvar && vval && (!prefix || (var && !strncmp((char *) vvar, var, strlen(var))))) {
                                switch_channel_set_variable(chanb, (char *) vvar, (char *) vval);
                        }
                }

                switch_event_destroy(&var_event);
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_ivr_unhold()

switch_status_t switch_ivr_unhold

(

switch_core_session_t *

session

)

Signal the session with a protocol specific unhold message.

Parameters

session

the session to unhold

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 1603 of file switch_ivr.c.

References CCS_HELD, CF_BROADCAST, CF_HOLD, CF_SUSPEND, switch_core_session_message::from, switch_core_session_message::message_id, switch_channel_clear_flag(), switch_channel_event_set_data(), switch_channel_get_callstate(), switch_channel_get_partner_uuid(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_stop_broadcast, switch_channel_wait_for_flag(), switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_receive_message, switch_core_session_rwunlock(), SWITCH_EVENT_CHANNEL_UNHOLD, switch_event_create, switch_event_fire, SWITCH_FALSE, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_MESSAGE_INDICATE_UNHOLD, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_media_toggle_hold(), switch_ivr_check_hold(), switch_ivr_hold_toggle_uuid(), and switch_ivr_unhold_uuid().

{
        switch_core_session_message_t msg = { 0 };
        switch_channel_t *channel = switch_core_session_get_channel(session);
        const char *other_uuid;
        switch_core_session_t *b_session;
        switch_event_t *event;

        if (channel) {
                switch_channel_callstate_t callstate;

                callstate = switch_channel_get_callstate(channel);
                if (callstate != CCS_HELD) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Call is not on hold. No need to unhold.\n");
                        return SWITCH_STATUS_FALSE;
                }
        }

        msg.message_id = SWITCH_MESSAGE_INDICATE_UNHOLD;
        msg.from = __FILE__;

        switch_channel_clear_flag(channel, CF_HOLD);
        switch_channel_clear_flag(channel, CF_SUSPEND);

        switch_core_session_receive_message(session, &msg);


        if ((other_uuid = switch_channel_get_partner_uuid(channel)) && (b_session = switch_core_session_locate(other_uuid))) {
                switch_channel_t *b_channel = switch_core_session_get_channel(b_session);
                switch_channel_stop_broadcast(b_channel);
                switch_channel_wait_for_flag(b_channel, CF_BROADCAST, SWITCH_FALSE, 5000, NULL);
                switch_core_session_rwunlock(b_session);
        }


        if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_UNHOLD) == SWITCH_STATUS_SUCCESS) {
                switch_channel_event_set_data(channel, event);
                switch_event_fire(&event);
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_ivr_unhold_uuid()

switch_status_t switch_ivr_unhold_uuid

(

const char *

uuid

)

Signal the session with a protocol specific unhold message.

Parameters

uuid	the uuid of the session to hold

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 1646 of file switch_ivr.c.

References switch_core_session_locate, switch_core_session_rwunlock(), switch_ivr_unhold(), and SWITCH_STATUS_SUCCESS.

{
        switch_core_session_t *session;
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        if ((session = switch_core_session_locate(uuid))) {
                status = switch_ivr_unhold(session);
                switch_core_session_rwunlock(session);
        }

        return status;
}

switch_ivr_uuid_bridge()

switch_status_t switch_ivr_uuid_bridge	(	const char *	originator_uuid,
		const char *	originatee_uuid
	)

Bridge two existing sessions.

Parameters

originator_uuid	the uuid of the originator
originatee_uuid	the uuid of the originator

Remarks

Any custom state handlers on both channels will be deleted

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 2005 of file switch_ivr_bridge.c.

References switch_caller_profile::callee_id_name, switch_caller_profile::callee_id_number, switch_caller_profile::caller_id_name, switch_caller_profile::caller_id_number, CF_BLEG, CF_BRIDGE_ORIGINATOR, CF_DIALPLAN, CF_HOLD_ON_BRIDGE, CF_LEG_HOLDING, CF_ORIGINATING, CF_RECOVERING_BRIDGE, CF_REDIRECT, CF_TRANSFER, CF_UUID_BRIDGE_ORIGINATOR, cleanup_proxy_mode_a(), CS_CONSUME_MEDIA, CS_HIBERNATE, switch_caller_profile::destination_number, DUMP_EVENT, switch_caller_profile::pool, SWITCH_BRIDGE_CHANNEL_VARIABLE, SWITCH_BRIDGE_UUID_VARIABLE, SWITCH_CALL_DIRECTION_INBOUND, SWITCH_CALL_DIRECTION_OUTBOUND, switch_caller_profile_clone(), switch_caller_profile_event_set_data(), switch_channel_add_state_handler(), switch_channel_add_variable_var_check(), switch_channel_clear_flag(), switch_channel_clear_state_flag(), switch_channel_clear_state_handler(), switch_channel_direction(), switch_channel_down_nosig, switch_channel_flip_cid(), switch_channel_get_caller_profile(), switch_channel_get_name(), switch_channel_get_state(), switch_channel_inbound_display, switch_channel_invert_cid(), switch_channel_media_up, switch_channel_outbound_display, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_originatee_caller_profile(), switch_channel_set_originator_caller_profile(), switch_channel_set_state, switch_channel_set_state_flag(), switch_channel_set_variable, switch_channel_step_caller_profile(), switch_channel_stop_broadcast, switch_channel_test_flag(), switch_core_session_get_channel(), switch_core_session_get_uuid(), switch_core_session_locate, switch_core_session_rwunlock(), switch_core_sprintf(), switch_core_strdup, switch_epoch_time_now(), SWITCH_EVENT_CHANNEL_DATA, switch_event_create_plain(), switch_event_destroy(), SWITCH_FALSE, switch_ivr_check_hold(), SWITCH_LOG_CRIT, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_SIGNAL_BOND_VARIABLE, SWITCH_STACK_PUSH, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, SWITCH_TRANSFER_HISTORY_VARIABLE, SWITCH_TRANSFER_SOURCE_VARIABLE, SWITCH_UUID_BRIDGE, switch_caller_profile::transfer_source, and switch_caller_profile::uuid_str.

Referenced by switch_core_standard_on_reset(), switch_ivr_3p_media(), switch_ivr_intercept_session(), switch_ivr_media(), and switch_ivr_originate().

{
        switch_core_session_t *originator_session, *originatee_session, *swap_session;
        switch_channel_t *originator_channel, *originatee_channel, *swap_channel;
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_caller_profile_t *originator_cp, *originatee_cp;
        switch_channel_state_t state;

        if ((originator_session = switch_core_session_locate(originator_uuid))) {
                if ((originatee_session = switch_core_session_locate(originatee_uuid))) {
                        originator_channel = switch_core_session_get_channel(originator_session);
                        originatee_channel = switch_core_session_get_channel(originatee_session);

                        switch_ivr_check_hold(originator_session);
                        switch_ivr_check_hold(originatee_session);
        

                        if (switch_channel_test_flag(originator_channel, CF_LEG_HOLDING)) {
                                switch_channel_set_flag(originator_channel, CF_HOLD_ON_BRIDGE);
                        }

                        if (switch_channel_test_flag(originatee_channel, CF_LEG_HOLDING)) {
                                switch_channel_set_flag(originatee_channel, CF_HOLD_ON_BRIDGE);
                        }


                        if (switch_channel_direction(originator_channel) == SWITCH_CALL_DIRECTION_OUTBOUND && !switch_channel_test_flag(originator_channel, CF_DIALPLAN)) {
                                if (!switch_channel_test_flag(originator_channel, CF_RECOVERING_BRIDGE)) {
                                        switch_channel_flip_cid(originator_channel);
                                }
                                switch_channel_set_flag(originator_channel, CF_DIALPLAN);
                        }

                        if (switch_channel_down_nosig(originator_channel)) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(originator_session), SWITCH_LOG_DEBUG, "%s is hungup refusing to bridge.\n", switch_channel_get_name(originatee_channel));
                                switch_core_session_rwunlock(originator_session);
                                switch_core_session_rwunlock(originatee_session);
                                return SWITCH_STATUS_FALSE;
                        }

                        if (!switch_channel_media_up(originator_channel)) {
                                if (switch_channel_media_up(originatee_channel)) {
                                        swap_session = originator_session;
                                        originator_session = originatee_session;
                                        originatee_session = swap_session;

                                        swap_channel = originator_channel;
                                        originator_channel = originatee_channel;
                                        originatee_channel = swap_channel;
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(originatee_session), SWITCH_LOG_WARNING, "reversing order of channels so this will work!\n");
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(originator_session), SWITCH_LOG_CRIT, "Neither channel is answered, cannot bridge them.\n");
                                        switch_core_session_rwunlock(originator_session);
                                        switch_core_session_rwunlock(originatee_session);
                                        return SWITCH_STATUS_FALSE;
                                }
                        }

                        if (switch_channel_direction(originatee_channel) == SWITCH_CALL_DIRECTION_OUTBOUND && switch_channel_test_flag(originatee_channel, CF_DIALPLAN)) {
                                switch_channel_clear_flag(originatee_channel, CF_DIALPLAN);
                        }

                        cleanup_proxy_mode_a(originator_session);
                        cleanup_proxy_mode_a(originatee_session);

                        /* override transmit state for originator_channel to bridge to originatee_channel
                         * install pointer to originatee_session into originator_channel
                         * set CF_TRANSFER on both channels and change state to CS_SOFT_EXECUTE to
                         * interrupt anything they are already doing.
                         * originatee_session will fall asleep and originator_session will bridge to it
                         */

                        switch_channel_set_flag(originator_channel, CF_REDIRECT);
                        switch_channel_set_flag(originatee_channel, CF_REDIRECT);


                        switch_channel_set_variable(originator_channel, SWITCH_UUID_BRIDGE, switch_core_session_get_uuid(originatee_session));
                        switch_channel_set_variable(originator_channel, SWITCH_BRIDGE_CHANNEL_VARIABLE, switch_channel_get_name(originatee_channel));
                        switch_channel_set_variable(originator_channel, SWITCH_BRIDGE_UUID_VARIABLE, switch_core_session_get_uuid(originatee_session));
                        switch_channel_set_variable(originator_channel, SWITCH_SIGNAL_BOND_VARIABLE, switch_core_session_get_uuid(originatee_session));
                        switch_channel_set_variable(originatee_channel, SWITCH_BRIDGE_CHANNEL_VARIABLE, switch_channel_get_name(originator_channel));
                        switch_channel_set_variable(originatee_channel, SWITCH_BRIDGE_UUID_VARIABLE, switch_core_session_get_uuid(originator_session));
                        switch_channel_set_variable(originatee_channel, SWITCH_SIGNAL_BOND_VARIABLE, switch_core_session_get_uuid(originator_session));


                        originator_cp = switch_channel_get_caller_profile(originator_channel);
                        originatee_cp = switch_channel_get_caller_profile(originatee_channel);



                        if (switch_channel_outbound_display(originator_channel)) {
                                switch_channel_invert_cid(originator_channel);

                                if (switch_channel_direction(originator_channel) == SWITCH_CALL_DIRECTION_INBOUND) {
                                        switch_channel_clear_flag(originatee_channel, CF_BLEG);
                                }
                        }

                        if (switch_channel_inbound_display(originatee_channel)) {
                                switch_channel_invert_cid(originatee_channel);

                                if (switch_channel_direction(originatee_channel) == SWITCH_CALL_DIRECTION_INBOUND) {
                                        switch_channel_set_flag(originatee_channel, CF_BLEG);
                                }

                        }


                        switch_channel_set_variable(originatee_channel, "original_destination_number", originatee_cp->destination_number);
                        switch_channel_set_variable(originatee_channel, "original_caller_id_name", originatee_cp->caller_id_name);
                        switch_channel_set_variable(originatee_channel, "original_caller_id_number", originatee_cp->caller_id_number);

                        switch_channel_set_variable(originator_channel, "original_destination_number", originator_cp->destination_number);
                        switch_channel_set_variable(originator_channel, "original_caller_id_name", originator_cp->caller_id_name);
                        switch_channel_set_variable(originator_channel, "original_caller_id_number", originator_cp->caller_id_number);

                        switch_channel_step_caller_profile(originatee_channel);
                        switch_channel_step_caller_profile(originator_channel);

                        originator_cp = switch_channel_get_caller_profile(originator_channel);
                        originatee_cp = switch_channel_get_caller_profile(originatee_channel);


#ifdef DEEP_DEBUG_CID
                        {
                                switch_event_t *event;

                                if (switch_event_create_plain(&event, SWITCH_EVENT_CHANNEL_DATA) == SWITCH_STATUS_SUCCESS) {
                                        //switch_channel_event_set_basic_data(originator_channel, event);
                                        switch_caller_profile_event_set_data(originator_cp, "ORIGINATOR", event);
                                        switch_caller_profile_event_set_data(originatee_cp, "ORIGINATEE", event);
                                        DUMP_EVENT(event);
                                        switch_event_destroy(&event);
                                }
                        }
#endif

                        switch_channel_set_originator_caller_profile(originatee_channel, switch_caller_profile_clone(originatee_session, originator_cp));
                        switch_channel_set_originatee_caller_profile(originator_channel, switch_caller_profile_clone(originator_session, originatee_cp));

                        originator_cp->callee_id_name = switch_core_strdup(originator_cp->pool, originatee_cp->callee_id_name);
                        originator_cp->callee_id_number = switch_core_strdup(originator_cp->pool, originatee_cp->callee_id_number);

                        originatee_cp->caller_id_name = switch_core_strdup(originatee_cp->pool, originator_cp->caller_id_name);
                        originatee_cp->caller_id_number = switch_core_strdup(originatee_cp->pool, originator_cp->caller_id_number);

#ifdef DEEP_DEBUG_CID
                        {
                                switch_event_t *event;

                                if (switch_event_create_plain(&event, SWITCH_EVENT_CHANNEL_DATA) == SWITCH_STATUS_SUCCESS) {
                                        //switch_channel_event_set_basic_data(originator_channel, event);
                                        switch_caller_profile_event_set_data(originator_cp, "POST-ORIGINATOR", event);
                                        switch_caller_profile_event_set_data(originatee_cp, "POST-ORIGINATEE", event);
                                        DUMP_EVENT(event);
                                        switch_event_destroy(&event);
                                }
                        }
#endif

                        switch_channel_stop_broadcast(originator_channel);
                        switch_channel_stop_broadcast(originatee_channel);

                        switch_channel_set_flag(originator_channel, CF_TRANSFER);
                        switch_channel_set_flag(originatee_channel, CF_TRANSFER);


                        switch_channel_clear_flag(originator_channel, CF_ORIGINATING);
                        switch_channel_clear_flag(originatee_channel, CF_ORIGINATING);


                        originator_cp->transfer_source = switch_core_sprintf(originator_cp->pool,
                                                                                                                                 "%ld:%s:uuid_br:%s", (long)switch_epoch_time_now(NULL), originator_cp->uuid_str,
                                                                                                                                 switch_core_session_get_uuid(originatee_session));
                        switch_channel_add_variable_var_check(originator_channel, SWITCH_TRANSFER_HISTORY_VARIABLE,
                                                                                                  originator_cp->transfer_source, SWITCH_FALSE, SWITCH_STACK_PUSH);
                        switch_channel_set_variable(originator_channel, SWITCH_TRANSFER_SOURCE_VARIABLE, originator_cp->transfer_source);


                        originatee_cp->transfer_source = switch_core_sprintf(originatee_cp->pool,
                                                                                                                                 "%ld:%s:uuid_br:%s", (long)switch_epoch_time_now(NULL), originatee_cp->uuid_str,
                                                                                                                                 switch_core_session_get_uuid(originator_session));
                        switch_channel_add_variable_var_check(originatee_channel, SWITCH_TRANSFER_HISTORY_VARIABLE,
                                                                                                  originatee_cp->transfer_source, SWITCH_FALSE, SWITCH_STACK_PUSH);
                        switch_channel_set_variable(originatee_channel, SWITCH_TRANSFER_SOURCE_VARIABLE, originatee_cp->transfer_source);

                        /* change the states and let the chips fall where they may */

                        //switch_channel_set_variable(originator_channel, SWITCH_PARK_AFTER_BRIDGE_VARIABLE, NULL);
                        //switch_channel_set_variable(originatee_channel, SWITCH_PARK_AFTER_BRIDGE_VARIABLE, NULL);
                        switch_channel_clear_state_handler(originator_channel, NULL);
                        switch_channel_clear_state_handler(originatee_channel, NULL);



                        switch_channel_clear_state_flag(originator_channel, CF_BRIDGE_ORIGINATOR);
                        switch_channel_clear_state_flag(originatee_channel, CF_BRIDGE_ORIGINATOR);

                        switch_channel_clear_flag(originator_channel, CF_UUID_BRIDGE_ORIGINATOR);
                        switch_channel_clear_flag(originatee_channel, CF_UUID_BRIDGE_ORIGINATOR);
                        switch_channel_set_state_flag(originator_channel, CF_UUID_BRIDGE_ORIGINATOR);

                        switch_channel_add_state_handler(originator_channel, &uuid_bridge_state_handlers);
                        switch_channel_add_state_handler(originatee_channel, &uuid_bridge_state_handlers);

                        state = switch_channel_get_state(originator_channel);
                        switch_channel_set_state(originator_channel, state == CS_HIBERNATE ? CS_CONSUME_MEDIA : CS_HIBERNATE);
                        state = switch_channel_get_state(originatee_channel);
                        switch_channel_set_state(originatee_channel, state == CS_HIBERNATE ? CS_CONSUME_MEDIA : CS_HIBERNATE);

                        status = SWITCH_STATUS_SUCCESS;

                        //switch_ivr_bridge_display(originator_session, originatee_session);

                        /* release the read locks we have on the channels */
                        switch_core_session_rwunlock(originator_session);
                        switch_core_session_rwunlock(originatee_session);

                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(originator_session), SWITCH_LOG_DEBUG, "originatee uuid %s is not present\n", originatee_uuid);
                        switch_core_session_rwunlock(originator_session);
                }
        } else {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(originator_session), SWITCH_LOG_DEBUG, "originator uuid %s is not present\n", originator_uuid);
        }

        return status;
}

switch_ivr_wait_for_silence()

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
	)

Definition at line 2080 of file switch_ivr_play_say.c.

References switch_codec_implementation::actual_samples_per_second, switch_frame::buflen, switch_file_handle::channels, switch_frame::codec, count, switch_frame::data, switch_frame::datalen, if(), switch_codec::implementation, switch_codec_implementation::microseconds_per_packet, switch_codec_implementation::number_of_channels, switch_frame::samples, switch_codec_implementation::samples_per_packet, switch_frame::seq, switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_channel_set_variable_printf(), 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_read(), 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_write_frame(), SWITCH_FALSE, SWITCH_FILE_DATA_SHORT, SWITCH_FILE_FLAG_READ, SWITCH_IO_FLAG_NONE, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_READ_ACCEPTABLE, SWITCH_RECOMMENDED_BUFFER_SIZE, SWITCH_STATUS_FALSE, SWITCH_STATUS_NOTFOUND, SWITCH_STATUS_SUCCESS, SWITCH_TRUE, and switch_zmalloc.

{
        uint32_t score, count = 0, j = 0;
        double energy = 0;
        switch_channel_t *channel = switch_core_session_get_channel(session);
        int divisor = 0;
        uint32_t org_silence_hits = silence_hits;
        uint32_t channels;
        switch_frame_t *read_frame;
        switch_status_t status = SWITCH_STATUS_FALSE;
        int16_t *data;
        uint32_t listening = 0;
        int countdown = 0;
        switch_codec_t raw_codec = { 0 };
        int16_t *abuf = NULL;
        switch_frame_t write_frame = { 0 };
        switch_file_handle_t fh = { 0 };
        int32_t sample_count = 0;
        switch_codec_implementation_t read_impl = { 0 };
        switch_core_session_get_read_impl(session, &read_impl);


        if (timeout_ms) {
                sample_count = (read_impl.actual_samples_per_second / 1000) * timeout_ms;
        }

        if (file) {
                if (switch_core_file_open(&fh,
                                                                  file,
                                                                  read_impl.number_of_channels,
                                                                  read_impl.actual_samples_per_second, SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, NULL) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Failure opening playback file %s.\n", file);
                        switch_core_session_reset(session, SWITCH_TRUE, SWITCH_FALSE);
                        return SWITCH_STATUS_NOTFOUND;
                }
                switch_zmalloc(abuf, SWITCH_RECOMMENDED_BUFFER_SIZE);
                write_frame.data = abuf;
                write_frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE;
        }


        if (switch_core_codec_init(&raw_codec,
                                                           "L16",
                                                           NULL,
                                                           NULL,
                                                           read_impl.actual_samples_per_second,
                                                           read_impl.microseconds_per_packet / 1000,
                                                           1, 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_WARNING, "Failed to initialize L16 codec.\n");
                status = SWITCH_STATUS_FALSE;
                goto end;
        }

        write_frame.codec = &raw_codec;

        divisor = read_impl.actual_samples_per_second / 8000;
        channels = read_impl.number_of_channels;

        switch_core_session_set_read_codec(session, &raw_codec);

        while (switch_channel_ready(channel)) {

                /* reinitialize energy value per loop */
                energy = 0;

                status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);

                if (!SWITCH_READ_ACCEPTABLE(status)) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Failed to read frame.\n");
                        break;
                }

                if (sample_count) {
                        sample_count -= raw_codec.implementation->samples_per_packet;
                        if (sample_count <= 0) {
                                switch_channel_set_variable(channel, "wait_for_silence_timeout", "true");
                                switch_channel_set_variable_printf(channel, "wait_for_silence_listenhits", "%d", listening);
                                switch_channel_set_variable_printf(channel, "wait_for_silence_silence_hits", "%d", silence_hits);
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                  "switch_ivr_wait_for_silence: TIMEOUT after %d ms at %d listen hits, %d silence hits, %d countdown\n",
                                  timeout_ms, listening, (org_silence_hits - silence_hits), countdown);
                                break;
                        }
                }

                if (abuf) {
                        switch_size_t olen = raw_codec.implementation->samples_per_packet;

                        if (switch_core_file_read(&fh, abuf, &olen) != SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Failed to read file %s.\n", file);
                                break;
                        }

                        write_frame.samples = (uint32_t) olen;
                        write_frame.datalen = (uint32_t) (olen * sizeof(int16_t) * fh.channels);
                        if ((status = switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0)) != SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Failed to write frame from file %s.\n", file);
                                break;
                        }
                }

                if (countdown) {
                        if (!--countdown) {
                                switch_channel_set_variable(channel, "wait_for_silence_timeout", "false");
                                switch_channel_set_variable_printf(channel, "wait_for_silence_listenhits", "%d", listening);
                                switch_channel_set_variable_printf(channel, "wait_for_silence_silence_hits", "%d", silence_hits);
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "switch_ivr_wait_for_silence: SILENCE DETECTED\n");
                                break;
                        } else {
                                continue;
                        }
                }

                data = (int16_t *) read_frame->data;

                /* Need to check if the read_frame is valid before attempting to get "energy" value from it */
                if (read_frame->seq) {
                        for (energy = 0, j = 0, count = 0; count < read_frame->samples; count++) {
                                energy += abs(data[j++]);
                                j += channels;
                        }
                }

                score = (uint32_t) (energy / (read_frame->samples / divisor));

                if (score >= thresh) {
                        listening++;
                }

                if (((listen_hits == 0) || (listening > listen_hits)) && (score < thresh)) {
                        if (!--silence_hits) {
                                countdown = 25;
                        }
                } else {
                        silence_hits = org_silence_hits;
                }
        }

        switch_core_session_reset(session, SWITCH_FALSE, SWITCH_TRUE);
        switch_core_codec_destroy(&raw_codec);

  end:

        if (abuf) {

                switch_core_file_close(&fh);
                free(abuf);
        }

        return status;
}

switch_play_and_get_digits()

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 *	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.

Parameters

session	the current session to play sound to and collect digits
min_digits	the fewest digits allowed for the response to be valid
max_digits	the max number of digits to accept
max_tries	number of times to replay the sound and capture digits
timeout	time to wait for input (this is per iteration, so total possible time = max_tries * (timeout + audio playback length)
valid_terminators	for input that can include # or * (useful for variable length prompts)
audio_file	file to play
bad_input_audio_file	file to play if the input from the user was invalid
var_name	variable name to put results in
digit_buffer	variable digits captured will be put back into (empty if capture failed)
digit_buffer_length	length of the buffer for digits (should be the same or larger than max_digits)
digits_regex	the qualifying regex

Returns

switch status, used to note status of channel (will still return success if digit capture failed)

Note

to test for digit capture failure look for \0 in the first position of the buffer

Definition at line 2627 of file switch_ivr_play_say.c.

References memset(), switch_channel_get_variable, switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_core_session_get_channel(), switch_core_session_strdup, switch_ivr_play_file(), switch_ivr_read(), switch_ivr_session_transfer(), SWITCH_LOG_DEBUG1, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, switch_mprintf(), SWITCH_READ_TERMINATOR_USED_VARIABLE, switch_regex_match(), switch_safe_free, switch_separate_string(), SWITCH_STATUS_FALSE, SWITCH_STATUS_RESTART, SWITCH_STATUS_SUCCESS, SWITCH_STATUS_TIMEOUT, SWITCH_STATUS_TOO_SMALL, target, and zstr.

Referenced by CoreSession::playAndGetDigits(), and switch_ivr_menu_execute().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        char *var_name_invalid = NULL;

        if (!zstr(digits_regex) && !zstr(var_name)) {
                var_name_invalid = switch_mprintf("%s_invalid", var_name);
                switch_channel_set_variable(channel, var_name_invalid, NULL);
                switch_safe_free(var_name_invalid);
        }

        while (switch_channel_ready(channel) && max_tries) {
                switch_status_t status;

                memset(digit_buffer, 0, digit_buffer_length);

                status = switch_ivr_read(session, min_digits, max_digits, prompt_audio_file, var_name,
                                                                 digit_buffer, digit_buffer_length, timeout, valid_terminators, digit_timeout);

                if (status == SWITCH_STATUS_RESTART) {
                        return status;
                }

                if (status == SWITCH_STATUS_TIMEOUT && strlen(digit_buffer) >= min_digits) {
                        status = SWITCH_STATUS_SUCCESS;
                }

                if ((min_digits == 0) && (strlen(digit_buffer) == 0) && switch_channel_get_variable(channel, SWITCH_READ_TERMINATOR_USED_VARIABLE) != 0)
                {
                        return SWITCH_STATUS_SUCCESS;
                }

                if (!(status == SWITCH_STATUS_TOO_SMALL && strlen(digit_buffer) == 0)) {
                        if (status == SWITCH_STATUS_SUCCESS) {
                                if (!zstr(digit_buffer)) {
                                        if (zstr(digits_regex)) {
                                                return SWITCH_STATUS_SUCCESS;
                                        }
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG1, "Test Regex [%s][%s]\n", digit_buffer, digits_regex);

                                        if (switch_regex_match(digit_buffer, digits_regex) == SWITCH_STATUS_SUCCESS) {
                                                return SWITCH_STATUS_SUCCESS;
                                        } else {
                                                switch_channel_set_variable(channel, var_name, NULL);
                                                if (!zstr(var_name)) {
                                                        var_name_invalid = switch_mprintf("%s_invalid", var_name);
                                                        switch_channel_set_variable(channel, var_name_invalid, digit_buffer);
                                                        switch_safe_free(var_name_invalid);
                                                }
                                        }
                                }
                        }
                }

                if (!switch_channel_ready(channel)) {
                        break;
                }

                switch_ivr_play_file(session, NULL, bad_input_audio_file, NULL);
                max_tries--;
        }

        memset(digit_buffer, 0, digit_buffer_length);

        /* If we get here then check for transfer-on-failure ext/dp/context */
        /* split this arg on spaces to get ext, dp, and context */

        if (!zstr(transfer_on_failure)) {
                const char *failure_ext = NULL;
                const char *failure_dialplan = NULL;
                const char *failure_context = NULL;
                char *target[4];
                char *mydata = switch_core_session_strdup(session, transfer_on_failure);
                int argc;

                argc = switch_separate_string(mydata, ' ', target, (sizeof(target) / sizeof(target[0])));

                if ( argc < 1 ) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,"Bad target for PAGD failure: [%s]\n", transfer_on_failure);
                        return SWITCH_STATUS_FALSE;
                }

                if ( argc > 0 ) {
                        failure_ext = target[0];
                }

                if ( argc > 1 ) {
                        failure_dialplan = target[1];
                }

                if ( argc > 2 ) {
                        failure_context = target[2];
                }

                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
                        "PAGD failure! Transfer to: %s / %s / %s\n", failure_ext, failure_dialplan, failure_context);

                switch_ivr_session_transfer(session,failure_ext, failure_dialplan, failure_context);
                return SWITCH_STATUS_FALSE;
        }

        return SWITCH_STATUS_FALSE;
}