Media Bugs

Collaboration diagram for Media Bugs:

Macros
#define	switch_core_session_get_name(_s)   switch_channel_get_name(switch_core_session_get_channel(_s))
#define	switch_core_media_bug_remove_all(_s)   switch_core_media_bug_remove_all_function(_s, NULL)

Functions
void	switch_core_screen_size (int *x, int *y)
void	switch_core_session_sched_heartbeat (switch_core_session_t *session, uint32_t seconds)
void	switch_core_session_unsched_heartbeat (switch_core_session_t *session)
void	switch_core_session_enable_heartbeat (switch_core_session_t *session, uint32_t seconds)
void	switch_core_session_disable_heartbeat (switch_core_session_t *session)
switch_status_t	switch_core_media_bug_pop (switch_core_session_t *orig_session, const char *function, switch_media_bug_t **pop)
switch_status_t	switch_core_media_bug_exec_all (switch_core_session_t *orig_session, const char *function, switch_media_bug_exec_cb_t cb, void *user_data)
uint32_t	switch_core_media_bug_patch_video (switch_core_session_t *orig_session, switch_frame_t *frame)
uint32_t	switch_core_media_bug_count (switch_core_session_t *orig_session, const char *function)
void	switch_media_bug_set_spy_fmt (switch_media_bug_t *bug, switch_vid_spy_fmt_t spy_fmt)
switch_status_t	switch_core_media_bug_push_spy_frame (switch_media_bug_t *bug, switch_frame_t *frame, switch_rw_t rw)
switch_status_t	switch_core_media_bug_patch_spy_frame (switch_media_bug_t *bug, switch_image_t *img, switch_rw_t rw)
switch_vid_spy_fmt_t	switch_media_bug_parse_spy_fmt (const char *name)
switch_status_t	switch_core_media_bug_add (_In_ switch_core_session_t *session, _In_ const char *function, _In_ const char *target, _In_ switch_media_bug_callback_t callback, _In_opt_ void *user_data, _In_ time_t stop_time, _In_ switch_media_bug_flag_t flags, _Out_ switch_media_bug_t **new_bug)
	Add a media bug to the session. More...
void	switch_core_media_bug_pause (switch_core_session_t *session)
	Pause a media bug on the session. More...
void	switch_core_media_bug_resume (switch_core_session_t *session)
	Resume a media bug on the session. More...
void	switch_core_media_bug_inuse (switch_media_bug_t *bug, switch_size_t *readp, switch_size_t *writep)
void *	switch_core_media_bug_get_user_data (_In_ switch_media_bug_t *bug)
	Obtain private data from a media bug. More...
switch_frame_t *	switch_core_media_bug_get_write_replace_frame (_In_ switch_media_bug_t *bug)
	Obtain a replace frame from a media bug. More...
switch_frame_t *	switch_core_media_bug_get_native_read_frame (switch_media_bug_t *bug)
switch_frame_t *	switch_core_media_bug_get_native_write_frame (switch_media_bug_t *bug)
switch_frame_t *	switch_core_media_bug_get_video_ping_frame (switch_media_bug_t *bug)
void	switch_core_media_bug_set_write_replace_frame (_In_ switch_media_bug_t *bug, _In_ switch_frame_t *frame)
	Set a return replace frame. More...
switch_frame_t *	switch_core_media_bug_get_read_replace_frame (_In_ switch_media_bug_t *bug)
	Obtain a replace frame from a media bug. More...
void	switch_core_media_bug_set_read_demux_frame (_In_ switch_media_bug_t *bug, _In_ switch_frame_t *frame)
switch_core_session_t *	switch_core_media_bug_get_session (_In_ switch_media_bug_t *bug)
	Obtain the session from a media bug. More...
uint32_t	switch_core_media_bug_test_flag (_In_ switch_media_bug_t *bug, _In_ uint32_t flag)
	Test for the existance of a flag on an media bug. More...
uint32_t	switch_core_media_bug_set_flag (_In_ switch_media_bug_t *bug, _In_ uint32_t flag)
uint32_t	switch_core_media_bug_clear_flag (_In_ switch_media_bug_t *bug, _In_ uint32_t flag)
void	switch_core_media_bug_set_read_replace_frame (_In_ switch_media_bug_t *bug, _In_ switch_frame_t *frame)
	Set a return replace frame. More...
uint32_t	switch_core_cpu_count (void)
switch_status_t	switch_core_media_bug_remove (_In_ switch_core_session_t *session, _Inout_ switch_media_bug_t **bug)
	Remove a media bug from the session. More...
uint32_t	switch_core_media_bug_prune (switch_core_session_t *session)
switch_status_t	switch_core_media_bug_remove_callback (switch_core_session_t *session, switch_media_bug_callback_t callback)
	Remove media bug callback. More...
switch_status_t	switch_core_media_bug_close (_Inout_ switch_media_bug_t **bug)
	Close and destroy a media bug. More...
switch_status_t	switch_core_media_bug_remove_all_function (_In_ switch_core_session_t *session, const char *function)
	Remove all media bugs from the session. More...
switch_status_t	switch_core_media_bug_enumerate (switch_core_session_t *session, switch_stream_handle_t *stream)
switch_status_t	switch_core_media_bug_transfer_recordings (switch_core_session_t *orig_session, switch_core_session_t *new_session)
switch_status_t	switch_core_media_bug_transfer_callback (switch_core_session_t *orig_session, switch_core_session_t *new_session, switch_media_bug_callback_t callback, void *(*user_data_dup_func)(switch_core_session_t *, void *))
switch_status_t	switch_core_media_bug_read (_In_ switch_media_bug_t *bug, _In_ switch_frame_t *frame, switch_bool_t fill)
	Read a frame from the bug. More...
