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...
void	switch_core_media_bug_set_media_params (switch_media_bug_t *bug, switch_mm_t *mm)
void	switch_core_media_bug_get_media_params (switch_media_bug_t *bug, switch_mm_t *mm)
const char *	switch_core_media_bug_get_text (switch_media_bug_t *bug)
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, switch_bool_t destroy)
	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_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

switch_core_media_bug_remove_all

#define switch_core_media_bug_remove_all

(

_s

)

switch_core_media_bug_remove_all_function(_s, NULL)

Definition at line 405 of file switch_core.h.

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

switch_core_session_get_name

#define switch_core_session_get_name

(

_s

)

switch_channel_get_name(switch_core_session_get_channel(_s))

Definition at line 265 of file switch_core.h.

Referenced by check_channel_status(), check_rtcp_and_ice(), check_timeout(), eavesdrop_callback(), handle_nack(), process_rtcp_report(), switch_core_media_bug_transfer_callback(), switch_core_session_read_frame(), switch_core_session_run(), switch_core_session_start_audio_write_thread(), switch_core_session_start_text_thread(), switch_core_session_start_video_thread(), switch_core_session_write_video_frame(), switch_ivr_parse_all_events(), and switch_rtp_set_media_timeout().

Function Documentation

switch_core_cpu_count()

uint32_t switch_core_cpu_count

(

void

)

Definition at line 1055 of file switch_core.c.

References switch_runtime::cpu_count.

Referenced by switch_core_media_init(), switch_event_init(), and switch_parse_cpu_string().

{
        return runtime.cpu_count;
}

switch_core_media_bug_add()

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
function	user defined module/function/reason identifying this bug
target	user defined identification of the target of the bug
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_capture_text(), 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_event(), switch_ivr_session_audio(), switch_ivr_tone_detect_session(), and switch_ivr_video_write_overlay_session().

switch_core_media_bug_clear_flag()

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

Referenced by switch_ivr_eavesdrop_session(), switch_ivr_record_session_mask(), and switch_ivr_record_session_pause().

switch_core_media_bug_close()

switch_status_t switch_core_media_bug_close	(	_Inout_ switch_media_bug_t **	bug,
		switch_bool_t	destroy
	)

Close and destroy a media bug.

Parameters

bug	bug to remove

Returns

SWITCH_STATUS_SUCCESS if the operation was a success

switch_core_media_bug_count()

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

Definition at line 1135 of file switch_core_media_bug.c.

References switch_core_session::bug_rwlock, switch_core_session::bugs, 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_core_media_bug_enumerate()

switch_status_t switch_core_media_bug_enumerate	(	switch_core_session_t *	session,
		switch_stream_handle_t *	stream
	)

Definition at line 1210 of file switch_core_media_bug.c.

References switch_core_session::bug_rwlock, switch_core_session::bugs, 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, switch_media_bug::thread_id, and switch_stream_handle::write_function.

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

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 1188 of file switch_core_media_bug.c.

References switch_core_session::bug_rwlock, switch_core_session::bugs, 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;
}

switch_core_media_bug_flush()

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_core_media_bug_flush_all()

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_core_media_bug_get_media_params()

void switch_core_media_bug_get_media_params	(	switch_media_bug_t *	bug,
		switch_mm_t *	mm
	)

Definition at line 125 of file switch_core_media_bug.c.

References switch_media_bug::mm.

Referenced by video_bug_thread().

{
        *mm = bug->mm;
}

switch_core_media_bug_get_native_read_frame()

switch_frame_t* switch_core_media_bug_get_native_read_frame

(

switch_media_bug_t *

bug

)

Definition at line 160 of file switch_core_media_bug.c.

References switch_media_bug::native_read_frame.

Referenced by eavesdrop_callback(), and record_callback().

{
        return bug->native_read_frame;
}

switch_core_media_bug_get_native_write_frame()

switch_frame_t* switch_core_media_bug_get_native_write_frame

(

switch_media_bug_t *

bug

)

Definition at line 165 of file switch_core_media_bug.c.

References switch_media_bug::native_write_frame.

Referenced by eavesdrop_callback(), and record_callback().

{
        return bug->native_write_frame;
}

switch_core_media_bug_get_read_replace_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_media_bug_get_session()

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(), text_callback(), tone_detect_callback(), video_write_overlay_callback(), and write_displace_callback().

switch_core_media_bug_get_text()

const char* switch_core_media_bug_get_text

(

switch_media_bug_t *

bug

)

Definition at line 135 of file switch_core_media_bug.c.

References switch_media_bug::text_framedata.

