#include <switch.h>
#include "private/switch_core_pvt.h"
#include <speex/speex_preprocess.h>
#include <speex/speex_echo.h>

Include dependency graph for switch_ivr_async.c:

Go to the source code of this file.

Data Structures
struct	switch_ivr_dmachine_binding

struct	dm_binding_head_t

struct	switch_ivr_dmachine

struct	displace_helper_t

struct	record_helper

struct	eavesdrop_pvt

struct	exec_cb_data

struct	pp_cb_t

struct	switch_session_audio_t

struct	switch_inband_dtmf_t

struct	switch_inband_dtmf_generate_t

struct	switch_tone_detect_t

struct	switch_tone_container_t

struct	dtmf_meta_app_t

struct	dtmf_meta_settings_t

struct	dtmf_meta_data_t

struct	bch_t

struct	play_and_detect_speech_state_t

struct	speech_thread_handle

struct	hangup_helper

struct	transfer_helper

struct	broadcast_helper

struct	oht_s

Macros
#define	MAX_TONES 16

#define	SWITCH_META_VAR_KEY "__dtmf_meta"

#define	SWITCH_BLOCK_DTMF_KEY "__dtmf_block"

#define	PLAY_AND_DETECT_DONE 1

#define	PLAY_AND_DETECT_DONE_RECOGNIZING 2

Typedefs
typedef struct switch_ivr_dmachine_binding	switch_ivr_dmachine_binding_t

typedef struct oht_s	overly_helper_t

Enumerations
enum	dm_match_t { DM_MATCH_NONE, DM_MATCH_EXACT, DM_MATCH_PARTIAL, DM_MATCH_BOTH, DM_MATCH_NEVER }

Functions
switch_status_t	switch_ivr_dmachine_last_ping (switch_ivr_dmachine_t *dmachine)

switch_digit_action_target_t	switch_ivr_dmachine_get_target (switch_ivr_dmachine_t *dmachine)

void	switch_ivr_dmachine_set_target (switch_ivr_dmachine_t *dmachine, switch_digit_action_target_t target)

void	switch_ivr_dmachine_set_match_callback (switch_ivr_dmachine_t *dmachine, switch_ivr_dmachine_callback_t match_callback)

void	switch_ivr_dmachine_set_nonmatch_callback (switch_ivr_dmachine_t *dmachine, switch_ivr_dmachine_callback_t nonmatch_callback)

const char *	switch_ivr_dmachine_get_name (switch_ivr_dmachine_t *dmachine)

switch_status_t	switch_ivr_dmachine_create (switch_ivr_dmachine_t *dmachine_p, const char name, switch_memory_pool_t pool, uint32_t digit_timeout_ms, uint32_t input_timeout_ms, switch_ivr_dmachine_callback_t match_callback, switch_ivr_dmachine_callback_t nonmatch_callback, void user_data)

void	switch_ivr_dmachine_set_digit_timeout_ms (switch_ivr_dmachine_t *dmachine, uint32_t digit_timeout_ms)

void	switch_ivr_dmachine_set_input_timeout_ms (switch_ivr_dmachine_t *dmachine, uint32_t input_timeout_ms)

void	switch_ivr_dmachine_destroy (switch_ivr_dmachine_t **dmachine)

switch_status_t	switch_ivr_dmachine_set_terminators (switch_ivr_dmachine_t dmachine, const char terminators)

switch_status_t	switch_ivr_dmachine_set_realm (switch_ivr_dmachine_t dmachine, const char realm)

switch_status_t	switch_ivr_dmachine_clear_realm (switch_ivr_dmachine_t dmachine, const char realm)

switch_status_t	switch_ivr_dmachine_bind (switch_ivr_dmachine_t dmachine, const char realm, const char digits, int32_t key, switch_ivr_dmachine_callback_t callback, void user_data)

static dm_match_t	switch_ivr_dmachine_check_match (switch_ivr_dmachine_t *dmachine, switch_bool_t is_timeout)

static switch_bool_t	switch_ivr_dmachine_check_timeout (switch_ivr_dmachine_t *dmachine)

switch_ivr_dmachine_match_t *	switch_ivr_dmachine_get_match (switch_ivr_dmachine_t *dmachine)

const char *	switch_ivr_dmachine_get_failed_digits (switch_ivr_dmachine_t *dmachine)

switch_status_t	switch_ivr_dmachine_ping (switch_ivr_dmachine_t dmachine, switch_ivr_dmachine_match_t *match_p)

switch_status_t	switch_ivr_dmachine_feed (switch_ivr_dmachine_t dmachine, const char digits, switch_ivr_dmachine_match_t **match)

switch_bool_t	switch_ivr_dmachine_is_parsing (switch_ivr_dmachine_t *dmachine)

switch_status_t	switch_ivr_dmachine_clear (switch_ivr_dmachine_t *dmachine)

switch_status_t	switch_ivr_session_echo (switch_core_session_t session, switch_input_args_t args)
	NEEDDESC - More...

static switch_bool_t	write_displace_callback (switch_media_bug_t bug, void user_data, switch_abc_type_t type)

static switch_bool_t	read_displace_callback (switch_media_bug_t bug, void user_data, switch_abc_type_t type)

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_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...

static void	set_completion_cause (struct record_helper rh, const char completion_cause)

static switch_bool_t	is_silence_frame (switch_frame_t frame, int silence_threshold, switch_codec_implementation_t codec_impl)

static void	send_record_stop_event (switch_channel_t channel, switch_codec_implementation_t read_impl, struct record_helper *rh)

static void *SWITCH_THREAD_FUNC	recording_thread (switch_thread_t thread, void obj)

static switch_bool_t	record_callback (switch_media_bug_t bug, void user_data, switch_abc_type_t type)

switch_status_t	switch_ivr_record_session_mask (switch_core_session_t session, const char file, switch_bool_t on)

switch_status_t	switch_ivr_stop_record_session (switch_core_session_t session, const char file)
	Stop Recording a session. More...

static void *	switch_ivr_record_user_data_dup (switch_core_session_t session, void user_data)

switch_status_t	switch_ivr_transfer_recordings (switch_core_session_t orig_session, switch_core_session_t new_session)

static switch_status_t	video_eavesdrop_callback (switch_core_session_t session, switch_frame_t frame, void *user_data)

static switch_bool_t	eavesdrop_callback (switch_media_bug_t bug, void user_data, switch_abc_type_t type)

switch_status_t	switch_ivr_eavesdrop_pop_eavesdropper (switch_core_session_t session, switch_core_session_t *sessionp)

static void	exec_cb (switch_media_bug_t bug, void user_data)

static void	display_exec_cb (switch_media_bug_t bug, void user_data)

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_record_session (switch_core_session_t session, char file, uint32_t limit, switch_file_handle_t *fh)
	Record a session to disk. More...

static switch_bool_t	preprocess_callback (switch_media_bug_t bug, void user_data, switch_abc_type_t type)

switch_status_t	switch_ivr_preprocess_session (switch_core_session_t session, const char cmds)

static switch_bool_t	session_audio_callback (switch_media_bug_t bug, void user_data, switch_abc_type_t type)

switch_status_t	switch_ivr_stop_session_audio (switch_core_session_t *session)

switch_status_t	switch_ivr_session_audio (switch_core_session_t session, const char cmd, const char *direction, int level)

static switch_bool_t	inband_dtmf_callback (switch_media_bug_t bug, void user_data, switch_abc_type_t type)

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_session (switch_core_session_t *session)
	Start looking for DTMF inband. More...

static int	teletone_dtmf_generate_handler (teletone_generation_session_t ts, teletone_tone_map_t map)

static switch_status_t	generate_on_dtmf (switch_core_session_t session, const switch_dtmf_t dtmf, switch_dtmf_direction_t direction)

static switch_bool_t	inband_dtmf_generate_callback (switch_media_bug_t bug, void user_data, switch_abc_type_t type)

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_inband_dtmf_generate_session (switch_core_session_t *session, switch_bool_t read_stream)
	Start generating DTMF inband. More...

static void	tone_detect_set_total_time (switch_tone_container_t *cont, int index)

static switch_status_t	tone_on_dtmf (switch_core_session_t session, const switch_dtmf_t dtmf, switch_dtmf_direction_t direction)

static switch_bool_t	tone_detect_callback (switch_media_bug_t bug, void user_data, switch_abc_type_t type)

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...

static void *SWITCH_THREAD_FUNC	bcast_thread (switch_thread_t thread, void obj)

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

static switch_status_t	meta_on_dtmf (switch_core_session_t session, const switch_dtmf_t dtmf, switch_dtmf_direction_t direction)

switch_status_t	switch_ivr_unbind_dtmf_meta_session (switch_core_session_t *session, uint32_t key)

static switch_status_t	block_on_dtmf (switch_core_session_t session, const switch_dtmf_t dtmf, switch_dtmf_direction_t direction)

switch_status_t	switch_ivr_unblock_dtmf_session (switch_core_session_t *session)

switch_status_t	switch_ivr_block_dtmf_session (switch_core_session_t *session)

switch_status_t	switch_ivr_bind_dtmf_meta_session (switch_core_session_t session, uint32_t key, switch_bind_flag_t bind_flags, const char app)

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

switch_status_t	switch_ivr_play_and_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...

static void *SWITCH_THREAD_FUNC	speech_thread (switch_thread_t thread, void obj)

static switch_bool_t	speech_callback (switch_media_bug_t bug, void user_data, switch_abc_type_t type)

static switch_status_t	speech_on_dtmf (switch_core_session_t session, const switch_dtmf_t dtmf, switch_dtmf_direction_t direction)

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_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_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_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_STANDARD_SCHED_FUNC (sch_hangup_callback)

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_STANDARD_SCHED_FUNC (sch_transfer_callback)

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...

	SWITCH_STANDARD_SCHED_FUNC (sch_broadcast_callback)

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...

static switch_bool_t	video_write_overlay_callback (switch_media_bug_t bug, void user_data, switch_abc_type_t type)

switch_status_t	switch_ivr_stop_video_write_overlay_session (switch_core_session_t *session)

switch_status_t	switch_ivr_video_write_overlay_session (switch_core_session_t session, const char img_path, switch_img_position_t pos, uint8_t alpha)

Macro Definition Documentation

#define MAX_TONES 16

Definition at line 3499 of file switch_ivr_async.c.

Referenced by switch_ivr_tone_detect_session().

#define PLAY_AND_DETECT_DONE 1

Definition at line 4182 of file switch_ivr_async.c.

Referenced by play_and_detect_input_callback(), and switch_ivr_play_and_detect_speech().

#define PLAY_AND_DETECT_DONE_RECOGNIZING 2

Definition at line 4183 of file switch_ivr_async.c.

Referenced by play_and_detect_input_callback(), and switch_ivr_play_and_detect_speech().

#define SWITCH_BLOCK_DTMF_KEY "__dtmf_block"

Definition at line 3896 of file switch_ivr_async.c.

Referenced by block_on_dtmf(), switch_ivr_block_dtmf_session(), and switch_ivr_unblock_dtmf_session().

#define SWITCH_META_VAR_KEY "__dtmf_meta"

Definition at line 3895 of file switch_ivr_async.c.

Referenced by meta_on_dtmf(), switch_ivr_bind_dtmf_meta_session(), and switch_ivr_unbind_dtmf_meta_session().

Typedef Documentation

typedef struct oht_s overly_helper_t

typedef struct switch_ivr_dmachine_binding switch_ivr_dmachine_binding_t

Definition at line 50 of file switch_ivr_async.c.

Enumeration Type Documentation

enum dm_match_t

Enumerator
DM_MATCH_NONE
DM_MATCH_EXACT
DM_MATCH_PARTIAL
DM_MATCH_BOTH
DM_MATCH_NEVER

Definition at line 330 of file switch_ivr_async.c.

              {
         DM_MATCH_NONE,
         DM_MATCH_EXACT,
         DM_MATCH_PARTIAL,
         DM_MATCH_BOTH,
         DM_MATCH_NEVER
 } dm_match_t;

Function Documentation

static void* SWITCH_THREAD_FUNC bcast_thread	(	switch_thread_t *	thread,
		void *	obj
	)

static

Definition at line 3904 of file switch_ivr_async.c.

References bch_t::app, bch_t::flags, bch_t::session, switch_core_session_get_uuid(), switch_core_session_read_lock(), switch_core_session_rwunlock(), and switch_ivr_broadcast().

Referenced by switch_ivr_broadcast_in_thread().

 {
         bch_t *bch = (bch_t *) obj;
 
         if (!bch->session) {
                 return NULL;
         }
 
         switch_core_session_read_lock(bch->session);
         switch_ivr_broadcast(switch_core_session_get_uuid(bch->session), bch->app, bch->flags);
         switch_core_session_rwunlock(bch->session);
 
         return NULL;
 
 }

static switch_status_t block_on_dtmf	(	switch_core_session_t *	session,
		const switch_dtmf_t *	dtmf,
		switch_dtmf_direction_t	direction
	)

static

Definition at line 4072 of file switch_ivr_async.c.