void	switch_core_media_bug_flush (_In_ switch_media_bug_t *bug)
	Flush the read and write buffers for the bug. More...
switch_status_t	switch_core_media_bug_flush_all (_In_ switch_core_session_t *session)
	Flush the read/write buffers for all media bugs on the session. More...
switch_status_t	switch_core_media_bug_set_pre_buffer_framecount (switch_media_bug_t *bug, uint32_t framecount)

Detailed Description

Macro Definition Documentation

#define switch_core_media_bug_remove_all

(

_s

)

switch_core_media_bug_remove_all_function(_s, NULL)

Definition at line 404 of file switch_core.h.

Referenced by switch_core_session_hangup_state(), switch_core_session_perform_destroy(), and switch_core_session_thread().

#define switch_core_session_get_name

(

_s

)

switch_channel_get_name(switch_core_session_get_channel(_s))

Definition at line 271 of file switch_core.h.

Referenced by check_channel_status(), eavesdrop_callback(), switch_core_media_bug_transfer_callback(), switch_core_media_bug_transfer_recordings(), switch_core_session_read_frame(), switch_core_session_run(), switch_core_session_start_video_thread(), and switch_core_session_write_video_frame().

Function Documentation

uint32_t switch_core_cpu_count

(

void

)

Definition at line 1042 of file switch_core.c.

References switch_runtime::cpu_count.

Referenced by switch_core_media_init(), and switch_event_init().

{
        return runtime.cpu_count;
}

switch_status_t switch_core_media_bug_add	(	_In_ switch_core_session_t *	session,
		_In_ const char *	function,
		_In_ const char *	target,
		_In_ switch_media_bug_callback_t	callback,
		_In_opt_ void *	user_data,
		_In_ time_t	stop_time,
		_In_ switch_media_bug_flag_t	flags,
		_Out_ switch_media_bug_t **	new_bug
	)

Add a media bug to the session.

Parameters

session	the session to add the bug to
callback	a callback for events
user_data	arbitrary user data
stop_time	absolute time at which the bug is automatically removed (or 0)
flags	flags to choose the stream
new_bug	pointer to assign new bug to

Returns

SWITCH_STATUS_SUCCESS if the operation was a success

Referenced by switch_ivr_detect_speech_init(), switch_ivr_displace_session(), switch_ivr_eavesdrop_session(), switch_ivr_inband_dtmf_generate_session(), switch_ivr_inband_dtmf_session(), switch_ivr_preprocess_session(), switch_ivr_record_session(), switch_ivr_session_audio(), switch_ivr_tone_detect_session(), and switch_ivr_video_write_overlay_session().

uint32_t switch_core_media_bug_clear_flag	(	_In_ switch_media_bug_t *	bug,
		_In_ uint32_t	flag
	)

Referenced by switch_ivr_eavesdrop_session(), and switch_ivr_record_session_mask().

switch_status_t switch_core_media_bug_close

(

_Inout_ switch_media_bug_t **

bug

)

Close and destroy a media bug.

Parameters

bug	bug to remove

Returns

SWITCH_STATUS_SUCCESS if the operation was a success

uint32_t switch_core_media_bug_count	(	switch_core_session_t *	orig_session,
		const char *	function
	)

Definition at line 994 of file switch_core_media_bug.c.

References switch_media_bug::function, switch_media_bug::next, SMBF_LOCK, SMBF_PRUNE, switch_test_flag, switch_thread_rwlock_rdlock(), and switch_thread_rwlock_unlock().

{
        switch_media_bug_t *bp;
        uint32_t x = 0;

        if (orig_session->bugs) {
                switch_thread_rwlock_rdlock(orig_session->bug_rwlock);
                for (bp = orig_session->bugs; bp; bp = bp->next) {
                        if (!switch_test_flag(bp, SMBF_PRUNE) && !switch_test_flag(bp, SMBF_LOCK) && !strcmp(bp->function, function)) {
                                x++;
                        }
                }
                switch_thread_rwlock_unlock(orig_session->bug_rwlock);
        }

        return x;
}

switch_status_t switch_core_media_bug_enumerate	(	switch_core_session_t *	session,
		switch_stream_handle_t *	stream
	)

Definition at line 1069 of file switch_core_media_bug.c.

References switch_media_bug::function, switch_media_bug::next, SWITCH_STATUS_SUCCESS, switch_thread_rwlock_rdlock(), switch_thread_rwlock_unlock(), switch_thread_self(), switch_media_bug::target, and switch_media_bug::thread_id.