Referenced by text_callback().

{
        return bug->text_framedata;
}

switch_core_media_bug_get_user_data()

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_core_media_bug_get_video_ping_frame()

switch_frame_t* switch_core_media_bug_get_video_ping_frame

(

switch_media_bug_t *

bug

)

Definition at line 140 of file switch_core_media_bug.c.

References switch_media_bug::video_ping_frame.

Referenced by video_write_overlay_callback().

{
        return bug->video_ping_frame;
}

switch_core_media_bug_get_write_replace_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().

switch_core_media_bug_inuse()

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

Definition at line 206 of file switch_core_media_bug.c.

References switch_media_bug::raw_read_buffer, switch_media_bug::raw_write_buffer, switch_media_bug::read_mutex, SMBF_READ_STREAM, SMBF_WRITE_STREAM, switch_buffer_inuse(), switch_mutex_lock(), switch_mutex_unlock(), switch_test_flag, and switch_media_bug::write_mutex.

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

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 465 of file switch_core_media_bug.c.

References vpx_image::d_h, vpx_image::d_w, POS_CENTER_MID, switch_media_bug::session, SPY_DUAL_CROP, switch_media_bug::spy_fmt, switch_media_bug::spy_img, SPY_LOWER_RIGHT_LARGE, SPY_LOWER_RIGHT_SMALL, switch_media_bug::spy_video_queue, 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;
        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 (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;
}

switch_core_media_bug_patch_video()

uint32_t switch_core_media_bug_patch_video	(	switch_core_session_t *	orig_session,
		switch_frame_t *	frame
	)

Definition at line 1153 of file switch_core_media_bug.c.

References switch_core_session::bug_rwlock, switch_core_session::bugs, switch_media_bug::callback, switch_media_bug::function, switch_frame::img, 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;
}

switch_core_media_bug_pause()

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 92 of file switch_core_media_bug.c.

References CF_PAUSE_BUGS, switch_core_session::channel, and switch_channel_set_flag.

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

switch_core_media_bug_pop()

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 1109 of file switch_core_media_bug.c.

References switch_core_session::bug_rwlock, switch_core_session::bugs, 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;
}

switch_core_media_bug_prune()

uint32_t switch_core_media_bug_prune

(

switch_core_session_t *

session

)

Definition at line 1393 of file switch_core_media_bug.c.

References switch_core_session::bug_codec, switch_core_session::bug_rwlock, switch_core_session::bugs, 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(), SWITCH_TRUE, 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_text_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, SWITCH_TRUE);
                ttl++;
                goto top;
        }

        return ttl;
}

switch_core_media_bug_push_spy_frame()

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 773 of file switch_core_media_bug.c.

References switch_frame::img, switch_media_bug::spy_video_queue, 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_core_media_bug_read()

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

SWITCH_STATUS_SUCCESS if the operation was a success

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

switch_core_media_bug_remove()

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_capture_text(), 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_core_media_bug_remove_all_function()

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_core_media_bug_remove_callback()

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 1435 of file switch_core_media_bug.c.

References switch_core_session::bug_codec, switch_core_session::bug_rwlock, switch_core_session::bugs, 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_core_media_bug_destroy(), SWITCH_FALSE, 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, *closed = NULL, *next = 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_FALSE) == SWITCH_STATUS_SUCCESS) {
                                        total++;
                                }

                                cur->next = closed;
                                closed = cur;

                        } else {
                                last = cur;
                        }
                }
        }
        switch_thread_rwlock_unlock(session->bug_rwlock);
        
        if (closed) {
                for (bp = closed; bp; bp = next) {
                        next = bp->next;
                        switch_core_media_bug_destroy(&bp);
                }
        }

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

        return total ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
}

switch_core_media_bug_resume()

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 97 of file switch_core_media_bug.c.

References CF_PAUSE_BUGS, switch_core_session::channel, and switch_channel_clear_flag().

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

switch_core_media_bug_set_flag()

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(), switch_ivr_record_session_pause(), and switch_ivr_session_audio().

switch_core_media_bug_set_media_params()

void switch_core_media_bug_set_media_params	(	switch_media_bug_t *	bug,
		switch_mm_t *	mm
	)

Definition at line 120 of file switch_core_media_bug.c.

References switch_media_bug::mm.

Referenced by record_callback().

{
        bug->mm = *mm;
}

switch_core_media_bug_set_pre_buffer_framecount()

switch_status_t switch_core_media_bug_set_pre_buffer_framecount	(	switch_media_bug_t *	bug,
		uint32_t	framecount
	)