References CF_INNER_BRIDGE, SWITCH_BLOCK_DTMF_KEY, switch_channel_get_private(), switch_channel_test_flag(), switch_core_session_get_channel(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_ivr_block_dtmf_session().

 {
         switch_channel_t *channel = switch_core_session_get_channel(session);
         uint8_t enabled = (uint8_t)(intptr_t)switch_channel_get_private(channel, SWITCH_BLOCK_DTMF_KEY);
 
         if (!enabled || switch_channel_test_flag(channel, CF_INNER_BRIDGE)) {
                 return SWITCH_STATUS_SUCCESS;
         }
 
         return SWITCH_STATUS_FALSE;
 }

static void display_exec_cb	(	switch_media_bug_t *	bug,
		void *	user_data
	)

static

Definition at line 1815 of file switch_ivr_async.c.

References exec_cb_data::caller, eavesdrop_pvt::eavesdropper, ep, switch_core_session_message::from, switch_core_session_message::message_id, switch_core_session_message::string_array_arg, switch_core_media_bug_get_user_data(), switch_core_session_receive_message, SWITCH_MESSAGE_INDICATE_DISPLAY, exec_cb_data::val, and exec_cb_data::var.

Referenced by switch_ivr_eavesdrop_update_display().

 {
         struct exec_cb_data *data = (struct exec_cb_data *) user_data;
         struct eavesdrop_pvt *ep = (struct eavesdrop_pvt *) switch_core_media_bug_get_user_data(bug);
 
         if (ep && ep->eavesdropper && ep->eavesdropper != data->caller) {
                 switch_core_session_message_t msg = { 0 };
 
                 msg.from = __FILE__;
                 msg.message_id = SWITCH_MESSAGE_INDICATE_DISPLAY;
                 msg.string_array_arg[0] = data->var;
                 msg.string_array_arg[1] = data->val;
                 
                 switch_core_session_receive_message(ep->eavesdropper, &msg);            
         }
 }

static switch_bool_t eavesdrop_callback	(	switch_media_bug_t *	bug,
		void *	user_data,
		switch_abc_type_t	type
	)

static

Definition at line 1620 of file switch_ivr_async.c.

Referenced by switch_ivr_eavesdrop_session().

 {
         struct eavesdrop_pvt *ep = (struct eavesdrop_pvt *) user_data;
         uint8_t data[SWITCH_RECOMMENDED_BUFFER_SIZE];
         switch_frame_t frame = { 0 };
         switch_core_session_t *session = switch_core_media_bug_get_session(bug);
         switch_channel_t *e_channel = switch_core_session_get_channel(ep->eavesdropper);
         int show_spy = 0;
 
         frame.data = data;
         frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE;
 
         show_spy = switch_core_media_bug_test_flag(bug, SMBF_SPY_VIDEO_STREAM) || switch_core_media_bug_test_flag(bug, SMBF_SPY_VIDEO_STREAM_BLEG);
 
         if (show_spy) {
                 if (!ep->set_decoded_read) {
                         ep->set_decoded_read = 1;
                         switch_channel_set_flag_recursive(e_channel, CF_VIDEO_DECODED_READ);
                         switch_core_session_request_video_refresh(ep->eavesdropper);
                 }
         } else {
                 if (ep->set_decoded_read) {
                         ep->set_decoded_read = 0;
                         switch_channel_clear_flag_recursive(e_channel, CF_VIDEO_DECODED_READ);
                         switch_core_session_request_video_refresh(ep->eavesdropper);
                 }
         }
 
         switch (type) {
         case SWITCH_ABC_TYPE_INIT:
 
                 if (switch_core_media_bug_test_flag(bug, SMBF_READ_VIDEO_STREAM) || 
                         switch_core_media_bug_test_flag(bug, SMBF_WRITE_VIDEO_STREAM) || 
                         switch_core_media_bug_test_flag(bug, SMBF_READ_VIDEO_PING)) {
                         switch_core_session_set_video_read_callback(ep->eavesdropper, video_eavesdrop_callback, (void *)bug);
                         switch_channel_set_flag_recursive(switch_core_session_get_channel(session), CF_VIDEO_DECODED_READ);
                 }
                 break;
         case SWITCH_ABC_TYPE_CLOSE:
                 if (ep->set_decoded_read) {
                         switch_channel_clear_flag_recursive(e_channel, CF_VIDEO_DECODED_READ);
                 }
 
                 if (switch_core_media_bug_test_flag(bug, SMBF_READ_VIDEO_STREAM) || 
                         switch_core_media_bug_test_flag(bug, SMBF_WRITE_VIDEO_STREAM) || 
                         switch_core_media_bug_test_flag(bug, SMBF_READ_VIDEO_PING)) {
                         switch_core_session_set_video_read_callback(ep->eavesdropper, NULL, NULL);
                 }
 
                 switch_channel_clear_flag_recursive(switch_core_session_get_channel(session), CF_VIDEO_DECODED_READ);
 
                 break;
         case SWITCH_ABC_TYPE_WRITE:
                 break;
         case SWITCH_ABC_TYPE_READ_PING:
                 if (ep->buffer) {
                         if (switch_core_media_bug_read(bug, &frame, SWITCH_FALSE) != SWITCH_STATUS_FALSE) {
                                 switch_buffer_lock(ep->buffer);
                                 switch_buffer_zwrite(ep->buffer, frame.data, frame.datalen);
                                 switch_buffer_unlock(ep->buffer);
                         }
                 } else {
                         return SWITCH_FALSE;
                 }
                 break;
         case SWITCH_ABC_TYPE_READ:
                 break;
 
         case SWITCH_ABC_TYPE_READ_REPLACE:
                 {
 
                         if (switch_test_flag(ep, ED_MUX_READ)) {
                                 switch_frame_t *rframe = switch_core_media_bug_get_read_replace_frame(bug);
 
                                 if (switch_buffer_inuse(ep->r_buffer) >= rframe->datalen) {
                                         uint32_t bytes;
                                         int channels = rframe->channels ? rframe->channels : 1;
                                         
                                         switch_buffer_lock(ep->r_buffer);
                                         bytes = (uint32_t) switch_buffer_read(ep->r_buffer, ep->data, rframe->datalen);
                                         
                                         rframe->datalen = switch_merge_sln(rframe->data, rframe->samples, (int16_t *) ep->data, bytes / 2, channels) * 2 * channels;
                                         rframe->samples = rframe->datalen / 2;
 
                                         ep->demux_frame.data = ep->data;
                                         ep->demux_frame.datalen = bytes;
                                         ep->demux_frame.samples = bytes / 2;
                                         ep->demux_frame.channels = rframe->channels;
 
                                         switch_buffer_unlock(ep->r_buffer);
                                         switch_core_media_bug_set_read_replace_frame(bug, rframe);
                                         switch_core_media_bug_set_read_demux_frame(bug, &ep->demux_frame);
                                 }
                         }
 
                 }
                 break;
 
         case SWITCH_ABC_TYPE_WRITE_REPLACE:
                 {
                         if (switch_test_flag(ep, ED_MUX_WRITE)) {
                                 switch_frame_t *rframe = switch_core_media_bug_get_write_replace_frame(bug);
 
                                 if (switch_buffer_inuse(ep->w_buffer) >= rframe->datalen) {
                                         uint32_t bytes;
                                         int channels = rframe->channels ? rframe->channels : 1;
 
                                         switch_buffer_lock(ep->w_buffer);
                                         bytes = (uint32_t) switch_buffer_read(ep->w_buffer, data, rframe->datalen);
 
                                         rframe->datalen = switch_merge_sln(rframe->data, rframe->samples, (int16_t *) data, bytes / 2, channels) * 2 * channels;
                                         rframe->samples = rframe->datalen / 2;
 
                                         switch_buffer_unlock(ep->w_buffer);
                                         switch_core_media_bug_set_write_replace_frame(bug, rframe);
                                 }
                         }
                 }
                 break;
 
         case SWITCH_ABC_TYPE_READ_VIDEO_PING:
         case SWITCH_ABC_TYPE_STREAM_VIDEO_PING:
                 {
 
                         if (!bug->video_ping_frame || !bug->video_ping_frame->img) {
                                 break;
                         }
                         
                         if (ep->eavesdropper && switch_core_session_read_lock(ep->eavesdropper) == SWITCH_STATUS_SUCCESS) {
                                 if (switch_core_session_write_video_frame(ep->eavesdropper, bug->video_ping_frame, SWITCH_IO_FLAG_NONE, 0) != SWITCH_STATUS_SUCCESS) {
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error writing video to %s\n", switch_core_session_get_name(ep->eavesdropper));
                                         ep->errs++;
 
                                         if (ep->errs > 10) {
                                                 switch_channel_hangup(e_channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                                                 switch_core_session_reset(ep->eavesdropper, SWITCH_TRUE, SWITCH_TRUE);
                                                 switch_core_session_rwunlock(ep->eavesdropper);
                                                 return SWITCH_FALSE;
                                         }
                                 } else {
                                         ep->errs = 0;
                                 }
                                 switch_core_session_rwunlock(ep->eavesdropper);
                         }
                 }
                 break;
         default:
                 break;
         }
 
         return SWITCH_TRUE;
 }

static void exec_cb	(	switch_media_bug_t *	bug,
		void *	user_data
	)

static

Definition at line 1799 of file switch_ivr_async.c.

References exec_cb_data::caller, eavesdrop_pvt::eavesdropper, ep, switch_channel_get_name(), SWITCH_CHANNEL_LOG, switch_core_media_bug_get_user_data(), switch_core_session_execute_application, switch_core_session_get_channel(), SWITCH_LOG_DEBUG, switch_log_printf(), exec_cb_data::val, and exec_cb_data::var.

Referenced by switch_ivr_eavesdrop_exec_all().

 {
         struct exec_cb_data *data = (struct exec_cb_data *) user_data;
         struct eavesdrop_pvt *ep = (struct eavesdrop_pvt *) switch_core_media_bug_get_user_data(bug);
 
         if (ep && ep->eavesdropper && ep->eavesdropper != data->caller) {
                 switch_channel_t *a = switch_core_session_get_channel(ep->eavesdropper);
                 switch_channel_t *b = switch_core_session_get_channel(data->caller);
 
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s telling %s to exec %s:%s\n", 
                                                   switch_channel_get_name(b), switch_channel_get_name(a), data->var, data->val);
 
                 switch_core_session_execute_application(ep->eavesdropper, data->var, data->val);
         }
 }

static switch_status_t generate_on_dtmf	(	switch_core_session_t *	session,
		const switch_dtmf_t *	dtmf,
		switch_dtmf_direction_t	direction
	)

static

Definition at line 3288 of file switch_ivr_async.c.

References switch_inband_dtmf_generate_t::audio_buffer, CF_DIVERT_EVENTS, switch_dtmf_t::digit, switch_inband_dtmf_generate_t::digit_queue, switch_dtmf_t::duration, switch_inband_dtmf_generate_t::mutex, switch_inband_dtmf_generate_t::ready, switch_inband_dtmf_generate_t::skip, switch_buffer_inuse(), switch_channel_event_set_data(), switch_channel_get_private(), switch_channel_test_flag(), switch_core_media_bug_get_user_data(), switch_core_session_get_channel(), switch_core_session_queue_event(), switch_event_add_header(), switch_event_add_header_string(), switch_event_create, SWITCH_EVENT_DTMF, switch_event_fire, switch_mutex_lock(), switch_mutex_unlock(), switch_queue_trypush(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_zmalloc.

Referenced by inband_dtmf_generate_callback().

 {
         switch_channel_t *channel = switch_core_session_get_channel(session);
         switch_media_bug_t *bug = switch_channel_get_private(channel, "dtmf_generate");
         switch_status_t status = SWITCH_STATUS_SUCCESS;
 
         if (bug) {
                 switch_inband_dtmf_generate_t *pvt = (switch_inband_dtmf_generate_t *) switch_core_media_bug_get_user_data(bug);
 
                 if (pvt) {
                         switch_mutex_lock(pvt->mutex);
                         
                         if (pvt->ready) {
                                 switch_dtmf_t *dt = NULL;
                                 switch_zmalloc(dt, sizeof(*dt));
                                 *dt = *dtmf;
                                 if (!switch_buffer_inuse(pvt->audio_buffer)) {
                                         pvt->skip = 10;
                                 }
                                 if (switch_queue_trypush(pvt->digit_queue, dt) == SWITCH_STATUS_SUCCESS) {
                                         switch_event_t *event;
 
                                         if (switch_event_create(&event, SWITCH_EVENT_DTMF) == SWITCH_STATUS_SUCCESS) {
                                                 switch_channel_event_set_data(channel, event);
                                                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "DTMF-Digit", "%c", dtmf->digit);
                                                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "DTMF-Duration", "%u", dtmf->duration);
                                                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "DTMF-Source", "APP");
                                                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "DTMF-Conversion", "native:inband");
                                                 if (switch_channel_test_flag(channel, CF_DIVERT_EVENTS)) {
                                                         switch_core_session_queue_event(session, &event);
                                                 } else {
                                                         switch_event_fire(&event);
                                                 }
                                         }
                                         
                                         dt = NULL;
                                         /* 
                                            SWITCH_STATUS_FALSE indicates pretend there never was a DTMF
                                            since we will be generating it inband now.
                                          */
                                         status = SWITCH_STATUS_FALSE;
                                 } else {
                                         free(dt);
                                 }
                         }
                         switch_mutex_unlock(pvt->mutex);
                 }
         }
 
         return status;
 }

static switch_bool_t inband_dtmf_callback	(	switch_media_bug_t *	bug,
		void *	user_data,
		switch_abc_type_t	type
	)

static

Definition at line 3182 of file switch_ivr_async.c.

References switch_frame::data, switch_dtmf_t::digit, switch_inband_dtmf_t::dtmf_detect, switch_dtmf_t::duration, switch_frame::samples, switch_inband_dtmf_t::session, switch_dtmf_t::source, SWITCH_ABC_TYPE_CLOSE, SWITCH_ABC_TYPE_INIT, SWITCH_ABC_TYPE_READ_REPLACE, SWITCH_ABC_TYPE_WRITE, switch_channel_queue_dtmf(), SWITCH_CHANNEL_SESSION_LOG, switch_core_media_bug_get_read_replace_frame(), switch_core_media_bug_get_session(), switch_core_media_bug_set_read_replace_frame(), switch_core_session_get_channel(), SWITCH_DTMF_INBAND_AUDIO, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_TRUE, teletone_dtmf_detect(), teletone_dtmf_get(), and TT_HIT_END.

Referenced by switch_ivr_inband_dtmf_session().

 {
         switch_inband_dtmf_t *pvt = (switch_inband_dtmf_t *) user_data;
         switch_frame_t *frame = NULL;
         switch_channel_t *channel = switch_core_session_get_channel(pvt->session);
         teletone_hit_type_t hit;
 
         switch (type) {
         case SWITCH_ABC_TYPE_INIT:
                 break;
         case SWITCH_ABC_TYPE_CLOSE:
                 break;
         case SWITCH_ABC_TYPE_READ_REPLACE:
                 if ((frame = switch_core_media_bug_get_read_replace_frame(bug))) {
                         if ((hit = teletone_dtmf_detect(&pvt->dtmf_detect, frame->data, frame->samples)) == TT_HIT_END) {
                                 switch_dtmf_t dtmf = {0};
 
                                 teletone_dtmf_get(&pvt->dtmf_detect, &dtmf.digit, &dtmf.duration);
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(switch_core_media_bug_get_session(bug)), SWITCH_LOG_DEBUG, "DTMF DETECTED: [%c][%d]\n",
                                                                   dtmf.digit, dtmf.duration);
                                 dtmf.source = SWITCH_DTMF_INBAND_AUDIO;
                                 switch_channel_queue_dtmf(channel, &dtmf);
                         }
                         switch_core_media_bug_set_read_replace_frame(bug, frame);
                 }
                 break;
         case SWITCH_ABC_TYPE_WRITE:
         default:
                 break;
         }
 
         return SWITCH_TRUE;
 }

static switch_bool_t inband_dtmf_generate_callback	(	switch_media_bug_t *	bug,
		void *	user_data,
		switch_abc_type_t	type
	)

static

Definition at line 3341 of file switch_ivr_async.c.