{
        switch_media_bug_t *bp;

        stream->write_function(stream, "<media-bugs>\n");

        if (session->bugs) {
                switch_thread_rwlock_rdlock(session->bug_rwlock);
                for (bp = session->bugs; bp; bp = bp->next) {
                        int thread_locked = (bp->thread_id && bp->thread_id == switch_thread_self());
                        stream->write_function(stream, 
                                                                   " <media-bug>\n"
                                                                   "  <function>%s</function>\n"
                                                                   "  <target>%s</target>\n"
                                                                   "  <thread-locked>%d</thread-locked>\n"
                                                                   " </media-bug>\n", 
                                                                   bp->function, bp->target, thread_locked);

                }
                switch_thread_rwlock_unlock(session->bug_rwlock);
        }

        stream->write_function(stream, "</media-bugs>\n");
        
        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_core_media_bug_exec_all	(	switch_core_session_t *	orig_session,
		const char *	function,
		switch_media_bug_exec_cb_t	cb,
		void *	user_data
	)

Definition at line 1047 of file switch_core_media_bug.c.

References switch_media_bug::function, switch_media_bug::next, SMBF_LOCK, SMBF_PRUNE, switch_assert, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_test_flag, switch_thread_rwlock_unlock(), and switch_thread_rwlock_wrlock().

Referenced by switch_ivr_eavesdrop_exec_all(), and switch_ivr_eavesdrop_update_display().

{
        switch_media_bug_t *bp;
        int x = 0;

        switch_assert(cb);

        if (orig_session->bugs) {
                switch_thread_rwlock_wrlock(orig_session->bug_rwlock);
                for (bp = orig_session->bugs; bp; bp = bp->next) {
                        if (!switch_test_flag(bp, SMBF_PRUNE) && !switch_test_flag(bp, SMBF_LOCK) && !strcmp(bp->function, function)) {
                                cb(bp, user_data);
                                x++;
                        }
                }
                switch_thread_rwlock_unlock(orig_session->bug_rwlock);
        }

        return x ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
}

void switch_core_media_bug_flush

(

_In_ switch_media_bug_t *

bug

)

Flush the read and write buffers for the bug.

Parameters

bug	the bug to flush the read and write buffers on

switch_status_t switch_core_media_bug_flush_all

(

_In_ switch_core_session_t *

session

)

Flush the read/write buffers for all media bugs on the session.

Parameters

session

the session to flush the read/write buffers for all media bugs on the session

Referenced by switch_core_session_perform_receive_message(), and switch_core_session_write_frame().

switch_frame_t* switch_core_media_bug_get_native_read_frame

(

switch_media_bug_t *

bug

)

Definition at line 111 of file switch_core_media_bug.c.

Referenced by record_callback().

{
        return bug->native_read_frame;
}

switch_frame_t* switch_core_media_bug_get_native_write_frame

(

switch_media_bug_t *

bug

)

Definition at line 116 of file switch_core_media_bug.c.

Referenced by record_callback().

{
        return bug->native_write_frame;
}

switch_frame_t* switch_core_media_bug_get_read_replace_frame

(

_In_ switch_media_bug_t *

bug

)

Obtain a replace frame from a media bug.

Parameters

bug	the bug to get the data from

Referenced by eavesdrop_callback(), inband_dtmf_callback(), inband_dtmf_generate_callback(), preprocess_callback(), read_displace_callback(), session_audio_callback(), tone_detect_callback(), and write_displace_callback().

switch_core_session_t* switch_core_media_bug_get_session

(

_In_ switch_media_bug_t *

bug

)

Obtain the session from a media bug.

Parameters

bug	the bug to get the data from

Referenced by eavesdrop_callback(), inband_dtmf_callback(), inband_dtmf_generate_callback(), preprocess_callback(), read_displace_callback(), record_callback(), recording_thread(), session_audio_callback(), speech_callback(), tone_detect_callback(), video_write_overlay_callback(), and write_displace_callback().

void* switch_core_media_bug_get_user_data

(

_In_ switch_media_bug_t *

bug

)

Obtain private data from a media bug.

Parameters

bug	the bug to get the data from

Returns

the private data

Referenced by display_exec_cb(), exec_cb(), generate_on_dtmf(), recording_thread(), switch_ivr_eavesdrop_pop_eavesdropper(), and switch_ivr_session_audio().

switch_frame_t* switch_core_media_bug_get_video_ping_frame

(

switch_media_bug_t *

bug

)

Definition at line 91 of file switch_core_media_bug.c.

Referenced by video_write_overlay_callback().

{
        return bug->video_ping_frame;
}

switch_frame_t* switch_core_media_bug_get_write_replace_frame

(

_In_ switch_media_bug_t *

bug

)

Obtain a replace frame from a media bug.

Parameters

bug	the bug to get the data from

Referenced by eavesdrop_callback(), inband_dtmf_generate_callback(), preprocess_callback(), read_displace_callback(), session_audio_callback(), tone_detect_callback(), and write_displace_callback().

void switch_core_media_bug_inuse	(	switch_media_bug_t *	bug,
		switch_size_t *	readp,
		switch_size_t *	writep
	)

Definition at line 157 of file switch_core_media_bug.c.

References SMBF_READ_STREAM, SMBF_WRITE_STREAM, switch_buffer_inuse(), switch_mutex_lock(), switch_mutex_unlock(), and switch_test_flag.

{
        if (switch_test_flag(bug, SMBF_READ_STREAM)) {
                switch_mutex_lock(bug->read_mutex);
                *readp = bug->raw_read_buffer ? switch_buffer_inuse(bug->raw_read_buffer) : 0;
                switch_mutex_unlock(bug->read_mutex);
        } else {
                *readp = 0;
        }

        if (switch_test_flag(bug, SMBF_WRITE_STREAM)) {
                switch_mutex_lock(bug->write_mutex);
                *writep = bug->raw_write_buffer ? switch_buffer_inuse(bug->raw_write_buffer) : 0;
                switch_mutex_unlock(bug->write_mutex);
        } else {
                *writep = 0;
        }
}

switch_status_t switch_core_media_bug_patch_spy_frame	(	switch_media_bug_t *	bug,
		switch_image_t *	img,
		switch_rw_t	rw
	)

Definition at line 416 of file switch_core_media_bug.c.

References vpx_image::d_h, vpx_image::d_w, POS_CENTER_MID, SPY_DUAL_CROP, SPY_LOWER_RIGHT_LARGE, SPY_LOWER_RIGHT_SMALL, switch_color_set_rgb(), SWITCH_CORE_QUEUE_LEN, switch_core_session_get_pool(), SWITCH_FIT_SIZE, switch_img_copy(), switch_img_copy_rect(), switch_img_fill(), switch_img_find_position(), switch_img_fit(), switch_img_free(), switch_img_patch(), switch_img_scale(), switch_queue_create(), switch_queue_size(), switch_queue_trypop(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_session_read_video_frame(), and switch_core_session_write_video_frame().

{
        switch_queue_t *spy_q = NULL;
        int w = 0, h = 0;
        switch_status_t status;
        void *pop;
        int i;

        for (i = 0; i < 2; i++) {
                if (!bug->spy_video_queue[i]) {
                        switch_queue_create(&bug->spy_video_queue[i], SWITCH_CORE_QUEUE_LEN, switch_core_session_get_pool(bug->session));
                }
        }
        
        spy_q = bug->spy_video_queue[rw];

        while(switch_queue_size(spy_q) > 0) {
                if ((status = switch_queue_trypop(spy_q, &pop)) == SWITCH_STATUS_SUCCESS) {
                        switch_img_free(&bug->spy_img[rw]);
                        if (!(bug->spy_img[rw] = (switch_image_t *) pop)) {
                                break;
                        }
                }
        }

        w = img->d_w;
        h = img->d_h;

        if (bug->spy_img[rw]) {

                switch (bug->spy_fmt) {
                case SPY_DUAL_CROP:
                        {
                                switch_image_t *spy_tmp = NULL;
                                switch_image_t *img_tmp = NULL;
                                switch_image_t *img_dup = NULL;
                                int x = 0, y = 0;
                                float aspect169 = (float)1920 / 1080;
                                switch_rgb_color_t bgcolor = { 0 };

                                if ((float)w/h == aspect169) {
                                        if ((float)bug->spy_img[rw]->d_w / bug->spy_img[rw]->d_h == aspect169) {
                                                spy_tmp = switch_img_copy_rect(bug->spy_img[rw], bug->spy_img[rw]->d_w / 4, 0, bug->spy_img[rw]->d_w / 2, bug->spy_img[rw]->d_h);
                                                
                                        } else {
                                                switch_img_copy(bug->spy_img[rw], &spy_tmp);
                                        }
                                } else {
                                        if ((float)bug->spy_img[rw]->d_w / bug->spy_img[rw]->d_h == aspect169) {
                                                spy_tmp = switch_img_copy_rect(bug->spy_img[rw], bug->spy_img[rw]->d_w / 6, 0, bug->spy_img[rw]->d_w / 4, bug->spy_img[rw]->d_h);
                                        } else {
                                                spy_tmp = switch_img_copy_rect(bug->spy_img[rw], bug->spy_img[rw]->d_w / 4, 0, bug->spy_img[rw]->d_w / 2, bug->spy_img[rw]->d_h);
                                        }
                                }

                                switch_img_copy(img, &img_dup);
                                img_tmp = switch_img_copy_rect(img_dup, w / 4, 0, w / 2, h);

                                switch_img_fit(&spy_tmp, w / 2, h, SWITCH_FIT_SIZE);
                                switch_img_fit(&img_tmp, w / 2, h, SWITCH_FIT_SIZE);

                                switch_color_set_rgb(&bgcolor, "#000000");
                                switch_img_fill(img, 0, 0, img->d_w, img->d_h, &bgcolor);

                                switch_img_find_position(POS_CENTER_MID, w / 2, h, img_tmp->d_w, img_tmp->d_h, &x, &y);
                                switch_img_patch(img, img_tmp, x, y);

                                switch_img_find_position(POS_CENTER_MID, w / 2, h, spy_tmp->d_w, spy_tmp->d_h, &x, &y);
                                switch_img_patch(img, spy_tmp, x + w / 2, y);


                                switch_img_free(&img_tmp);
                                switch_img_free(&img_dup);
                                switch_img_free(&spy_tmp);
                        }
                        break;
                case SPY_LOWER_RIGHT_SMALL:
                case SPY_LOWER_RIGHT_LARGE:
                default:
                        {
                                float scaler = 0.125f;
                                int spyw, spyh;

                                if (bug->spy_fmt == SPY_LOWER_RIGHT_LARGE) {
                                        scaler = 0.25f;
                                }

                                spyw = (int) (float)w * scaler;
                                spyh = (int) (float)h * scaler;
                                
                                if (bug->spy_img[rw]->d_w != spyw || bug->spy_img[rw]->d_h != spyh) {
                                        switch_image_t *tmp_img = NULL;
                                        
                                        switch_img_scale(bug->spy_img[rw], &tmp_img, spyw, spyh);
                                        switch_img_free(&bug->spy_img[rw]);
                                        bug->spy_img[rw] = tmp_img;
                                }

                                switch_img_patch(img, bug->spy_img[rw], w - spyw, h - spyh);
                        }
                        break;
                }

                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;
}

uint32_t switch_core_media_bug_patch_video	(	switch_core_session_t *	orig_session,
		switch_frame_t *	frame
	)

Definition at line 1012 of file switch_core_media_bug.c.

References switch_media_bug::callback, switch_media_bug::function, switch_media_bug::next, switch_media_bug::ready, SMBF_LOCK, SMBF_PRUNE, SMBF_VIDEO_PATCH, switch_media_bug::stop_time, SWITCH_ABC_TYPE_VIDEO_PATCH, switch_core_media_bug_prune(), switch_epoch_time_now(), SWITCH_FALSE, switch_set_flag, switch_test_flag, switch_thread_rwlock_rdlock(), switch_thread_rwlock_unlock(), SWITCH_TRUE, switch_media_bug::user_data, and switch_media_bug::video_ping_frame.

{
        switch_media_bug_t *bp;
        uint32_t x = 0, ok = SWITCH_TRUE, prune = 0;

        if (orig_session->bugs) {
                switch_thread_rwlock_rdlock(orig_session->bug_rwlock);
                for (bp = orig_session->bugs; bp; bp = bp->next) {
                        if (!switch_test_flag(bp, SMBF_PRUNE) && !switch_test_flag(bp, SMBF_LOCK) && !strcmp(bp->function, "patch:video")) {
                                if (bp->ready && frame->img && switch_test_flag(bp, SMBF_VIDEO_PATCH)) {
                                        bp->video_ping_frame = frame;
                                        if (bp->callback) {
                                                if (bp->callback(bp, bp->user_data, SWITCH_ABC_TYPE_VIDEO_PATCH) == SWITCH_FALSE
                                                        || (bp->stop_time && bp->stop_time <= switch_epoch_time_now(NULL))) {
                                                        ok = SWITCH_FALSE;
                                                }
                                        }
                                        bp->video_ping_frame = NULL;
                                }

                                if (ok == SWITCH_FALSE) {
                                        switch_set_flag(bp, SMBF_PRUNE);
                                        prune++;
                                } else x++;
                        }
                }
                switch_thread_rwlock_unlock(orig_session->bug_rwlock);
                if (prune) {
                        switch_core_media_bug_prune(orig_session);
                }
        }

        return x;
}

void switch_core_media_bug_pause

(

switch_core_session_t *

session

)

Pause a media bug on the session.

Parameters

session

the session to pause the bug on sets CF_PAUSE_BUGS flag

Definition at line 58 of file switch_core_media_bug.c.

References CF_PAUSE_BUGS, and switch_channel_set_flag.

{
        switch_channel_set_flag(session->channel, CF_PAUSE_BUGS);
}

switch_status_t switch_core_media_bug_pop	(	switch_core_session_t *	orig_session,
		const char *	function,
		switch_media_bug_t **	pop
	)

Definition at line 968 of file switch_core_media_bug.c.

References switch_media_bug::function, switch_media_bug::next, SMBF_LOCK, switch_set_flag, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_rwlock_unlock(), and switch_thread_rwlock_wrlock().

Referenced by switch_ivr_eavesdrop_pop_eavesdropper().

{
        switch_media_bug_t *bp;

        if (orig_session->bugs) {
                switch_thread_rwlock_wrlock(orig_session->bug_rwlock);
                for (bp = orig_session->bugs; bp; bp = bp->next) {
                        if (!strcmp(bp->function, function)) {
                                switch_set_flag(bp, SMBF_LOCK);
                                break;
                        }
                }
                switch_thread_rwlock_unlock(orig_session->bug_rwlock);

                if (bp) {
                        *pop = bp;
                        return SWITCH_STATUS_SUCCESS;
                } else {
                        *pop = NULL;
                }
        }

        return SWITCH_STATUS_FALSE;
}

uint32_t switch_core_media_bug_prune

(

switch_core_session_t *

session

)

Definition at line 1253 of file switch_core_media_bug.c.

References switch_media_bug::next, SMBF_LOCK, SMBF_PRUNE, switch_clear_flag, switch_core_codec_destroy(), switch_core_codec_ready(), switch_core_media_bug_close(), switch_core_media_bug_test_flag(), switch_thread_rwlock_unlock(), switch_thread_rwlock_wrlock(), and switch_media_bug::thread_id.

Referenced by perform_write(), switch_core_media_bug_patch_video(), switch_core_session_read_frame(), switch_core_session_read_video_frame(), switch_core_session_write_frame(), and switch_core_session_write_video_frame().

{
        switch_media_bug_t *bp = NULL, *last = NULL;
        int ttl = 0;


  top:

        switch_thread_rwlock_wrlock(session->bug_rwlock);
        if (session->bugs) {
                for (bp = session->bugs; bp; bp = bp->next) {
                        if (switch_core_media_bug_test_flag(bp, SMBF_PRUNE)) {
                                if (last) {
                                        last->next = bp->next;
                                } else {
                                        session->bugs = bp->next;
                                }
                                break;
                        }

                        last = bp;
                }
        }

        if (!session->bugs && switch_core_codec_ready(&session->bug_codec)) {
                switch_core_codec_destroy(&session->bug_codec);
        }

        switch_thread_rwlock_unlock(session->bug_rwlock);

        if (bp) {
                switch_clear_flag(bp, SMBF_LOCK);
                bp->thread_id = 0;
                switch_core_media_bug_close(&bp);
                ttl++;
                goto top;
        }
        
        return ttl;
}

switch_status_t switch_core_media_bug_push_spy_frame	(	switch_media_bug_t *	bug,
		switch_frame_t *	frame,
		switch_rw_t	rw
	)

Definition at line 645 of file switch_core_media_bug.c.

References switch_assert, switch_img_copy(), switch_queue_push(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by video_eavesdrop_callback().

{

        switch_assert(bug);
        switch_assert(frame);

        if (bug->spy_video_queue[rw] && frame->img) {
                switch_image_t *img = NULL;

                switch_img_copy(frame->img, &img);

                if (img) {
                        switch_queue_push(bug->spy_video_queue[rw], img);
                        return SWITCH_STATUS_SUCCESS;
                }
        }

        return SWITCH_STATUS_FALSE;
}

switch_status_t switch_core_media_bug_read	(	_In_ switch_media_bug_t *	bug,
		_In_ switch_frame_t *	frame,
		switch_bool_t	fill
	)

Read a frame from the bug.

Parameters

bug	the bug to read from
frame	the frame to write the data to

Returns

the amount of data

Referenced by eavesdrop_callback(), record_callback(), and speech_callback().

switch_status_t switch_core_media_bug_remove	(	_In_ switch_core_session_t *	session,
		_Inout_ switch_media_bug_t **	bug
	)

Remove a media bug from the session.

Parameters

session	the session to remove the bug from
bug	bug to remove

Returns

SWITCH_STATUS_SUCCESS if the operation was a success

Referenced by switch_ivr_eavesdrop_session(), switch_ivr_stop_detect_speech(), switch_ivr_stop_displace_session(), switch_ivr_stop_inband_dtmf_generate_session(), switch_ivr_stop_inband_dtmf_session(), switch_ivr_stop_record_session(), switch_ivr_stop_session_audio(), switch_ivr_stop_tone_detect_session(), and switch_ivr_stop_video_write_overlay_session().

switch_status_t switch_core_media_bug_remove_all_function	(	_In_ switch_core_session_t *	session,
		const char *	function
	)

Remove all media bugs from the session.

Parameters

session

the session to remove the bugs from

Returns

SWITCH_STATUS_SUCCESS if the operation was a success

switch_status_t switch_core_media_bug_remove_callback	(	switch_core_session_t *	session,
		switch_media_bug_callback_t	callback
	)

Remove media bug callback.

Parameters

bug	bug to remove
callback	callback to remove

Returns

SWITCH_STATUS_SUCCESS if the operation was a success

Definition at line 1295 of file switch_core_media_bug.c.

References switch_media_bug::callback, cur, switch_media_bug::next, switch_media_bug::ready, switch_core_codec_destroy(), switch_core_codec_ready(), switch_core_media_bug_close(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_rwlock_unlock(), switch_thread_rwlock_wrlock(), switch_thread_self(), and switch_media_bug::thread_id.

Referenced by switch_ivr_stop_record_session().

{
        switch_media_bug_t *cur = NULL, *bp = NULL, *last = NULL;
        int total = 0;

        switch_thread_rwlock_wrlock(session->bug_rwlock);
        if (session->bugs) {
                bp = session->bugs;
                while (bp) {
                        cur = bp;
                        bp = bp->next;

                        if ((!cur->thread_id || cur->thread_id == switch_thread_self()) && cur->ready && cur->callback == callback) {
                                if (last) {
                                        last->next = cur->next;
                                } else {
                                        session->bugs = cur->next;
                                }
                                if (switch_core_media_bug_close(&cur) == SWITCH_STATUS_SUCCESS) {
                                        total++;
                                }
                        } else {
                                last = cur;
                        }
                }
        }

        if (!session->bugs && switch_core_codec_ready(&session->bug_codec)) {
                switch_core_codec_destroy(&session->bug_codec);
        }

        switch_thread_rwlock_unlock(session->bug_rwlock);


        return total ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
}

void switch_core_media_bug_resume

(

switch_core_session_t *

session

)

Resume a media bug on the session.

Parameters

session

the session to resume the bug on, clears CF_PAUSE_BUGS flag

Definition at line 63 of file switch_core_media_bug.c.

References CF_PAUSE_BUGS, and switch_channel_clear_flag().

{
        switch_channel_clear_flag(session->channel, CF_PAUSE_BUGS);
}

uint32_t switch_core_media_bug_set_flag	(	_In_ switch_media_bug_t *	bug,
		_In_ uint32_t	flag
	)

Referenced by record_callback(), switch_ivr_eavesdrop_pop_eavesdropper(), switch_ivr_eavesdrop_session(), switch_ivr_record_session_mask(), and switch_ivr_session_audio().

switch_status_t switch_core_media_bug_set_pre_buffer_framecount	(	switch_media_bug_t *	bug,
		uint32_t	framecount
	)

Definition at line 176 of file switch_core_media_bug.c.

References SWITCH_STATUS_SUCCESS.

Referenced by switch_ivr_record_session().

{
        bug->record_pre_buffer_max = framecount;

        return SWITCH_STATUS_SUCCESS;
}

void switch_core_media_bug_set_read_demux_frame	(	_In_ switch_media_bug_t *	bug,
		_In_ switch_frame_t *	frame
	)

Referenced by eavesdrop_callback().

void switch_core_media_bug_set_read_replace_frame	(	_In_ switch_media_bug_t *	bug,
		_In_ switch_frame_t *	frame
	)

Set a return replace frame.

Parameters

bug	the bug to set the frame on
frame	the frame to set

Referenced by eavesdrop_callback(), inband_dtmf_callback(), inband_dtmf_generate_callback(), read_displace_callback(), session_audio_callback(), and write_displace_callback().

void switch_core_media_bug_set_write_replace_frame	(	_In_ switch_media_bug_t *	bug,
		_In_ switch_frame_t *	frame
	)

Set a return replace frame.

Parameters

bug	the bug to set the frame on
frame	the frame to set

Referenced by eavesdrop_callback(), inband_dtmf_generate_callback(), read_displace_callback(), session_audio_callback(), and write_displace_callback().

uint32_t switch_core_media_bug_test_flag	(	_In_ switch_media_bug_t *	bug,
		_In_ uint32_t	flag
	)

Test for the existance of a flag on an media bug.

Parameters

bug	the object to test
flag	the or'd list of flags to test

Returns

true value if the object has the flags defined

Referenced by eavesdrop_callback(), perform_write(), record_callback(), recording_thread(), switch_core_session_read_frame(), switch_core_session_read_video_frame(), switch_core_session_write_frame(), switch_core_session_write_video_frame(), switch_ivr_eavesdrop_session(), and video_eavesdrop_callback().

switch_status_t switch_core_media_bug_transfer_callback	(	switch_core_session_t *	orig_session,
		switch_core_session_t *	new_session,
		switch_media_bug_callback_t	callback,
		void *(*)(switch_core_session_t *, void *)	user_data_dup_func
	)

Definition at line 925 of file switch_core_media_bug.c.

References cur, SWITCH_CHANNEL_SESSION_LOG, switch_core_codec_destroy(), switch_core_codec_ready(), switch_core_media_bug_add(), switch_core_media_bug_destroy(), switch_core_session_get_name, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_rwlock_unlock(), and switch_thread_rwlock_wrlock().

Referenced by switch_ivr_transfer_recordings().

{
        switch_media_bug_t *new_bug = NULL, *cur = NULL, *bp = NULL, *last = NULL;
        int total = 0;

        switch_thread_rwlock_wrlock(orig_session->bug_rwlock);
        bp = orig_session->bugs;
        while (bp) {
                cur = bp;
                bp = bp->next;
                
                if (cur->callback == callback) {
                        if (last) {
                                last->next = cur->next;
                        } else {
                                orig_session->bugs = cur->next;
                        }

                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(orig_session), SWITCH_LOG_DEBUG, "Transfering %s from %s to %s\n", cur->target,
                                                          switch_core_session_get_name(orig_session), switch_core_session_get_name(new_session));

                        switch_core_media_bug_add(new_session, cur->function, cur->target, cur->callback,
                                                                          user_data_dup_func(new_session, cur->user_data),
                                                                          cur->stop_time, cur->flags, &new_bug);
                        switch_core_media_bug_destroy(cur);
                        total++;
                } else {
                        last = cur;
                }
        }

        if (!orig_session->bugs && switch_core_codec_ready(&orig_session->bug_codec)) {
                switch_core_codec_destroy(&orig_session->bug_codec);
        }

        switch_thread_rwlock_unlock(orig_session->bug_rwlock);


        return total ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
}

switch_status_t switch_core_media_bug_transfer_recordings	(	switch_core_session_t *	orig_session,
		switch_core_session_t *	new_session
	)

Definition at line 877 of file switch_core_media_bug.c.

References switch_media_bug::function, switch_media_bug::next, switch_media_bug::stop_time, switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_core_session_get_channel(), switch_core_session_get_name, switch_core_session_strdup, switch_epoch_time_now(), switch_ivr_record_session(), switch_ivr_stop_record_session(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_rwlock_unlock(), switch_thread_rwlock_wrlock(), and switch_media_bug::target.

Referenced by switch_channel_mark_hold(), and switch_ivr_originate().

{
        switch_media_bug_t *bp;
        char *list[100] = { 0 };
        int stop_times[100] = { 0 };
        int i = 0, x = 0;

        if (orig_session->bugs) {
                switch_channel_t *new_channel = switch_core_session_get_channel(new_session);
                switch_channel_t *orig_channel = switch_core_session_get_channel(orig_session);
                const char *save_append = switch_channel_get_variable(new_channel, "record_append");
                const char *save_stereo = switch_channel_get_variable(new_channel, "record_stereo");
                const char *orig_stereo = switch_channel_get_variable(orig_channel, "record_stereo");
                const char *new_stereo = orig_stereo;
                
                switch_thread_rwlock_wrlock(orig_session->bug_rwlock);
                switch_channel_set_variable(new_channel, "RECORD_MIN_SEC", "0");
                switch_channel_set_variable(new_channel, "record_append", "true");
                switch_channel_set_variable(new_channel, "record_stereo", new_stereo);

                for (bp = orig_session->bugs; bp; bp = bp->next) {
                        if (!strcmp(bp->function, "session_record")) {
                                list[x] = switch_core_session_strdup(new_session, bp->target);
                                if (bp->stop_time > 0) {
                                        stop_times[x] = (int)(bp->stop_time - switch_epoch_time_now(NULL));
                                }
                                x++;
                        }
                }

                switch_thread_rwlock_unlock(orig_session->bug_rwlock);

                for(i = 0; i < x; i++) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(orig_session), SWITCH_LOG_DEBUG, "Transfering %s from %s to %s\n", list[i],
                                                          switch_core_session_get_name(orig_session), switch_core_session_get_name(new_session));
                        switch_ivr_stop_record_session(orig_session, list[i]);
                        switch_ivr_record_session(new_session, list[i], stop_times[i], NULL);
                }

                switch_channel_set_variable(new_channel, "record_append", save_append);
                switch_channel_set_variable(new_channel, "record_stereo", save_stereo);

        }

        return x ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
}

void switch_core_screen_size	(	int *	x,
		int *	y
	)

Definition at line 238 of file switch_core.c.

Referenced by switch_core_init_and_modload().

{

#ifdef WIN32
        CONSOLE_SCREEN_BUFFER_INFO csbi;
        int ret;

        if ((ret = GetConsoleScreenBufferInfo(GetStdHandle( STD_OUTPUT_HANDLE ), &csbi))) {
                if (x) *x = csbi.dwSize.X;
                if (y) *y = csbi.dwSize.Y;
        }

#elif defined(TIOCGWINSZ)
        struct winsize w;
        ioctl(0, TIOCGWINSZ, &w);

        if (x) *x = w.ws_col;
        if (y) *y = w.ws_row;
#else
        if (x) *x = 80;
        if (y) *y = 24;
#endif

}

void switch_core_session_disable_heartbeat

(

switch_core_session_t *

session

)

Definition at line 1605 of file switch_core_session.c.

References switch_assert, and switch_core_session_unsched_heartbeat().

{
        switch_core_session_unsched_heartbeat(session);
        switch_assert(session != NULL);
        session->read_frame_count = 0;
        session->track_duration = 0;

}

void switch_core_session_enable_heartbeat	(	switch_core_session_t *	session,
		uint32_t	seconds
	)

Definition at line 1572 of file switch_core_session.c.

References CF_PROXY_MODE, switch_assert, switch_channel_get_name(), switch_channel_get_variable, switch_channel_get_variable_dup(), switch_channel_media_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_test_flag(), switch_core_session_sched_heartbeat(), switch_core_session_unsched_heartbeat(), SWITCH_FALSE, SWITCH_LOG_INFO, switch_log_printf(), SWITCH_LOG_WARNING, and switch_true().

Referenced by switch_channel_perform_mark_answered(), and switch_core_media_receive_message().

{
        switch_assert(session != NULL);

        if (!seconds) {
                seconds = 60;
        }

        session->track_duration = seconds;

        if (switch_channel_test_flag(session->channel, CF_PROXY_MODE) || !switch_channel_media_ready(session->channel) ||
                switch_true(switch_channel_get_variable_dup(session->channel, "heartbeat_use_scheduler", SWITCH_FALSE, -1)) ||
                switch_true(switch_channel_get_variable_dup(session->channel, "bypass_media", SWITCH_FALSE, -1)) ||
                switch_true(switch_channel_get_variable_dup(session->channel, "bypass_media_after_bridge", SWITCH_FALSE, -1))) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "%s using scheduler due to bypass media or media is not established.\n",
                                                  switch_channel_get_name(session->channel));
                switch_core_session_sched_heartbeat(session, seconds);
                return;
        }

        if (switch_true(switch_channel_get_variable(session->channel, "heartbeat_fire_on_set"))) {
                session->read_frame_count = 0;
        } else {
                session->read_frame_count = (session->read_impl.samples_per_second / session->read_impl.samples_per_packet) * seconds;
        }

        switch_core_session_unsched_heartbeat(session);

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "%s setting session heartbeat to %u second(s).\n",
                                          switch_channel_get_name(session->channel), seconds);

}