Definition at line 225 of file switch_core_media_bug.c.

References switch_media_bug::record_pre_buffer_max, and SWITCH_STATUS_SUCCESS.

Referenced by switch_ivr_record_session_event().

{
        bug->record_pre_buffer_max = framecount;

        return SWITCH_STATUS_SUCCESS;
}

switch_core_media_bug_set_read_demux_frame()

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

Referenced by eavesdrop_callback().

switch_core_media_bug_set_read_replace_frame()

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

switch_core_media_bug_set_write_replace_frame()

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

switch_core_media_bug_test_flag()

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_text_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_core_media_bug_transfer_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 1044 of file switch_core_media_bug.c.

References switch_core_session::bug_codec, switch_core_session::bug_rwlock, switch_core_session::bugs, switch_core_session::channel, cur, switch_core_session::flags, switch_media_bug::next, switch_channel_media_ready, 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_LOG_WARNING, 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, *old_last_next = NULL, *old_bugs = NULL;
        int total = 0;

        if (!switch_channel_media_ready(new_session->channel)) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(orig_session), SWITCH_LOG_WARNING, "Cannot transfer media bugs to a channel with no media.\n");
                return SWITCH_STATUS_FALSE;
        }
        
        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) {
                                old_last_next = last->next;
                                last->next = cur->next;
                        } else {
                                old_bugs = orig_session->bugs;
                                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));

                        if ((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_STATUS_SUCCESS)) {
                                switch_core_media_bug_destroy(&cur);
                                total++;
                        } else {
                                /* Call the dup function again to revert to original session */
                                user_data_dup_func(orig_session, cur->user_data);
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(orig_session), SWITCH_LOG_DEBUG, "Adding a bug failed: abort transfering %s from %s to %s\n", cur->target,
                                        switch_core_session_get_name(orig_session), switch_core_session_get_name(new_session));

                                /* Put the old bug back to the original session's list of bugs */
                                if (last) {
                                        last->next = old_last_next;
                                } else {
                                        orig_session->bugs = old_bugs;
                                }

                                last = cur;
                        }
                } 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_core_screen_size()

void switch_core_screen_size	(	int *	x,
		int *	y
	)

Definition at line 261 of file switch_core.c.

Referenced by switch_core_init_and_modload(), and switch_must_realloc().

{

#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

}

switch_core_session_disable_heartbeat()

void switch_core_session_disable_heartbeat

(

switch_core_session_t *

session

)

Definition at line 1703 of file switch_core_session.c.

References switch_core_session::read_frame_count, switch_assert, switch_core_session_unsched_heartbeat(), and switch_core_session::track_duration.

Referenced by switch_must_realloc().

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

}

switch_core_session_enable_heartbeat()

void switch_core_session_enable_heartbeat	(	switch_core_session_t *	session,
		uint32_t	seconds
	)

Definition at line 1670 of file switch_core_session.c.

References CF_PROXY_MODE, switch_core_session::channel, switch_core_session::read_frame_count, switch_core_session::read_impl, switch_codec_implementation::samples_per_packet, switch_codec_implementation::samples_per_second, 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, switch_true(), and switch_core_session::track_duration.

Referenced by switch_channel_perform_mark_answered(), switch_core_media_receive_message(), and switch_must_realloc().

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

}

switch_core_session_sched_heartbeat()

void switch_core_session_sched_heartbeat	(	switch_core_session_t *	session,
		uint32_t	seconds
	)

Definition at line 1655 of file switch_core_session.c.

References __SWITCH_FUNC__, switch_core_session::channel, 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(), switch_true(), switch_core_session::track_duration, and switch_core_session::track_id.

Referenced by switch_core_session_enable_heartbeat(), and switch_must_realloc().

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

switch_core_session_unsched_heartbeat()

void switch_core_session_unsched_heartbeat

(

switch_core_session_t *

session

)

Definition at line 1647 of file switch_core_session.c.

References switch_scheduler_del_task_id(), and switch_core_session::track_id.

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

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

switch_media_bug_parse_spy_fmt()

switch_vid_spy_fmt_t switch_media_bug_parse_spy_fmt

(

const char *

name

)

Definition at line 443 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;
}

switch_media_bug_set_spy_fmt()

void switch_media_bug_set_spy_fmt	(	switch_media_bug_t *	bug,
		switch_vid_spy_fmt_t	spy_fmt
	)

Definition at line 460 of file switch_core_media_bug.c.

References switch_media_bug::spy_fmt.

Referenced by switch_ivr_eavesdrop_session().

{
        bug->spy_fmt = spy_fmt;
}