References switch_codec_implementation::actual_samples_per_second, switch_inband_dtmf_generate_t::audio_buffer, buf, teletone_generation_session::channels, switch_frame::data, switch_frame::datalen, switch_dtmf_t::digit, switch_inband_dtmf_generate_t::digit_queue, teletone_generation_session::duration, switch_dtmf_t::duration, generate_on_dtmf(), memset(), switch_inband_dtmf_generate_t::mutex, teletone_generation_session::rate, switch_inband_dtmf_generate_t::read, switch_inband_dtmf_generate_t::ready, switch_inband_dtmf_generate_t::session, switch_inband_dtmf_generate_t::skip, switch_dtmf_t::source, SWITCH_ABC_TYPE_CLOSE, SWITCH_ABC_TYPE_INIT, SWITCH_ABC_TYPE_READ_REPLACE, SWITCH_ABC_TYPE_WRITE_REPLACE, switch_buffer_create_dynamic(), switch_buffer_destroy(), switch_buffer_inuse(), switch_buffer_read(), switch_channel_get_name(), SWITCH_CHANNEL_SESSION_LOG, switch_core_default_dtmf_duration(), switch_core_max_dtmf_duration(), switch_core_media_bug_get_read_replace_frame(), switch_core_media_bug_get_session(), switch_core_media_bug_get_write_replace_frame(), switch_core_media_bug_set_read_replace_frame(), switch_core_media_bug_set_write_replace_frame(), switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_impl(), SWITCH_DTMF_INBAND_AUDIO, SWITCH_FALSE, switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_init(), switch_mutex_lock(), SWITCH_MUTEX_NESTED, switch_mutex_unlock(), switch_queue_create(), switch_queue_trypop(), SWITCH_STATUS_SUCCESS, SWITCH_TRUE, teletone_destroy_session(), teletone_dtmf_generate_handler(), teletone_init_session(), teletone_run(), and switch_inband_dtmf_generate_t::ts.

Referenced by switch_ivr_inband_dtmf_generate_session().

 {
         switch_inband_dtmf_generate_t *pvt = (switch_inband_dtmf_generate_t *) user_data;
         switch_frame_t *frame;
         switch_codec_implementation_t read_impl = { 0 };
         switch_core_session_get_read_impl(pvt->session, &read_impl);
 
         switch (type) {
         case SWITCH_ABC_TYPE_INIT:
                 {
                         switch_queue_create(&pvt->digit_queue, 100, switch_core_session_get_pool(pvt->session));
                         switch_buffer_create_dynamic(&pvt->audio_buffer, 512, 1024, 0);
                         teletone_init_session(&pvt->ts, 0, teletone_dtmf_generate_handler, pvt->audio_buffer);
                         pvt->ts.rate = read_impl.actual_samples_per_second;
                         pvt->ts.channels = 1;
                         switch_mutex_init(&pvt->mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(pvt->session));
                         if (pvt->read) {
                                 switch_core_event_hook_add_recv_dtmf(pvt->session, generate_on_dtmf);
                         } else {
                                 switch_core_event_hook_add_send_dtmf(pvt->session, generate_on_dtmf);
                         }
                         switch_mutex_lock(pvt->mutex);
                         pvt->ready = 1;
                         switch_mutex_unlock(pvt->mutex);
                 }
                 break;
         case SWITCH_ABC_TYPE_CLOSE:
                 {
                         switch_mutex_lock(pvt->mutex);
                         pvt->ready = 0;
                         switch_core_event_hook_remove_recv_dtmf(pvt->session, generate_on_dtmf);
                         switch_buffer_destroy(&pvt->audio_buffer);
                         teletone_destroy_session(&pvt->ts);
                         switch_mutex_unlock(pvt->mutex);
                 }
                 break;
         case SWITCH_ABC_TYPE_READ_REPLACE:
         case SWITCH_ABC_TYPE_WRITE_REPLACE:
                 {
                         switch_size_t bytes;
                         void *pop;
                         
                         if (pvt->skip) {
                                 pvt->skip--;
                                 return SWITCH_TRUE;
                         }
                         
 
                         switch_mutex_lock(pvt->mutex);
 
                         if (!pvt->ready) {
                                 switch_mutex_unlock(pvt->mutex);
                                 return SWITCH_FALSE;
                         }
 
                         if (pvt->read) {
                                 frame = switch_core_media_bug_get_read_replace_frame(bug);
                         } else {
                                 frame = switch_core_media_bug_get_write_replace_frame(bug);
                         }
 
                         if (!switch_buffer_inuse(pvt->audio_buffer)) {
                                 if (switch_queue_trypop(pvt->digit_queue, &pop) == SWITCH_STATUS_SUCCESS) {
                                         switch_dtmf_t *dtmf = (switch_dtmf_t *) pop;
                                         
 
                                         if (dtmf->source != SWITCH_DTMF_INBAND_AUDIO) {
                                                 char buf[2] = "";
                                                 int duration = dtmf->duration;
 
                                                 buf[0] = dtmf->digit;
                                                 if (duration > (int)switch_core_max_dtmf_duration(0)) {
                                                         duration = switch_core_default_dtmf_duration(0);
                                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(switch_core_media_bug_get_session(bug)),
                                                                                   SWITCH_LOG_WARNING, "%s Truncating DTMF duration %d ms to %d ms\n",
                                                                                           switch_channel_get_name(switch_core_session_get_channel(pvt->session)), dtmf->duration / 8, duration);
                                                 }
                                                 
 
                                                 pvt->ts.duration = duration;
                                                 teletone_run(&pvt->ts, buf);
                                         }
                                         free(pop);
                                 }
                         }
 
                         if (switch_buffer_inuse(pvt->audio_buffer) && (bytes = switch_buffer_read(pvt->audio_buffer, frame->data, frame->datalen))) {
                                 if (bytes < frame->datalen) {
                                         switch_byte_t *dp = frame->data;
                                         memset(dp + bytes, 0, frame->datalen - bytes);
                                 }
                         }
 
                         if (pvt->read) {
                                 switch_core_media_bug_set_read_replace_frame(bug, frame);
                         } else {
                                 switch_core_media_bug_set_write_replace_frame(bug, frame);
                         }
 
                         switch_mutex_unlock(pvt->mutex);
                 }
                 break;
         default:
                 break;
         }
 
         return SWITCH_TRUE;
 }

static switch_bool_t is_silence_frame	(	switch_frame_t *	frame,
		int	silence_threshold,
		switch_codec_implementation_t *	codec_impl
	)

static

Definition at line 1067 of file switch_ivr_async.c.

References switch_frame::data, switch_frame::datalen, switch_codec_implementation::number_of_channels, switch_codec_implementation::samples_per_second, and SWITCH_TRUE.

Referenced by record_callback().

 {
         int16_t *fdata = (int16_t *) frame->data;
         uint32_t samples = frame->datalen / sizeof(*fdata);
         switch_bool_t is_silence = SWITCH_TRUE;
         uint32_t channel_num = 0;
 
         int divisor = 0;
         if (!(divisor = codec_impl->samples_per_second / 8000)) {
                 divisor = 1;
         }
 
         /* is silence only if every channel is silent */
         for (channel_num = 0; channel_num < codec_impl->number_of_channels && is_silence; channel_num++) {
                 uint32_t count = 0, j = channel_num;
                 double energy = 0;
                 for (count = 0; count < samples; count++) {
                         energy += abs(fdata[j]);
                         j += codec_impl->number_of_channels;
                 }
                 is_silence &= (uint32_t) ((energy / (samples / divisor)) < silence_threshold);
         }
 
         return is_silence;
 }

static switch_status_t meta_on_dtmf	(	switch_core_session_t *	session,
		const switch_dtmf_t *	dtmf,
		switch_dtmf_direction_t	direction
	)

static

Definition at line 3942 of file switch_ivr_async.c.

References dtmf_meta_app_t::app, dtmf_meta_app_t::bind_flags, CF_INNER_BRIDGE, CF_PROXY_MODE, switch_dtmf_t::digit, dtmf_meta_app_t::flags, is_dtmf, dtmf_meta_settings_t::last_digit, dtmf_meta_settings_t::map, memset(), dtmf_meta_settings_t::meta, dtmf_meta_settings_t::meta_on, SBF_DIAL_ALEG, SBF_DIAL_BLEG, SBF_EXEC_ALEG, SBF_EXEC_BLEG, SBF_EXEC_INLINE, SBF_EXEC_OPPOSITE, SBF_EXEC_SAME, SBF_ONCE, SMF_ECHO_ALEG, SMF_ECHO_BLEG, SMF_EXEC_INLINE, SMF_REBRIDGE, dtmf_meta_data_t::sr, switch_channel_get_name(), switch_channel_get_private(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_test_flag(), switch_core_session_get_channel(), switch_core_session_get_uuid(), SWITCH_DTMF_RECV, SWITCH_DTMF_SEND, switch_dtmftoi(), switch_epoch_time_now(), SWITCH_FALSE, switch_ivr_broadcast(), switch_ivr_broadcast_in_thread(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_META_VAR_KEY, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, SWITCH_TRUE, and dtmf_meta_settings_t::up.

Referenced by switch_ivr_bind_dtmf_meta_session().

 {
         switch_channel_t *channel = switch_core_session_get_channel(session);
         dtmf_meta_data_t *md = switch_channel_get_private(channel, SWITCH_META_VAR_KEY);
         time_t now = switch_epoch_time_now(NULL);
         char digit[2] = "";
         int dval;
 
         if (!md || switch_channel_test_flag(channel, CF_INNER_BRIDGE)) {
                 return SWITCH_STATUS_SUCCESS;
         }
 
         if (direction == SWITCH_DTMF_RECV && !md->sr[SWITCH_DTMF_RECV].up) {
                 return SWITCH_STATUS_SUCCESS;
         }
 
         if (direction == SWITCH_DTMF_SEND && !md->sr[SWITCH_DTMF_SEND].up) {
                 return SWITCH_STATUS_SUCCESS;
         }
 
         if (md->sr[direction].meta_on && now - md->sr[direction].last_digit > 5) {
                 md->sr[direction].meta_on = SWITCH_FALSE;
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "%s Meta digit timeout parsing %c\n", switch_channel_get_name(channel),
                                                   dtmf->digit);
                 return SWITCH_STATUS_SUCCESS;
         }
 
         md->sr[direction].last_digit = now;
 
         if (dtmf->digit == md->sr[direction].meta) {
                 if (md->sr[direction].meta_on) {
                         md->sr[direction].meta_on = SWITCH_FALSE;
                         return SWITCH_STATUS_SUCCESS;
                 } else {
                         md->sr[direction].meta_on = SWITCH_TRUE;
                         return SWITCH_STATUS_FALSE;
                 }
         }
 
         if (md->sr[direction].meta_on) {
                 if (is_dtmf(dtmf->digit)) {
                         int ok = 0;
                         *digit = dtmf->digit;
                         dval = switch_dtmftoi(digit);
                         
                         if (direction == SWITCH_DTMF_RECV && (md->sr[direction].map[dval].bind_flags & SBF_DIAL_ALEG)) {
                                 ok = 1;
                         } else if (direction == SWITCH_DTMF_SEND && (md->sr[direction].map[dval].bind_flags & SBF_DIAL_BLEG)) {
                                 ok = 1;
                         }
 
                         if (ok && md->sr[direction].map[dval].app) {
                                 uint32_t flags = md->sr[direction].map[dval].flags;
 
                                 if ((md->sr[direction].map[dval].bind_flags & SBF_EXEC_OPPOSITE)) {
                                         if (direction == SWITCH_DTMF_SEND) {
                                                 flags |= SMF_ECHO_ALEG;
                                         } else {
                                                 flags |= SMF_ECHO_BLEG;
                                         }
                                 } else if ((md->sr[direction].map[dval].bind_flags & SBF_EXEC_SAME)) {
                                         if (direction == SWITCH_DTMF_SEND) {
                                                 flags |= SMF_ECHO_BLEG;
                                         } else {
                                                 flags |= SMF_ECHO_ALEG;
                                         }
                                 } else if ((md->sr[direction].map[dval].bind_flags & SBF_EXEC_ALEG)) {
                                         flags |= SMF_ECHO_ALEG;
                                 } else if ((md->sr[direction].map[dval].bind_flags & SBF_EXEC_BLEG)) {
                                         flags |= SMF_ECHO_BLEG;
                                 } else {
                                         flags |= SMF_ECHO_ALEG;
                                 }
 
                                 if ((md->sr[direction].map[dval].bind_flags & SBF_EXEC_INLINE)) {
                                         flags |= SMF_EXEC_INLINE;
                                 }
 
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Processing meta digit '%c' [%s]\n",
                                                                   switch_channel_get_name(channel), dtmf->digit, md->sr[direction].map[dval].app);
 
                                 if (switch_channel_test_flag(channel, CF_PROXY_MODE)) {
                                         switch_ivr_broadcast_in_thread(session, md->sr[direction].map[dval].app, flags | SMF_REBRIDGE);
                                 } else {
                                         switch_ivr_broadcast(switch_core_session_get_uuid(session), md->sr[direction].map[dval].app, flags);
                                 }
 
                                 if ((md->sr[direction].map[dval].bind_flags & SBF_ONCE)) {
                                         memset(&md->sr[direction].map[dval], 0, sizeof(md->sr[direction].map[dval]));
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Unbinding meta digit '%c'\n",
                                                                           switch_channel_get_name(channel), dtmf->digit);
                                 }
 
                         } else {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "%s Ignoring meta digit '%c' not mapped\n",
                                                                   switch_channel_get_name(channel), dtmf->digit);
 
                         }
                 }
                 md->sr[direction].meta_on = SWITCH_FALSE;
                 return SWITCH_STATUS_FALSE;
         }
 
         return SWITCH_STATUS_SUCCESS;
 }

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

static

Definition at line 4189 of file switch_ivr_async.c.