void switch_core_session_sched_heartbeat	(	switch_core_session_t *	session,
		uint32_t	seconds
	)

Definition at line 1557 of file switch_core_session.c.

References __SWITCH_FUNC__, SSHF_FREE_ARG, switch_channel_get_variable, switch_core_session_get_uuid(), switch_core_session_unsched_heartbeat(), switch_epoch_time_now(), switch_scheduler_add_task(), and switch_true().

Referenced by switch_core_session_enable_heartbeat().

{
        time_t when;

        switch_core_session_unsched_heartbeat(session);
        if (switch_true(switch_channel_get_variable(session->channel, "heartbeat_fire_on_set"))) {
                when = switch_epoch_time_now(NULL);
        } else {
                when = switch_epoch_time_now(NULL) + session->track_duration;
        }

        session->track_id = switch_scheduler_add_task(when, sch_heartbeat_callback, (char *) __SWITCH_FUNC__,
                                                                                                  switch_core_session_get_uuid(session), 0, strdup(switch_core_session_get_uuid(session)), SSHF_FREE_ARG);
}

void switch_core_session_unsched_heartbeat

(

switch_core_session_t *

session

)

Definition at line 1549 of file switch_core_session.c.

References switch_scheduler_del_task_id().

Referenced by switch_core_session_disable_heartbeat(), switch_core_session_enable_heartbeat(), and switch_core_session_sched_heartbeat().

{
        if (session->track_id) {
                switch_scheduler_del_task_id(session->track_id);
                session->track_id = 0;
        }
}

switch_vid_spy_fmt_t switch_media_bug_parse_spy_fmt

(

const char *

name

)

Definition at line 394 of file switch_core_media_bug.c.

References SPY_DUAL_CROP, SPY_LOWER_RIGHT_LARGE, SPY_LOWER_RIGHT_SMALL, and zstr.

Referenced by switch_ivr_eavesdrop_session().

{
        if (zstr(name)) goto end;

        if (!strcasecmp(name, "dual-crop")) {
                return SPY_DUAL_CROP;
        }

        if (!strcasecmp(name, "lower-right-large")) {
                return SPY_LOWER_RIGHT_LARGE;
        }

 end:

        return SPY_LOWER_RIGHT_SMALL;
}

void switch_media_bug_set_spy_fmt	(	switch_media_bug_t *	bug,
		switch_vid_spy_fmt_t	spy_fmt
	)

Definition at line 411 of file switch_core_media_bug.c.

Referenced by switch_ivr_eavesdrop_session().

{
        bug->spy_fmt = spy_fmt;
}