References switch_dtmf_t::digit, play_and_detect_speech_state_t::done, switch_event::event_id, PLAY_AND_DETECT_DONE, PLAY_AND_DETECT_DONE_RECOGNIZING, play_and_detect_speech_state_t::result, switch_channel_get_name(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable_printf(), switch_core_session_get_channel(), switch_core_session_sprintf(), switch_core_session_strdup, SWITCH_EVENT_DETECTED_SPEECH, switch_event_get_body(), switch_event_get_header, SWITCH_INPUT_TYPE_DTMF, SWITCH_INPUT_TYPE_EVENT, SWITCH_LOG_DEBUG, SWITCH_LOG_INFO, switch_log_printf(), SWITCH_PLAYBACK_TERMINATOR_USED, SWITCH_PLAYBACK_TERMINATORS_VARIABLE, SWITCH_STATUS_BREAK, SWITCH_STATUS_SUCCESS, and zstr.

Referenced by switch_ivr_play_and_detect_speech().

 {
         play_and_detect_speech_state_t *state = (play_and_detect_speech_state_t *)data;
         if (!state->done) {
                 switch_channel_t *channel = switch_core_session_get_channel(session);
                 if (input_type == SWITCH_INPUT_TYPE_EVENT) {
                         switch_event_t *event;
                         event = (switch_event_t *)input;
                         if (event->event_id == SWITCH_EVENT_DETECTED_SPEECH) {
                                 const char *speech_type = switch_event_get_header(event, "Speech-Type");
                                 if (!zstr(speech_type)) {
                                         if (!strcasecmp(speech_type, "detected-speech")) {
                                                 const char *result;
                                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "(%s) DETECTED SPEECH\n", switch_channel_get_name(channel));
                                                 result = switch_event_get_body(event);
                                                 if (!zstr(result)) {
                                                         state->result = switch_core_session_strdup(session, result);
                                                 } else {
                                                         state->result = "";
                                                 }
                                                 state->done = PLAY_AND_DETECT_DONE_RECOGNIZING;
                                                 return SWITCH_STATUS_BREAK;
                                         } else if (!strcasecmp(speech_type, "begin-speaking")) {
                                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "(%s) START OF SPEECH\n", switch_channel_get_name(channel));
                                                 return SWITCH_STATUS_BREAK;
                                         } else if (!strcasecmp("closed", speech_type)) {
                                                 state->done = PLAY_AND_DETECT_DONE_RECOGNIZING;
                                                 state->result = "";
                                                 return SWITCH_STATUS_BREAK;
                                         }
                                 }
                         }
                 } else if (input_type == SWITCH_INPUT_TYPE_DTMF) {
                         switch_dtmf_t *dtmf = (switch_dtmf_t *) input;
                         const char *terminators = switch_channel_get_variable(channel, SWITCH_PLAYBACK_TERMINATORS_VARIABLE);
                         if (terminators) {
                                 if (!strcasecmp(terminators, "any")) {
                                         terminators = "1234567890*#";
                                 } else if (!strcasecmp(terminators, "none")) {
                                         terminators = NULL;
                                 }
                         }
                         if (terminators && strchr(terminators, dtmf->digit)) {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "(%s) ACCEPT TERMINATOR %c\n", switch_channel_get_name(channel), dtmf->digit);
                                 switch_channel_set_variable_printf(channel, SWITCH_PLAYBACK_TERMINATOR_USED, "%c", dtmf->digit);
                                 state->result = switch_core_session_sprintf(session, "DIGIT: %c", dtmf->digit);
                                 state->done = PLAY_AND_DETECT_DONE;
                                 return SWITCH_STATUS_BREAK;
                         } else {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "(%s) IGNORE NON-TERMINATOR DIGIT %c\n", switch_channel_get_name(channel), dtmf->digit);
                         }
                 }
         }
         return SWITCH_STATUS_SUCCESS;
 }

static switch_bool_t preprocess_callback	(	switch_media_bug_t *	bug,
		void *	user_data,
		switch_abc_type_t	type
	)

static

Definition at line 2748 of file switch_ivr_async.c.

References switch_frame::data, switch_frame::datalen, pp_cb_t::done, pp_cb_t::read_data, pp_cb_t::read_ec, pp_cb_t::read_mutex, pp_cb_t::read_out, pp_cb_t::read_st, SWITCH_ABC_TYPE_CLOSE, SWITCH_ABC_TYPE_INIT, SWITCH_ABC_TYPE_READ_REPLACE, SWITCH_ABC_TYPE_WRITE_REPLACE, switch_channel_set_private(), switch_core_media_bug_get_read_replace_frame(), switch_core_media_bug_get_session(), switch_core_media_bug_get_write_replace_frame(), switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_impl(), SWITCH_FALSE, switch_mutex_init(), SWITCH_MUTEX_NESTED, SWITCH_TRUE, pp_cb_t::write_data, pp_cb_t::write_ec, pp_cb_t::write_mutex, pp_cb_t::write_out, and pp_cb_t::write_st.

Referenced by switch_ivr_preprocess_session().

 {
         switch_core_session_t *session = switch_core_media_bug_get_session(bug);
         switch_channel_t *channel = switch_core_session_get_channel(session);
         pp_cb_t *cb = (pp_cb_t *) user_data;
         switch_codec_implementation_t read_impl = { 0 };
         switch_frame_t *frame = NULL;
 
         switch_core_session_get_read_impl(session, &read_impl);
 
         switch (type) {
         case SWITCH_ABC_TYPE_INIT:
                 {
                         switch_mutex_init(&cb->read_mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));
                         switch_mutex_init(&cb->write_mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));
                 }
                 break;
         case SWITCH_ABC_TYPE_CLOSE:
                 {
                         if (cb->read_st) {
                                 speex_preprocess_state_destroy(cb->read_st);
                         }
 
                         if (cb->write_st) {
                                 speex_preprocess_state_destroy(cb->write_st);
                         }
 
                         if (cb->read_ec) {
                                 speex_echo_state_destroy(cb->read_ec);
                         }
 
                         if (cb->write_ec) {
                                 speex_echo_state_destroy(cb->write_ec);
                         }
 
                         switch_channel_set_private(channel, "_preprocess", NULL);
                 }
                 break;
         case SWITCH_ABC_TYPE_READ_REPLACE:
                 {
                         if (cb->done)
                                 return SWITCH_FALSE;
                         frame = switch_core_media_bug_get_read_replace_frame(bug);
 
                         if (cb->read_st) {
 
                                 if (cb->read_ec) {
                                         speex_echo_cancellation(cb->read_ec, (int16_t *) frame->data, (int16_t *) cb->write_data, (int16_t *) cb->read_out);
                                         memcpy(frame->data, cb->read_out, frame->datalen);
                                 }
 
                                 speex_preprocess_run(cb->read_st, frame->data);
                         }
 
                         if (cb->write_ec) {
                                 memcpy(cb->read_data, frame->data, frame->datalen);
                         }
                 }
                 break;
         case SWITCH_ABC_TYPE_WRITE_REPLACE:
                 {
                         if (cb->done)
                                 return SWITCH_FALSE;
                         frame = switch_core_media_bug_get_write_replace_frame(bug);
 
                         if (cb->write_st) {
 
                                 if (cb->write_ec) {
                                         speex_echo_cancellation(cb->write_ec, (int16_t *) frame->data, (int16_t *) cb->read_data, (int16_t *) cb->write_out);
                                         memcpy(frame->data, cb->write_out, frame->datalen);
                                 }
 
                                 speex_preprocess_run(cb->write_st, frame->data);
                         }
 
                         if (cb->read_ec) {
                                 memcpy(cb->write_data, frame->data, frame->datalen);
                         }
                 }
                 break;
         default:
                 break;
         }
 
         return SWITCH_TRUE;
 }

static switch_bool_t read_displace_callback	(	switch_media_bug_t *	bug,
		void *	user_data,
		switch_abc_type_t	type
	)

static

Definition at line 815 of file switch_ivr_async.c.

References buf, switch_file_handle::channels, switch_frame::data, switch_frame::datalen, displace_helper_t::fh, displace_helper_t::file, displace_helper_t::loop, memset(), displace_helper_t::mux, switch_frame::samples, SWITCH_ABC_TYPE_CLOSE, SWITCH_ABC_TYPE_INIT, SWITCH_ABC_TYPE_READ_REPLACE, SWITCH_ABC_TYPE_WRITE, SWITCH_ABC_TYPE_WRITE_REPLACE, switch_channel_set_private(), switch_core_file_close(), switch_core_file_read(), switch_core_file_seek(), switch_core_media_bug_get_read_replace_frame(), switch_core_media_bug_get_session(), switch_core_media_bug_get_write_replace_frame(), switch_core_media_bug_set_read_replace_frame(), switch_core_media_bug_set_write_replace_frame(), switch_core_session_get_channel(), SWITCH_FALSE, switch_normalize_to_16bit, SWITCH_RECOMMENDED_BUFFER_SIZE, SWITCH_STATUS_SUCCESS, and SWITCH_TRUE.

Referenced by switch_ivr_displace_session().

 {
         displace_helper_t *dh = (displace_helper_t *) user_data;
 
         switch (type) {
         case SWITCH_ABC_TYPE_INIT:
                 break;
         case SWITCH_ABC_TYPE_CLOSE:
                 if (dh) {
                         switch_core_session_t *session = switch_core_media_bug_get_session(bug);
                         switch_channel_t *channel;
 
                         switch_core_file_close(&dh->fh);
 
                         if (session && (channel = switch_core_session_get_channel(session))) {
                                 switch_channel_set_private(channel, dh->file, NULL);
                         }
                 }
                 break;
         case SWITCH_ABC_TYPE_WRITE_REPLACE:
                 {
                         switch_frame_t *rframe = switch_core_media_bug_get_write_replace_frame(bug);
                         if (dh && !dh->mux) {
                                 memset(rframe->data, 255, rframe->datalen);
                         }
                         switch_core_media_bug_set_write_replace_frame(bug, rframe);
                 }
                 break;
         case SWITCH_ABC_TYPE_READ_REPLACE:
                 if (dh) {
                         switch_frame_t *rframe = NULL;
                         switch_size_t len;
                         switch_status_t st;
                         rframe = switch_core_media_bug_get_read_replace_frame(bug);
                         len = rframe->samples;
 
                         if (dh->mux) {
                                 int16_t buf[SWITCH_RECOMMENDED_BUFFER_SIZE];
                                 int16_t *fp = rframe->data;
                                 uint32_t x;
 
                                 st = switch_core_file_read(&dh->fh, buf, &len);
 
                                 for (x = 0; x < (uint32_t) len * dh->fh.channels; x++) {
                                         int32_t mixed = fp[x] + buf[x];
                                         switch_normalize_to_16bit(mixed);
                                         fp[x] = (int16_t) mixed;
                                 }
                                 
                         } else {
                                 st = switch_core_file_read(&dh->fh, rframe->data, &len);
                                 rframe->samples = (uint32_t) len;
                         }
 
                         rframe->datalen = rframe->samples * 2 * dh->fh.channels;
 
 
                         if (st != SWITCH_STATUS_SUCCESS || len == 0) {
                                 if (dh->loop) {
                                         uint32_t pos = 0;
                                         switch_core_file_seek(&dh->fh, &pos, 0, SEEK_SET);
                                 } else {
                                         switch_core_session_t *session = switch_core_media_bug_get_session(bug);
                                         switch_channel_t *channel;
 
                                         if (session && (channel = switch_core_session_get_channel(session))) {
                                                 switch_channel_set_private(channel, dh->file, NULL);
                                         }
                                         return SWITCH_FALSE;
                                 }
                         }
 
                         switch_core_media_bug_set_read_replace_frame(bug, rframe);
                 }
                 break;
         case SWITCH_ABC_TYPE_WRITE:
         default:
                 break;
         }
 
         return SWITCH_TRUE;
 }

static switch_bool_t record_callback	(	switch_media_bug_t *	bug,
		void *	user_data,
		switch_abc_type_t	type
	)

static

Definition at line 1180 of file switch_ivr_async.c.

References record_helper::buffer_mutex, switch_frame::buflen, switch_frame::channels, record_helper::completion_cause, switch_frame::data, switch_stream_handle::data, switch_frame::datalen, record_helper::fh, record_helper::file, record_helper::final_timeout_ms, record_helper::hangup_on_error, if(), switch_frame::img, record_helper::in_fh, record_helper::initial_timeout_ms, is_silence_frame(), record_helper::last_read_time, record_helper::last_write_time, switch_codec_implementation::microseconds_per_packet, record_helper::min_sec, record_helper::native, record_helper::out_fh, pool, record_helper::read_impl, recording_thread(), record_helper::rready, switch_file_handle::samplerate, switch_file_handle::samples_out, send_record_stop_event(), set_completion_cause(), record_helper::silence_threshold, record_helper::silence_time, record_helper::silence_timeout_ms, SMBF_MASK, SMBF_PRUNE, record_helper::speech_detected, SWITCH_ABC_TYPE_CLOSE, SWITCH_ABC_TYPE_INIT, SWITCH_ABC_TYPE_READ_PING, SWITCH_ABC_TYPE_READ_VIDEO_PING, SWITCH_ABC_TYPE_STREAM_VIDEO_PING, SWITCH_ABC_TYPE_TAP_NATIVE_READ, SWITCH_ABC_TYPE_TAP_NATIVE_WRITE, SWITCH_ABC_TYPE_WRITE, switch_api_execute(), switch_buffer_destroy(), switch_buffer_write(), SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER, switch_channel_down_nosig, switch_channel_event_set_data(), switch_channel_execute_on(), switch_channel_expand_variables, switch_channel_get_variable, switch_channel_hangup, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_private(), switch_channel_set_variable, switch_core_file_close(), switch_core_file_write(), switch_core_file_write_video(), switch_core_gen_encoded_silence(), switch_core_media_bug_get_native_read_frame(), switch_core_media_bug_get_native_write_frame(), switch_core_media_bug_get_session(), switch_core_media_bug_read(), switch_core_media_bug_set_flag(), switch_core_media_bug_test_flag(), switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_impl(), switch_core_session_reset(), switch_core_session_strdup, switch_event_add_header_string(), switch_event_create, switch_event_fire, SWITCH_EVENT_RECORD_START, SWITCH_FALSE, switch_file_remove(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_micro_time_now(), switch_mutex_init(), switch_mutex_lock(), SWITCH_MUTEX_NESTED, switch_mutex_unlock(), SWITCH_RECOMMENDED_BUFFER_SIZE, SWITCH_RECORD_POST_PROCESS_EXEC_API_VARIABLE, SWITCH_RECORD_POST_PROCESS_EXEC_APP_VARIABLE, switch_safe_free, SWITCH_STACK_BOTTOM, SWITCH_STANDARD_STREAM, SWITCH_STATUS_SUCCESS, switch_thread_create(), switch_thread_join(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_stacksize_set(), switch_time_now(), SWITCH_TRUE, switch_true(), switch_yield, record_helper::thread, record_helper::thread_buffer, record_helper::thread_ready, switch_media_bug::video_ping_frame, record_helper::vwrites, record_helper::wready, record_helper::writes, and zstr.

Referenced by switch_ivr_record_session(), switch_ivr_stop_record_session(), and switch_ivr_transfer_recordings().

 {
         switch_core_session_t *session = switch_core_media_bug_get_session(bug);
         switch_channel_t *channel = switch_core_session_get_channel(session);
         struct record_helper *rh = (struct record_helper *) user_data;
         switch_event_t *event;
         switch_frame_t *nframe;
         switch_size_t len = 0;
         int mask = switch_core_media_bug_test_flag(bug, SMBF_MASK);
         unsigned char null_data[SWITCH_RECOMMENDED_BUFFER_SIZE] = {0};
 
         switch (type) {
         case SWITCH_ABC_TYPE_INIT:
                 {
                         const char *var = switch_channel_get_variable(channel, "RECORD_USE_THREAD");
 
                         if (!rh->native && rh->fh && (zstr(var) || switch_true(var))) {
                                 switch_threadattr_t *thd_attr = NULL;
                                 switch_memory_pool_t *pool = switch_core_session_get_pool(session);
                                 int sanity = 200;
 
                                 
                                 switch_core_session_get_read_impl(session, &rh->read_impl);
                                 switch_mutex_init(&rh->buffer_mutex, SWITCH_MUTEX_NESTED, pool);
                                 switch_threadattr_create(&thd_attr, pool);
                                 switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
                                 switch_thread_create(&rh->thread, thd_attr, recording_thread, bug, pool);
                                 
                                 while(--sanity > 0 && !rh->thread_ready) {
                                         switch_yield(10000);
                                 }
                         }
 
                         if (switch_event_create(&event, SWITCH_EVENT_RECORD_START) == SWITCH_STATUS_SUCCESS) {
                                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Record-File-Path", rh->file);
                                 switch_channel_event_set_data(channel, event);
                                 switch_event_fire(&event);
                         }
 
                         rh->silence_time = switch_micro_time_now();
                         rh->silence_timeout_ms = rh->initial_timeout_ms;
                         rh->speech_detected = SWITCH_FALSE;
                         rh->completion_cause = NULL;
 
                         switch_core_session_get_read_impl(session, &rh->read_impl);
                 }
                 break;
         case SWITCH_ABC_TYPE_TAP_NATIVE_READ:
                 {
                         switch_time_t now = switch_time_now();
                         switch_time_t diff;
 
                         rh->rready = 1;
 
                         nframe = switch_core_media_bug_get_native_read_frame(bug);
                         len = nframe->datalen;
                         
                         if (!rh->wready) {
                                 unsigned char fill_data[SWITCH_RECOMMENDED_BUFFER_SIZE] = {0};
                                 switch_size_t fill_len = len;
 
                                 switch_core_gen_encoded_silence(fill_data, &rh->read_impl, len);
                                 switch_core_file_write(&rh->out_fh, fill_data, &fill_len);
                         }
                                 
                                 
                         if (rh->last_read_time && rh->last_read_time < now) {
                                 diff = (now - rh->last_read_time) / rh->read_impl.microseconds_per_packet;
                                 
                                 if (diff > 3) {
                                         unsigned char fill_data[SWITCH_RECOMMENDED_BUFFER_SIZE] = {0};
                                         switch_core_gen_encoded_silence(fill_data, &rh->read_impl, len);
                                         
                                         while(diff > 1) {
                                                 switch_size_t fill_len = len;
                                                 switch_core_file_write(&rh->in_fh, fill_data, &fill_len);
                                                 diff--;
                                         }
                                 }
                         }
 
                         switch_core_file_write(&rh->in_fh, mask ? null_data : nframe->data, &len);
                         rh->last_read_time = now;
                         rh->writes++;
                 }
                 break;
         case SWITCH_ABC_TYPE_TAP_NATIVE_WRITE:
                 {
                         switch_time_t now = switch_time_now();
                         switch_time_t diff;
                         rh->wready = 1;
                         
                         nframe = switch_core_media_bug_get_native_write_frame(bug);
                         len = nframe->datalen;
 
                         if (!rh->rready) {
                                 unsigned char fill_data[SWITCH_RECOMMENDED_BUFFER_SIZE] = {0};
                                 switch_size_t fill_len = len;
                                 switch_core_gen_encoded_silence(fill_data, &rh->read_impl, len);
                                 switch_core_file_write(&rh->in_fh, fill_data, &fill_len);
                         }
 
 
                         
 
                         if (rh->last_write_time && rh->last_write_time < now) {
                                 diff = (now - rh->last_write_time) / rh->read_impl.microseconds_per_packet;
                                 
                                 if (diff > 3) {
                                         unsigned char fill_data[SWITCH_RECOMMENDED_BUFFER_SIZE] = {0};
                                         switch_core_gen_encoded_silence(fill_data, &rh->read_impl, len);
                                         
                                         while(diff > 1) {
                                                 switch_size_t fill_len = len;
                                                 switch_core_file_write(&rh->out_fh, fill_data, &fill_len);
                                                 diff--;
                                         }
                                 }
                         }
                         
                         switch_core_file_write(&rh->out_fh, mask ? null_data : nframe->data, &len);
                         rh->last_write_time = now;
                         rh->writes++;
                 }
                 break;
         case SWITCH_ABC_TYPE_CLOSE:
                 {
                         const char *var;
 
                         switch_codec_implementation_t read_impl = { 0 };
                         switch_core_session_get_read_impl(session, &read_impl);
 
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Stop recording file %s\n", rh->file);
                         switch_channel_set_private(channel, rh->file, NULL);
 
                         if (rh->native) {
                                 switch_core_file_close(&rh->in_fh);
                                 switch_core_file_close(&rh->out_fh);
                         } else if (rh->fh) {
                                 switch_size_t len;
                                 uint8_t data[SWITCH_RECOMMENDED_BUFFER_SIZE];
                                 switch_frame_t frame = { 0 };
 
                                 if (rh->thread_ready) {
                                         switch_status_t st;
 
                                         rh->thread_ready = 0;
                                         switch_thread_join(&st, rh->thread);
                                 }
 
                                 if (rh->thread_buffer) {
                                         switch_buffer_destroy(&rh->thread_buffer);
                                 }
 
 
                                 frame.data = data;
                                 frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE;
 
                                 while (switch_core_media_bug_read(bug, &frame, SWITCH_TRUE) == SWITCH_STATUS_SUCCESS) {
                                         len = (switch_size_t) frame.datalen / 2;
 
                                         if (len && switch_core_file_write(rh->fh, mask ? null_data : data, &len) != SWITCH_STATUS_SUCCESS) {
                                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error writing %s\n", rh->file);
                                                 /* File write failed */
                                                 set_completion_cause(rh, "uri-failure");
                                                 if (rh->hangup_on_error) {
                                                         switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                                                         switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
                                                 }
                                                 send_record_stop_event(channel, &read_impl, rh);
                                                 return SWITCH_FALSE;
                                         }
                                 }
 
                                 
                                 //if (switch_core_file_has_video(rh->fh, SWITCH_TRUE)) {
                                         //switch_core_media_set_video_file(session, NULL, SWITCH_RW_READ);
                                         //switch_channel_clear_flag_recursive(session->channel, CF_VIDEO_DECODED_READ);
                                 //}
 
                                 switch_core_file_close(rh->fh);
 
                                 if (!rh->writes && !rh->vwrites) {
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Discarding empty file %s\n", rh->file);
                                         switch_channel_set_variable(channel, "RECORD_DISCARDED", "true");
                                         switch_file_remove(rh->file, switch_core_session_get_pool(session));
                                         set_completion_cause(rh, "empty-file");
                                 } else if (rh->fh->samples_out < rh->fh->samplerate * rh->min_sec) {
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Discarding short file %s\n", rh->file);
                                         switch_channel_set_variable(channel, "RECORD_DISCARDED", "true");
                                         switch_file_remove(rh->file, switch_core_session_get_pool(session));
                                         set_completion_cause(rh, "input-too-short");
                                 } else {
 
                                         if (switch_channel_down_nosig(channel)) {
                                                 /* We got hung up */
                                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Channel is hung up\n");
                                                 if (rh->speech_detected) {
                                                         /* Treat it as equivalent with final-silence */
                                                         set_completion_cause(rh, "success-silence");
                                                 } else {
                                                         /* Treat it as equivalent with inital-silence timeout */
                                                         set_completion_cause(rh, "no-input-timeout");
                                                 }
                                         } else {
                                                 /* Set the completion_cause to maxtime reached, unless it's already set */
                                                 set_completion_cause(rh, "success-maxtime");
                                         }
                                 }
                         }
                         
                         send_record_stop_event(channel, &read_impl, rh);
                         
                         switch_channel_execute_on(channel, SWITCH_RECORD_POST_PROCESS_EXEC_APP_VARIABLE);
 
                         if ((var = switch_channel_get_variable(channel, SWITCH_RECORD_POST_PROCESS_EXEC_API_VARIABLE))) {
                                 char *cmd = switch_core_session_strdup(session, var);
                                 char *data, *expanded = NULL;
                                 switch_stream_handle_t stream = { 0 };
                                 
                                 SWITCH_STANDARD_STREAM(stream);
 
                                 if ((data = strchr(cmd, ':'))) {
                                         *data++ = '\0';
                                         expanded = switch_channel_expand_variables(channel, data);
                                 }
 
                                 switch_api_execute(cmd, expanded, session, &stream);
 
                                 if (expanded && expanded != data) {
                                         free(expanded);
                                 }
 
                                 switch_safe_free(stream.data);
 
                         }
 
 
                 }
 
                 break;
         case SWITCH_ABC_TYPE_READ_PING:
 
                 if (rh->fh) {
                         switch_size_t len;
                         uint8_t data[SWITCH_RECOMMENDED_BUFFER_SIZE];
                         switch_frame_t frame = { 0 };
                         switch_status_t status;
                         int i = 0;
 
                         frame.data = data;
                         frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE;
 
                         for (;;) {
                                 status = switch_core_media_bug_read(bug, &frame, i++ == 0 ? SWITCH_FALSE : SWITCH_TRUE);
 
                                 if (status != SWITCH_STATUS_SUCCESS || !frame.datalen) {
                                         break;
                                 } else {
                                         len = (switch_size_t) frame.datalen / 2 / frame.channels;
                                         
                                         if (rh->thread_buffer) {
                                                 switch_mutex_lock(rh->buffer_mutex);
                                                 switch_buffer_write(rh->thread_buffer, mask ? null_data : data, frame.datalen);
                                                 switch_mutex_unlock(rh->buffer_mutex);
                                         } else if (switch_core_file_write(rh->fh, mask ? null_data : data, &len) != SWITCH_STATUS_SUCCESS) {
                                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error writing %s\n", rh->file);
                                                 /* File write failed */
                                                 set_completion_cause(rh, "uri-failure");
                                                 if (rh->hangup_on_error) {
                                                         switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                                                         switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
                                                 }
                                                 return SWITCH_FALSE;
                                         }
                                         
                                         rh->writes++;
                                         
                                         /* check for silence timeout */
                                         if (rh->silence_threshold) {
                                                 switch_codec_implementation_t read_impl = { 0 };
                                                 switch_core_session_get_read_impl(session, &read_impl);
                                                 if (is_silence_frame(&frame, rh->silence_threshold, &read_impl)) {
                                                         if (!rh->silence_time) {
                                                                 /* start of silence */
                                                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Start of silence detected\n");
                                                                 rh->silence_time = switch_micro_time_now();
                                                         } else {
                                                                 /* continuing silence */
                                                                 int duration_ms = (int)((switch_micro_time_now() - rh->silence_time) / 1000);
                                                                 if (rh->silence_timeout_ms > 0 && duration_ms >= rh->silence_timeout_ms) {
                                                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Recording file %s timeout: %i >= %i\n", rh->file, duration_ms, rh->silence_timeout_ms);
                                                                         switch_core_media_bug_set_flag(bug, SMBF_PRUNE);
                                                                         if (rh->speech_detected) {
                                                                                 /* Reached final silence timeout */
                                                                                 set_completion_cause(rh, "success-silence");
                                                                         } else {
                                                                                 /* Reached initial silence timeout */
                                                                                 set_completion_cause(rh, "no-input-timeout");
                                                                                 /* Discard the silent file? */
                                                                         }
                                                                 }
                                                         }
                                                 } else { /* not silence */
                                                         if (rh->silence_time) {
                                                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Start of speech detected\n");
                                                                 rh->speech_detected = SWITCH_TRUE;
                                                                 /* end of silence */
                                                                 rh->silence_time = 0;
                                                                 /* switch from initial timeout to final timeout */
                                                                 rh->silence_timeout_ms = rh->final_timeout_ms;
                                                         }
                                                 }
                                         } else {
                                                 /* no silence detection */
                                                 if (!rh->speech_detected) {
                                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "No silence detection configured; assuming start of speech\n");
                                                         rh->speech_detected = SWITCH_TRUE;
                                                 }
                                         }
                                 }
                         }
                 }
                 break;
         case SWITCH_ABC_TYPE_READ_VIDEO_PING:
         case SWITCH_ABC_TYPE_STREAM_VIDEO_PING:
                 if (rh->fh) {
                         if (!bug->video_ping_frame) break;
                         
                         if ((len || bug->video_ping_frame->img) && switch_core_file_write_video(rh->fh, bug->video_ping_frame) != SWITCH_STATUS_SUCCESS && 
                                 rh->hangup_on_error) {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error writing video to %s\n", rh->file);
                                 switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                                 switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
                                 return SWITCH_FALSE;
                         }
                         rh->vwrites++;
                 }
                 break;
 
         case SWITCH_ABC_TYPE_WRITE:
         default:
                 break;
         }
 
         return SWITCH_TRUE;
 }

static void* SWITCH_THREAD_FUNC recording_thread	(	switch_thread_t *	thread,
		void *	obj
	)

static

Definition at line 1119 of file switch_ivr_async.c.

References record_helper::buffer_mutex, switch_codec_implementation::decoded_bytes_per_packet, record_helper::fh, record_helper::file, record_helper::hangup_on_error, switch_codec_implementation::number_of_channels, record_helper::read_impl, set_completion_cause(), SMBF_STEREO, switch_buffer_create_dynamic(), switch_buffer_inuse(), switch_buffer_read(), SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER, switch_channel_down_nosig, switch_channel_hangup, SWITCH_CHANNEL_SESSION_LOG, switch_channel_up_nosig, switch_core_file_has_video(), switch_core_file_write(), switch_core_media_bug_get_session(), switch_core_media_bug_get_user_data(), switch_core_media_bug_test_flag(), switch_core_session_alloc, switch_core_session_get_channel(), switch_core_session_get_read_impl(), switch_core_session_read_lock(), switch_core_session_reset(), switch_core_session_rwunlock(), SWITCH_FILE_OPEN, SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_RECOMMENDED_BUFFER_SIZE, SWITCH_STATUS_SUCCESS, switch_test_flag, SWITCH_TRUE, switch_yield, record_helper::thread_buffer, and record_helper::thread_ready.

Referenced by record_callback().

 {
         switch_media_bug_t *bug = (switch_media_bug_t *) obj;
         switch_core_session_t *session = switch_core_media_bug_get_session(bug);
         switch_channel_t *channel = switch_core_session_get_channel(session);
         struct record_helper *rh;
         switch_size_t bsize = SWITCH_RECOMMENDED_BUFFER_SIZE, samples = 0, inuse = 0;
         unsigned char *data;
         int channels = 1;
         switch_codec_implementation_t read_impl = { 0 };
 
         if (switch_core_session_read_lock(session) != SWITCH_STATUS_SUCCESS) {
                 return NULL;
         }
 
         rh = switch_core_media_bug_get_user_data(bug);
         switch_buffer_create_dynamic(&rh->thread_buffer, 1024 * 512, 1024 * 64, 0);
         rh->thread_ready = 1;
 
         channels = switch_core_media_bug_test_flag(bug, SMBF_STEREO) ? 2 : rh->read_impl.number_of_channels;
         data = switch_core_session_alloc(session, SWITCH_RECOMMENDED_BUFFER_SIZE);
 
         while(switch_test_flag(rh->fh, SWITCH_FILE_OPEN)) {
                 if (switch_core_file_has_video(rh->fh, SWITCH_TRUE)) {
                         switch_core_session_get_read_impl(session, &read_impl);
                         if (read_impl.decoded_bytes_per_packet > 0 && read_impl.decoded_bytes_per_packet <= SWITCH_RECOMMENDED_BUFFER_SIZE) {
                                 bsize = read_impl.decoded_bytes_per_packet;
                         }
                 }
 
                 switch_mutex_lock(rh->buffer_mutex);
                 inuse = switch_buffer_inuse(rh->thread_buffer);
 
                 if (rh->thread_ready && switch_channel_up_nosig(channel) && inuse < bsize) {
                         switch_mutex_unlock(rh->buffer_mutex);
                         switch_yield(20000);
                         continue;
                 } else if ((!rh->thread_ready || switch_channel_down_nosig(channel)) && !inuse) {
                         switch_mutex_unlock(rh->buffer_mutex);
                         break;
                 }
                 
                 samples = switch_buffer_read(rh->thread_buffer, data, bsize) / 2 / channels;
                 switch_mutex_unlock(rh->buffer_mutex);
 
                 if (switch_core_file_write(rh->fh, data, &samples) != SWITCH_STATUS_SUCCESS) {
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error writing %s\n", rh->file);
                         /* File write failed */
                         set_completion_cause(rh, "uri-failure");
                         if (rh->hangup_on_error) {
                                 switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                                 switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
                         }
                 }
         }
 
         switch_core_session_rwunlock(session);
 
         return NULL;
 }

static void send_record_stop_event	(	switch_channel_t *	channel,
		switch_codec_implementation_t *	read_impl,
		struct record_helper *	rh
	)

static

Definition at line 1093 of file switch_ivr_async.c.

References switch_codec_implementation::actual_samples_per_second, record_helper::completion_cause, record_helper::fh, record_helper::file, switch_file_handle::samples_out, switch_channel_event_set_data(), switch_channel_set_variable_printf(), switch_event_add_header_string(), switch_event_create, switch_event_fire, SWITCH_EVENT_RECORD_STOP, SWITCH_STACK_BOTTOM, SWITCH_STATUS_SUCCESS, and zstr.

Referenced by record_callback().

 {
         switch_event_t *event;
 
         if (rh->fh) {
                 switch_channel_set_variable_printf(channel, "record_samples", "%d", rh->fh->samples_out);
                 if (read_impl->actual_samples_per_second) {
                         switch_channel_set_variable_printf(channel, "record_seconds", "%d", rh->fh->samples_out / read_impl->actual_samples_per_second);
                         switch_channel_set_variable_printf(channel, "record_ms", "%d", rh->fh->samples_out / (read_impl->actual_samples_per_second / 1000));
                 }
         }
 
         if (!zstr(rh->completion_cause)) {
                 switch_channel_set_variable_printf(channel, "record_completion_cause", "%s", rh->completion_cause);
         }
 
         if (switch_event_create(&event, SWITCH_EVENT_RECORD_STOP) == SWITCH_STATUS_SUCCESS) {
                 switch_channel_event_set_data(channel, event);
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Record-File-Path", rh->file);
                 if (!zstr(rh->completion_cause)) {
                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Record-Completion-Cause", rh->completion_cause);
                 }
                 switch_event_fire(&event);
         }
 }

static switch_bool_t session_audio_callback	(	switch_media_bug_t *	bug,
		void *	user_data,
		switch_abc_type_t	type
	)

static

Definition at line 3039 of file switch_ivr_async.c.

References switch_frame::data, switch_frame::datalen, memset(), switch_codec_implementation::number_of_channels, switch_session_audio_t::read_level, switch_session_audio_t::read_mute, switch_session_audio_t::session, SWITCH_ABC_TYPE_READ_REPLACE, SWITCH_ABC_TYPE_WRITE_REPLACE, switch_change_sln_volume(), switch_channel_set_private(), switch_core_media_bug_get_read_replace_frame(), switch_core_media_bug_get_session(), switch_core_media_bug_get_write_replace_frame(), switch_core_media_bug_set_read_replace_frame(), switch_core_media_bug_set_write_replace_frame(), switch_core_session_get_channel(), switch_core_session_get_read_impl(), SWITCH_FALSE, switch_generate_sln_silence(), SWITCH_TRUE, switch_session_audio_t::write_level, and switch_session_audio_t::write_mute.

Referenced by switch_ivr_session_audio().

 {
         switch_session_audio_t *pvt = (switch_session_audio_t *) user_data;
         switch_frame_t *frame = NULL;
         int level = 0, mute = 0;
         switch_core_session_t *session = switch_core_media_bug_get_session(bug);
         switch_codec_implementation_t read_impl = { 0 };
 
         switch_core_session_get_read_impl(session, &read_impl);
 
 
         if (type == SWITCH_ABC_TYPE_READ_REPLACE || type == SWITCH_ABC_TYPE_WRITE_REPLACE) {
                 if (!(pvt->read_level || pvt->write_level || pvt->read_mute || pvt->write_mute)) {
                         switch_channel_set_private(switch_core_session_get_channel(pvt->session), "__audio", NULL);
                         return SWITCH_FALSE;
                 }
         }
 
         if (type == SWITCH_ABC_TYPE_READ_REPLACE) {
                 level = pvt->read_level;
                 mute = pvt->read_mute;
                 frame = switch_core_media_bug_get_read_replace_frame(bug);
         } else if (type == SWITCH_ABC_TYPE_WRITE_REPLACE) {
                 level = pvt->write_level;
                 mute = pvt->write_mute;
                 frame = switch_core_media_bug_get_write_replace_frame(bug);
         }
 
         if (frame) {
                 if (mute) {
                         if (mute > 1) {
                                 switch_generate_sln_silence(frame->data, frame->datalen / 2, read_impl.number_of_channels, mute);
                         } else {
                                 memset(frame->data, 0, frame->datalen);
                         }
                 } else if (level) {
                         switch_change_sln_volume(frame->data, frame->datalen / 2, level);
                 }
 
                 if (type == SWITCH_ABC_TYPE_READ_REPLACE) {
                         switch_core_media_bug_set_read_replace_frame(bug, frame);
                 } else if (type == SWITCH_ABC_TYPE_WRITE_REPLACE) {
                         switch_core_media_bug_set_write_replace_frame(bug, frame);
                 }
         }
 
         return SWITCH_TRUE;
 }

static void set_completion_cause	(	struct record_helper *	rh,
		const char *	completion_cause
	)

static

Set the recording completion cause. The cause can only be set once, to minimize the logic in the record_callback. [The completion_cause strings are essentially those of an MRCP Recorder resource.]

Definition at line 1060 of file switch_ivr_async.c.

References record_helper::completion_cause.

Referenced by record_callback(), and recording_thread().

 {
         if (!rh->completion_cause) {
                 rh->completion_cause = completion_cause;
         }
 }

static switch_bool_t speech_callback	(	switch_media_bug_t *	bug,
		void *	user_data,
		switch_abc_type_t	type
	)

static

Definition at line 4497 of file switch_ivr_async.c.

References speech_thread_handle::ah, switch_frame::buflen, speech_thread_handle::cond, switch_frame::data, switch_frame::datalen, speech_thread_handle::mutex, speech_thread_handle::pool, speech_thread_handle::ready, speech_thread(), SWITCH_ABC_TYPE_CLOSE, SWITCH_ABC_TYPE_INIT, SWITCH_ABC_TYPE_READ, SWITCH_ABC_TYPE_WRITE, SWITCH_ASR_FLAG_NONE, SWITCH_CHANNEL_SESSION_LOG, switch_core_asr_check_results(), switch_core_asr_close(), switch_core_asr_feed(), switch_core_media_bug_get_session(), switch_core_media_bug_read(), SWITCH_FALSE, SWITCH_LOG_DEBUG, switch_log_printf(), switch_mutex_lock(), switch_mutex_trylock(), switch_mutex_unlock(), SWITCH_RECOMMENDED_BUFFER_SIZE, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_cond_signal(), switch_thread_create(), switch_thread_join(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_stacksize_set(), SWITCH_TRUE, and speech_thread_handle::thread.

Referenced by switch_ivr_detect_speech_init().

 {
         struct speech_thread_handle *sth = (struct speech_thread_handle *) user_data;
         uint8_t data[SWITCH_RECOMMENDED_BUFFER_SIZE];
         switch_frame_t frame = { 0 };
         switch_asr_flag_t flags = SWITCH_ASR_FLAG_NONE;
 
         frame.data = data;
         frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE;
 
         switch (type) {
         case SWITCH_ABC_TYPE_INIT:
                 {
                         switch_threadattr_t *thd_attr = NULL;
                         
                         switch_threadattr_create(&thd_attr, sth->pool);
                         switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
                         switch_thread_create(&sth->thread, thd_attr, speech_thread, sth, sth->pool);
                 }
                 break;
         case SWITCH_ABC_TYPE_CLOSE:
                 {
                         switch_status_t st;
 
                         switch_core_asr_close(sth->ah, &flags);
                         if (sth->mutex && sth->cond && sth->ready) {
                                 if (switch_mutex_trylock(sth->mutex) == SWITCH_STATUS_SUCCESS) {
                                         switch_thread_cond_signal(sth->cond);
                                         switch_mutex_unlock(sth->mutex);
                                 }
                         }
                         
                         switch_thread_join(&st, sth->thread);
 
                 }
                 break;
         case SWITCH_ABC_TYPE_READ:
                 if (sth->ah) {
                         if (switch_core_media_bug_read(bug, &frame, SWITCH_FALSE) != SWITCH_STATUS_FALSE) {
                                 if (switch_core_asr_feed(sth->ah, frame.data, frame.datalen, &flags) != SWITCH_STATUS_SUCCESS) {
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(switch_core_media_bug_get_session(bug)), SWITCH_LOG_DEBUG, "Error Feeding Data\n");
                                         return SWITCH_FALSE;
                                 }
                                 if (switch_core_asr_check_results(sth->ah, &flags) == SWITCH_STATUS_SUCCESS) {
                                         if (sth->mutex && sth->cond && sth->ready) {
                                                 switch_mutex_lock(sth->mutex);
                                                 switch_thread_cond_signal(sth->cond);
                                                 switch_mutex_unlock(sth->mutex);
                                         }
                                 }
                         }
                 }
                 break;
         case SWITCH_ABC_TYPE_WRITE:
         default:
                 break;
         }
 
         return SWITCH_TRUE;
 }

static switch_status_t speech_on_dtmf	(	switch_core_session_t *	session,
		const switch_dtmf_t *	dtmf,
		switch_dtmf_direction_t	direction
	)

static

Definition at line 4558 of file switch_ivr_async.c.

References speech_thread_handle::ah, SWITCH_ASR_FLAG_NONE, switch_channel_get_private(), SWITCH_CHANNEL_SESSION_LOG, switch_core_asr_feed_dtmf(), switch_core_session_get_channel(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_SPEECH_KEY, and SWITCH_STATUS_SUCCESS.

Referenced by switch_ivr_detect_speech_init(), and switch_ivr_stop_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);
         switch_status_t status = SWITCH_STATUS_SUCCESS;
         switch_asr_flag_t flags = SWITCH_ASR_FLAG_NONE;
 
         if (sth) {
                 if (switch_core_asr_feed_dtmf(sth->ah, dtmf, &flags) != SWITCH_STATUS_SUCCESS) {
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error Feeding DTMF\n");
                 }
         }
 
         return status;
 }

static void* SWITCH_THREAD_FUNC speech_thread	(	switch_thread_t *	thread,
		void *	obj
	)

static

Definition at line 4348 of file switch_ivr_async.c.

References speech_thread_handle::ah, speech_thread_handle::cond, switch_dtmf_t::digit, switch_dtmf_t::duration, is_dtmf, speech_thread_handle::mutex, speech_thread_handle::pool, speech_thread_handle::ready, speech_thread_handle::session, switch_dtmf_t::source, SWITCH_ASR_FLAG_CLOSED, SWITCH_ASR_FLAG_FIRE_EVENTS, SWITCH_ASR_FLAG_NONE, SWITCH_CHANNEL_CHANNEL_LOG, switch_channel_down_nosig, switch_channel_event_set_data(), switch_channel_get_variable, switch_channel_queue_dtmf(), switch_channel_up_nosig, switch_core_asr_check_results(), switch_core_asr_get_result_headers(), switch_core_asr_get_results(), switch_core_default_dtmf_duration(), switch_core_session_get_channel(), switch_core_session_queue_event(), switch_core_session_read_lock(), switch_core_session_rwunlock(), SWITCH_DTMF_INBAND_AUDIO, switch_event_add_body(), switch_event_add_header_string(), switch_event_create, switch_event_destroy(), SWITCH_EVENT_DETECTED_SPEECH, switch_event_dup(), switch_event_fire, switch_event_merge(), switch_ivr_resume_detect_speech(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_init(), switch_mutex_lock(), SWITCH_MUTEX_NESTED, switch_mutex_unlock(), switch_safe_free, SWITCH_STACK_BOTTOM, SWITCH_STATUS_BREAK, SWITCH_STATUS_SUCCESS, switch_stristr(), switch_test_flag, switch_thread_cond_create(), switch_thread_cond_wait(), and switch_true().

Referenced by speech_callback().

 {
         struct speech_thread_handle *sth = (struct speech_thread_handle *) obj;
         switch_channel_t *channel = switch_core_session_get_channel(sth->session);
         switch_asr_flag_t flags = SWITCH_ASR_FLAG_NONE;
         switch_status_t status;
         switch_event_t *event;
 
         switch_thread_cond_create(&sth->cond, sth->pool);
         switch_mutex_init(&sth->mutex, SWITCH_MUTEX_NESTED, sth->pool);
 
         if (switch_core_session_read_lock(sth->session) != SWITCH_STATUS_SUCCESS) {
                 sth->ready = 0;
                 return NULL;
         }
 
         switch_mutex_lock(sth->mutex);
 
         sth->ready = 1;
 
         while (switch_channel_up_nosig(channel) && !switch_test_flag(sth->ah, SWITCH_ASR_FLAG_CLOSED)) {
                 char *xmlstr = NULL;
                 switch_event_t *headers = NULL;
 
                 switch_thread_cond_wait(sth->cond, sth->mutex);
 
                 if (switch_channel_down_nosig(channel) || switch_test_flag(sth->ah, SWITCH_ASR_FLAG_CLOSED)) {
                         break;
                 }
 
                 if (switch_core_asr_check_results(sth->ah, &flags) == SWITCH_STATUS_SUCCESS) {
 
                         status = switch_core_asr_get_results(sth->ah, &xmlstr, &flags);
 
                         if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_BREAK) {
                                 goto done;
                         } else if (status == SWITCH_STATUS_SUCCESS) {
                                 /* Try to fetch extra information for this result, the return value doesn't really matter here - it's just optional data. */
                                 switch_core_asr_get_result_headers(sth->ah, &headers, &flags);
                         }
 
                         if (status == SWITCH_STATUS_SUCCESS && switch_true(switch_channel_get_variable(channel, "asr_intercept_dtmf"))) {
                                 const char *p;
                                 
                                 if ((p = switch_stristr("<input>", xmlstr))) {
                                         p += 7;
                                 }
 
                                 while (p && *p) {
                                         char c;
 
                                         if (*p == '<') {
                                                 break;
                                         }
 
                                         if (!strncasecmp(p, "pound", 5)) {
                                                 c = '#';
                                                 p += 5;
                                         } else if (!strncasecmp(p, "hash", 4)) {
                                                 c = '#';
                                                 p += 4;
                                         } else if (!strncasecmp(p, "star", 4)) {
                                                 c = '*';
                                                 p += 4;
                                         } else if (!strncasecmp(p, "asterisk", 8)) {
                                                 c = '*';
                                                 p += 8;
                                         } else {
                                                 c = *p;
                                                 p++;
                                         }
 
                                         if (is_dtmf(c)) {
                                                 switch_dtmf_t dtmf = {0};
                                                 dtmf.digit = c;
                                                 dtmf.duration = switch_core_default_dtmf_duration(0);
                                                 dtmf.source = SWITCH_DTMF_INBAND_AUDIO;
                                                 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_DEBUG, "Queue speech detected dtmf %c\n", c);
                                                 switch_channel_queue_dtmf(channel, &dtmf);
                                         }
 
                                 }
                                 switch_ivr_resume_detect_speech(sth->session);
                         }
 
                         if (switch_event_create(&event, SWITCH_EVENT_DETECTED_SPEECH) == SWITCH_STATUS_SUCCESS) {
                                 if (status == SWITCH_STATUS_SUCCESS) {
                                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Speech-Type", "detected-speech");
 
                                         if (headers) {
                                                 switch_event_merge(event, headers);
                                         }
 
                                         switch_event_add_body(event, "%s", xmlstr);
                                 } else {
                                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Speech-Type", "begin-speaking");
                                 }
 
                                 if (switch_test_flag(sth->ah, SWITCH_ASR_FLAG_FIRE_EVENTS)) {
                                         switch_event_t *dup;
 
                                         if (switch_event_dup(&dup, event) == SWITCH_STATUS_SUCCESS) {
                                                 switch_channel_event_set_data(channel, dup);
                                                 switch_event_fire(&dup);
                                         }
 
                                 }
 
                                 if (switch_core_session_queue_event(sth->session, &event) != SWITCH_STATUS_SUCCESS) {
                                         switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_ERROR, "Event queue failed!\n");
                                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "delivery-failure", "true");
                                         switch_event_fire(&event);
                                 }
                         }
 
                         switch_safe_free(xmlstr);
 
                         if (headers) {
                                 switch_event_destroy(&headers);
                         }
                 }
         }
   done:
 
         if (switch_event_create(&event, SWITCH_EVENT_DETECTED_SPEECH) == SWITCH_STATUS_SUCCESS) {
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Speech-Type", "closed");
                 if (switch_test_flag(sth->ah, SWITCH_ASR_FLAG_FIRE_EVENTS)) {
                         switch_event_t *dup;
 
                         if (switch_event_dup(&dup, event) == SWITCH_STATUS_SUCCESS) {
                                 switch_channel_event_set_data(channel, dup);
                                 switch_event_fire(&dup);
                         }
 
                 }
 
                 if (switch_core_session_queue_event(sth->session, &event) != SWITCH_STATUS_SUCCESS) {
                         switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_ERROR, "Event queue failed!\n");
                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "delivery-failure", "true");
                         switch_event_fire(&event);
                 }
         }
 
         switch_mutex_unlock(sth->mutex);
         switch_core_session_rwunlock(sth->session);
 
         return NULL;
 }

static dm_match_t switch_ivr_dmachine_check_match	(	switch_ivr_dmachine_t *	dmachine,
		switch_bool_t	is_timeout
	)

static

Definition at line 339 of file switch_ivr_async.c.

Referenced by switch_ivr_dmachine_ping().

 {
         dm_match_t best = DM_MATCH_NONE;
         switch_ivr_dmachine_binding_t *bp, *exact_bp = NULL, *partial_bp = NULL, *both_bp = NULL, *r_bp = NULL;
         int pmatches = 0, ematches = 0, rmatches = 0;
         
         if (!dmachine->cur_digit_len || !dmachine->realm) goto end;
 
         for(bp = dmachine->realm->binding_list; bp; bp = bp->next) {
                 if (bp->is_regex) {
                         switch_status_t r_status = switch_regex_match(dmachine->digits, bp->digits);
                         
                         if (r_status == SWITCH_STATUS_SUCCESS) {
                                 bp->rmatch++;
                         } else {
                                 bp->rmatch = 0;
                         }
 
                         rmatches++;
                         pmatches++;
 
                 } else {
                         if (!strncmp(dmachine->digits, bp->digits, strlen(dmachine->digits))) {
                                 pmatches++;
                                 ematches = 1;
                         }
                 }
         }
 
         if (!zstr(dmachine->realm->terminators)) {
                 char *p = dmachine->realm->terminators;
                 char *q;
 
                 while(p && *p) {
                         if ((q=strrchr(dmachine->digits, *p))) {
                                 *q = '\0';
                                 is_timeout = 1;
                                 break;
                         }
                         p++;
                 }
         }
 
         for(bp = dmachine->realm->binding_list; bp; bp = bp->next) {
                 if (bp->is_regex) {
                         if (bp->rmatch) {
                                 if (is_timeout || (bp == dmachine->realm->binding_list && !bp->next)) {
                                         best = DM_MATCH_EXACT;
                                         exact_bp = bp;
                                         break;
                                 }
                                 best = DM_MATCH_PARTIAL;
                         }
                 } else {
                         int pmatch = !strncmp(dmachine->digits, bp->digits, strlen(dmachine->digits));
 
                         if (!exact_bp && pmatch && (((pmatches == 1 || ematches == 1) && !rmatches) || is_timeout) && !strcmp(bp->digits, dmachine->digits)) {
                                 best = DM_MATCH_EXACT;
                                 exact_bp = bp;
                                 if (dmachine->cur_digit_len == dmachine->max_digit_len) break;
                         } 
 
                         if (!(both_bp && partial_bp) && strlen(bp->digits) != strlen(dmachine->digits) && pmatch) {
                                 
                                 if (exact_bp) {
                                         best = DM_MATCH_BOTH;
                                         both_bp = bp;
                                 } else {
                                         best = DM_MATCH_PARTIAL;
                                         partial_bp = bp;
                                 }
                         }
 
                         if (both_bp && exact_bp && partial_bp) break;
                 }
         }
 
         if (!pmatches) {
                 best = DM_MATCH_NEVER;
         }
 
         
  end:
 
         if (is_timeout) {
                 if (both_bp) {
                         r_bp = exact_bp ? exact_bp : both_bp;
                 }
         } 
 
         if (best == DM_MATCH_EXACT && exact_bp) {
                 r_bp = exact_bp;
         }
         
         
         if (r_bp) {
                 dmachine->last_matching_binding = r_bp;
                 switch_set_string(dmachine->last_matching_digits, dmachine->digits);
                 best = DM_MATCH_EXACT;
         }
 
         return best;
         
 }

static switch_bool_t switch_ivr_dmachine_check_timeout ( switch_ivr_dmachine_t * dmachine )

static

Definition at line 444 of file switch_ivr_async.c.

References switch_ivr_dmachine::cur_digit_len, switch_ivr_dmachine::digit_timeout_ms, switch_ivr_dmachine::input_timeout_ms, switch_ivr_dmachine::last_digit_time, SWITCH_FALSE, switch_time_now(), and SWITCH_TRUE.

Referenced by switch_ivr_dmachine_ping().

 {
         switch_time_t now = switch_time_now();
         uint32_t timeout = dmachine->cur_digit_len ? dmachine->digit_timeout_ms : dmachine->input_timeout_ms;
 
         if (!dmachine->last_digit_time) dmachine->last_digit_time = now;
 
         if (timeout) {
                 if ((uint32_t)((now - dmachine->last_digit_time) / 1000) > timeout) {
                         return SWITCH_TRUE;
                 }
         }
 
         return SWITCH_FALSE;
 }

static void* switch_ivr_record_user_data_dup	(	switch_core_session_t *	session,
		void *	user_data
	)

static

Definition at line 1558 of file switch_ivr_async.c.

References record_helper::fh, record_helper::file, switch_core_session_alloc, and switch_core_session_strdup.

Referenced by switch_ivr_transfer_recordings().

 {
         struct record_helper *rh = (struct record_helper *) user_data, *dup = NULL;
 
         dup = switch_core_session_alloc(session, sizeof(*dup));
         memcpy(dup, rh, sizeof(*rh));
         dup->file = switch_core_session_strdup(session, rh->file);
         dup->fh = switch_core_session_alloc(session, sizeof(switch_file_handle_t));
         memcpy(dup->fh, rh->fh, sizeof(switch_file_handle_t));
 
         return dup;
 }

SWITCH_STANDARD_SCHED_FUNC ( sch_hangup_callback )

Definition at line 4818 of file switch_ivr_async.c.

References hangup_helper::bleg, hangup_helper::cause, if(), switch_assert, SWITCH_BRIDGE_VARIABLE, switch_channel_get_variable, switch_channel_hangup, SWITCH_CHANNEL_SESSION_LOG, switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_rwunlock(), switch_log_printf(), SWITCH_LOG_WARNING, and hangup_helper::uuid_str.

 {
         struct hangup_helper *helper;
         switch_core_session_t *session, *other_session;
         const char *other_uuid;
 
         switch_assert(task);
 
         helper = (struct hangup_helper *) task->cmd_arg;
 
         if ((session = switch_core_session_locate(helper->uuid_str))) {
                 switch_channel_t *channel = switch_core_session_get_channel(session);
 
                 if (helper->bleg) {
                         if ((other_uuid = switch_channel_get_variable(channel, SWITCH_BRIDGE_VARIABLE)) && (other_session = switch_core_session_locate(other_uuid))) {
                                 switch_channel_t *other_channel = switch_core_session_get_channel(other_session);
                                 switch_channel_hangup(other_channel, helper->cause);
                                 switch_core_session_rwunlock(other_session);
                         } else {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "No channel to hangup\n");
                         }
                 } else {
                         switch_channel_hangup(channel, helper->cause);
                 }
 
                 switch_core_session_rwunlock(session);
         }
 }

SWITCH_STANDARD_SCHED_FUNC ( sch_transfer_callback )

Definition at line 4868 of file switch_ivr_async.c.

References transfer_helper::context, transfer_helper::dialplan, transfer_helper::extension, if(), switch_assert, switch_core_session_locate, switch_core_session_rwunlock(), switch_ivr_session_transfer(), and transfer_helper::uuid_str.

 {
         struct transfer_helper *helper;
         switch_core_session_t *session;
 
         switch_assert(task);
 
         helper = (struct transfer_helper *) task->cmd_arg;
 
         if ((session = switch_core_session_locate(helper->uuid_str))) {
                 switch_ivr_session_transfer(session, helper->extension, helper->dialplan, helper->context);
                 switch_core_session_rwunlock(session);
         }
 
 }

SWITCH_STANDARD_SCHED_FUNC ( sch_broadcast_callback )

Definition at line 4935 of file switch_ivr_async.c.

References broadcast_helper::flags, broadcast_helper::path, switch_assert, switch_ivr_broadcast(), and broadcast_helper::uuid_str.

 {
         struct broadcast_helper *helper;
         switch_assert(task);
 
         helper = (struct broadcast_helper *) task->cmd_arg;
         switch_ivr_broadcast(helper->uuid_str, helper->path, helper->flags);
 }

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

static

Definition at line 3273 of file switch_ivr_async.c.

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

Referenced by inband_dtmf_generate_callback().

 {
         switch_buffer_t *audio_buffer = ts->user_data;
         int wrote;
 
         if (!audio_buffer) {
                 return -1;
         }
 
         wrote = teletone_mux_tones(ts, map);
         switch_buffer_write(audio_buffer, ts->buffer, wrote * 2);
 
         return 0;
 }

static switch_bool_t tone_detect_callback	(	switch_media_bug_t *	bug,
		void *	user_data,
		switch_abc_type_t	type
	)

static

Definition at line 3565 of file switch_ivr_async.c.

Referenced by switch_ivr_tone_detect_session().

 {
         switch_tone_container_t *cont = (switch_tone_container_t *) user_data;
         switch_frame_t *frame = NULL;
         int i = 0;
         switch_bool_t rval = SWITCH_TRUE;
 
         switch (type) {
         case SWITCH_ABC_TYPE_INIT:
                 if (cont) {
                         cont->bug_running = 1;
                 }
                 break;
         case SWITCH_ABC_TYPE_CLOSE:
                 break;
         case SWITCH_ABC_TYPE_READ_REPLACE:
         case SWITCH_ABC_TYPE_WRITE_REPLACE:
                 {
                         
                         if (type == SWITCH_ABC_TYPE_READ_REPLACE) {
                                 frame = switch_core_media_bug_get_read_replace_frame(bug);
                         } else {
                                 frame = switch_core_media_bug_get_write_replace_frame(bug);
                         }
 
                         for (i = 0; i < cont->index; i++) {
                                 int skip = 0;
 
                                 if (cont->list[i].sleep) {
                                         cont->list[i].sleep--;
                                         if (cont->list[i].sleep) {
                                                 skip = 1;
                                         }
                                 }
 
                                 if (cont->list[i].expires) {
                                         cont->list[i].expires--;
                                         if (!cont->list[i].expires) {
                                                 cont->list[i].hits = 0;
                                                 cont->list[i].sleep = 0;
                                                 cont->list[i].expires = 0;
                                         }
                                 }
 
                                 if (!cont->list[i].up)
                                         skip = 1;
 
                                 if (skip)
                                         continue;
 
                                 if (teletone_multi_tone_detect(&cont->list[i].mt, frame->data, frame->samples)) {
                                         switch_event_t *event;
                                         cont->list[i].hits++;
 
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(switch_core_media_bug_get_session(bug)), SWITCH_LOG_DEBUG, "TONE %s HIT %d/%d\n",
                                                                           cont->list[i].key, cont->list[i].hits, cont->list[i].total_hits);
                                         cont->list[i].sleep = cont->list[i].default_sleep;
                                         cont->list[i].expires = cont->list[i].default_expires;
 
                                         if (cont->list[i].hits >= cont->list[i].total_hits) {
                                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(switch_core_media_bug_get_session(bug)), SWITCH_LOG_DEBUG, "TONE %s DETECTED\n",
                                                                                   cont->list[i].key);
                                                 tone_detect_set_total_time(cont, i);
                                                 cont->list[i].up = 0;
 
                                                 if (cont->list[i].callback) {
                                                         if ((rval = cont->list[i].callback(cont->session, cont->list[i].app, cont->list[i].data)) == SWITCH_TRUE) {
                                                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(switch_core_media_bug_get_session(bug)), SWITCH_LOG_DEBUG, "Re-enabling %s\n",
                                                                                                   cont->list[i].key);
                                                                 cont->list[i].up = 1;
                                                                 cont->list[i].hits = 0;
                                                                 cont->list[i].sleep = 0;
                                                                 cont->list[i].expires = 0;
                                                         }
                                                 } else {
                                                         switch_channel_execute_on(switch_core_session_get_channel(cont->session), SWITCH_CHANNEL_EXECUTE_ON_TONE_DETECT_VARIABLE);
                                                         if (cont->list[i].app) {
                                                                 switch_core_session_execute_application_async(cont->session, cont->list[i].app, cont->list[i].data);
                                                         }
                                                 }
 
                                                 if (cont->list[i].once) {
                                                         rval = SWITCH_FALSE;
                                                 }
 
                                                 if (switch_event_create(&event, SWITCH_EVENT_DETECTED_TONE) == SWITCH_STATUS_SUCCESS) {
                                                         switch_event_t *dup;
                                                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Detected-Tone", cont->list[i].key);
 
                                                         if (switch_event_dup(&dup, event) == SWITCH_STATUS_SUCCESS) {
                                                                 switch_event_fire(&dup);
                                                         }
 
                                                         if (switch_core_session_queue_event(cont->session, &event) != SWITCH_STATUS_SUCCESS) {
                                                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(switch_core_media_bug_get_session(bug)), SWITCH_LOG_ERROR,
                                                                                                   "Event queue failed!\n");
                                                                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "delivery-failure", "true");
                                                                 switch_event_fire(&event);
                                                         }
                                                 }
                                         }
                                 }
                         }
                 }
                 break;
         case SWITCH_ABC_TYPE_WRITE:
         default:
                 break;
         }
 
         if (rval == SWITCH_FALSE) {
                 cont->bug_running = 0;
         }
 
         return rval;
 }

static void tone_detect_set_total_time	(	switch_tone_container_t *	cont,
		int	index
	)

static

Definition at line 3528 of file switch_ivr_async.c.

References switch_tone_detect_t::key, switch_tone_container_t::list, switch_tone_container_t::session, switch_tone_detect_t::start_time, switch_channel_set_variable_name_printf(), switch_core_session_get_channel(), switch_micro_time_now(), switch_mprintf(), and switch_safe_free.

Referenced by tone_detect_callback(), and tone_on_dtmf().

 {
         char *total_time = switch_mprintf("%d", (int)(switch_micro_time_now() - cont->list[index].start_time) / 1000);
 
         switch_channel_set_variable_name_printf(switch_core_session_get_channel(cont->session), total_time, "tone_detect_%s_total_time", 
                                                                                         cont->list[index].key);
         switch_safe_free(total_time);
 }

static switch_status_t tone_on_dtmf	(	switch_core_session_t *	session,
		const switch_dtmf_t *	dtmf,
		switch_dtmf_direction_t	direction
	)

static

Definition at line 3537 of file switch_ivr_async.c.

References switch_tone_detect_t::app, switch_tone_detect_t::callback, switch_tone_detect_t::data, switch_tone_container_t::detect_fax, switch_dtmf_t::digit, switch_tone_container_t::list, switch_tone_container_t::session, switch_channel_api_on(), SWITCH_CHANNEL_API_ON_TONE_DETECT_VARIABLE, switch_channel_execute_on(), SWITCH_CHANNEL_EXECUTE_ON_TONE_DETECT_VARIABLE, switch_channel_get_private(), switch_core_session_execute_application_async(), switch_core_session_get_channel(), SWITCH_STATUS_SUCCESS, and tone_detect_set_total_time().

Referenced by switch_ivr_tone_detect_session().

 {
         switch_channel_t *channel = switch_core_session_get_channel(session);
         switch_tone_container_t *cont = switch_channel_get_private(channel, "_tone_detect_");
         int i;
 
         if (!cont || !cont->detect_fax || dtmf->digit != 'f') {
                 return SWITCH_STATUS_SUCCESS;
         }
 
         i = cont->detect_fax;
 
         tone_detect_set_total_time(cont, i);
         if (cont->list[i].callback) {
                 cont->list[i].callback(cont->session, cont->list[i].app, cont->list[i].data);
         } else {
                 switch_channel_execute_on(switch_core_session_get_channel(cont->session), SWITCH_CHANNEL_EXECUTE_ON_TONE_DETECT_VARIABLE);
                 switch_channel_api_on(switch_core_session_get_channel(cont->session), SWITCH_CHANNEL_API_ON_TONE_DETECT_VARIABLE);
 
                 if (cont->list[i].app) {
                         switch_core_session_execute_application_async(cont->session, cont->list[i].app, cont->list[i].data);
                 }
         }
                 
         return SWITCH_STATUS_SUCCESS;
 
 }

static switch_status_t video_eavesdrop_callback	(	switch_core_session_t *	session,
		switch_frame_t *	frame,
		void *	user_data
	)

static

Definition at line 1603 of file switch_ivr_async.c.

References switch_frame::img, SMBF_SPY_VIDEO_STREAM, SMBF_SPY_VIDEO_STREAM_BLEG, switch_core_media_bug_push_spy_frame(), switch_core_media_bug_test_flag(), SWITCH_RW_READ, SWITCH_RW_WRITE, and SWITCH_STATUS_SUCCESS.

Referenced by eavesdrop_callback().

 {
         switch_media_bug_t *bug = (switch_media_bug_t *) user_data;
 
         if (frame->img) {
                 if (switch_core_media_bug_test_flag(bug, SMBF_SPY_VIDEO_STREAM)) {
                         switch_core_media_bug_push_spy_frame(bug, frame, SWITCH_RW_READ);
                 }
                 
                 if (switch_core_media_bug_test_flag(bug, SMBF_SPY_VIDEO_STREAM_BLEG)) {
                         switch_core_media_bug_push_spy_frame(bug, frame, SWITCH_RW_WRITE);
                 }
         }
 
         return SWITCH_STATUS_SUCCESS;
 }

static switch_bool_t video_write_overlay_callback	(	switch_media_bug_t *	bug,
		void *	user_data,
		switch_abc_type_t	type
	)

static

Definition at line 5093 of file switch_ivr_async.c.

References oht_s::alpha, CF_VIDEO_DECODED_READ, vpx_image::d_h, vpx_image::d_w, switch_frame::img, oht_s::img, oht_s::pos, SWITCH_ABC_TYPE_CLOSE, SWITCH_ABC_TYPE_INIT, SWITCH_ABC_TYPE_WRITE_VIDEO_PING, switch_channel_test_flag(), switch_core_media_bug_get_session(), switch_core_media_bug_get_video_ping_frame(), switch_core_session_get_channel(), SWITCH_FIT_SIZE, switch_img_copy(), switch_img_find_position(), switch_img_fit(), switch_img_free(), switch_img_overlay(), and SWITCH_TRUE.

Referenced by switch_ivr_video_write_overlay_session().

 {
         overly_helper_t *oht = (overly_helper_t *) user_data;
         switch_core_session_t *session = switch_core_media_bug_get_session(bug);
         switch_channel_t *channel = switch_core_session_get_channel(session);
         
         switch (type) {
         case SWITCH_ABC_TYPE_INIT:
                 {                       
                 }
                 break;
         case SWITCH_ABC_TYPE_CLOSE:
                 {
                         switch_img_free(&oht->img);
                 }
                 break;
         case SWITCH_ABC_TYPE_WRITE_VIDEO_PING:
                 if (switch_channel_test_flag(channel, CF_VIDEO_DECODED_READ)) {
                         switch_frame_t *frame = switch_core_media_bug_get_video_ping_frame(bug);
                         int x = 0, y = 0;
                         switch_image_t *oimg = NULL;
 
                         if (frame->img && oht->img) {
                                 switch_img_copy(oht->img, &oimg);
                                 switch_img_fit(&oimg, frame->img->d_w, frame->img->d_h, SWITCH_FIT_SIZE);
                                 switch_img_find_position(oht->pos, frame->img->d_w, frame->img->d_h, oimg->d_w, oimg->d_h, &x, &y);
                                 switch_img_overlay(frame->img, oimg, x, y, oht->alpha);
                                 //switch_img_patch(frame->img, oimg, x, y);
                                 switch_img_free(&oimg);
                         }
                 }
                 break;
         default:
                 break;
         }
 
         return SWITCH_TRUE;
 }

static switch_bool_t write_displace_callback	(	switch_media_bug_t *	bug,
		void *	user_data,
		switch_abc_type_t	type
	)

static

Definition at line 731 of file switch_ivr_async.c.

References buf, switch_file_handle::channels, switch_frame::data, switch_frame::datalen, displace_helper_t::fh, displace_helper_t::file, displace_helper_t::loop, memset(), displace_helper_t::mux, switch_frame::samples, SWITCH_ABC_TYPE_CLOSE, SWITCH_ABC_TYPE_INIT, SWITCH_ABC_TYPE_READ_REPLACE, SWITCH_ABC_TYPE_WRITE, SWITCH_ABC_TYPE_WRITE_REPLACE, switch_channel_set_private(), switch_core_file_close(), switch_core_file_read(), switch_core_file_seek(), switch_core_media_bug_get_read_replace_frame(), switch_core_media_bug_get_session(), switch_core_media_bug_get_write_replace_frame(), switch_core_media_bug_set_read_replace_frame(), switch_core_media_bug_set_write_replace_frame(), switch_core_session_get_channel(), SWITCH_FALSE, switch_normalize_to_16bit, SWITCH_RECOMMENDED_BUFFER_SIZE, SWITCH_STATUS_SUCCESS, and SWITCH_TRUE.

Referenced by switch_ivr_displace_session().

 {
         displace_helper_t *dh = (displace_helper_t *) user_data;
 
         switch (type) {
         case SWITCH_ABC_TYPE_INIT:
                 break;
         case SWITCH_ABC_TYPE_CLOSE:
                 if (dh) {
                         switch_core_session_t *session = switch_core_media_bug_get_session(bug);
                         switch_channel_t *channel;
 
                         switch_core_file_close(&dh->fh);
 
                         if (session && (channel = switch_core_session_get_channel(session))) {
                                 switch_channel_set_private(channel, dh->file, NULL);
                         }
                 }
                 break;
         case SWITCH_ABC_TYPE_READ_REPLACE:
                 {
                         switch_frame_t *rframe = switch_core_media_bug_get_read_replace_frame(bug);
                         if (dh && !dh->mux) {
                                 memset(rframe->data, 255, rframe->datalen);
                         }
                         switch_core_media_bug_set_read_replace_frame(bug, rframe);
                 }
                 break;
         case SWITCH_ABC_TYPE_WRITE_REPLACE:
                 if (dh) {
                         switch_frame_t *rframe = NULL;
                         switch_size_t len;
                         switch_status_t st;
 
                         rframe = switch_core_media_bug_get_write_replace_frame(bug);
                         len = rframe->samples;
 
                         if (dh->mux) {
                                 int16_t buf[SWITCH_RECOMMENDED_BUFFER_SIZE];
                                 int16_t *fp = rframe->data;
                                 uint32_t x;
 
                                 st = switch_core_file_read(&dh->fh, buf, &len);
 
                                 for (x = 0; x < (uint32_t) len * dh->fh.channels; x++) {
                                         int32_t mixed = fp[x] + buf[x];
                                         switch_normalize_to_16bit(mixed);
                                         fp[x] = (int16_t) mixed;
                                 }
                         } else {
                                 st = switch_core_file_read(&dh->fh, rframe->data, &len);
                                 if (len < rframe->samples) {
                                         memset((char *)rframe->data + (len * 2 * dh->fh.channels), 0, (rframe->samples - len) * 2 * dh->fh.channels);
                                 }
                         }
 
                         rframe->datalen = rframe->samples * 2 * dh->fh.channels;
 
                         if (st != SWITCH_STATUS_SUCCESS || len == 0) {
                                 if (dh->loop) {
                                         uint32_t pos = 0;
                                         switch_core_file_seek(&dh->fh, &pos, 0, SEEK_SET);
                                 } else {
                                         switch_core_session_t *session = switch_core_media_bug_get_session(bug);
                                         switch_channel_t *channel;
 
                                         if (session && (channel = switch_core_session_get_channel(session))) {
                                                 switch_channel_set_private(channel, dh->file, NULL);
                                         }
                                         return SWITCH_FALSE;
                                 }
                         }
 
                         switch_core_media_bug_set_write_replace_frame(bug, rframe);
                 }
                 break;
         case SWITCH_ABC_TYPE_WRITE:
         default:
                 break;
         }
 
         return SWITCH_TRUE;
 }

Data Structures

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation