switch_frame_t *read_demux_frame;
switch_queue_t *read_video_queue;
switch_queue_t *write_video_queue;
+ switch_queue_t *spy_video_queue[2];
+ switch_image_t *spy_img[2];
+ switch_vid_spy_fmt_t spy_fmt;
switch_thread_t *video_bug_thread;
struct switch_media_bug *next;
};
const char *function, switch_media_bug_exec_cb_t cb, void *user_data);
SWITCH_DECLARE(uint32_t) switch_core_media_bug_patch_video(switch_core_session_t *orig_session, switch_frame_t *frame);
SWITCH_DECLARE(uint32_t) switch_core_media_bug_count(switch_core_session_t *orig_session, const char *function);
+SWITCH_DECLARE(void) switch_media_bug_set_spy_fmt(switch_media_bug_t *bug, switch_vid_spy_fmt_t spy_fmt);
+SWITCH_DECLARE(switch_status_t) switch_core_media_bug_push_spy_frame(switch_media_bug_t *bug, switch_frame_t *frame, switch_rw_t rw);
+SWITCH_DECLARE(switch_status_t) switch_core_media_bug_patch_spy_frame(switch_media_bug_t *bug, switch_image_t *img, switch_rw_t rw);
+SWITCH_DECLARE(switch_vid_spy_fmt_t) switch_media_bug_parse_spy_fmt(const char *name);
+
/*!
\brief Add a media bug to the session
\param session the session to add the bug to
SMBF_WRITE_VIDEO_PING = (1 << 18),
SMBF_READ_VIDEO_STREAM = (1 << 19),
SMBF_WRITE_VIDEO_STREAM = (1 << 20),
- SMBF_VIDEO_PATCH = (1 << 21)
+ SMBF_VIDEO_PATCH = (1 << 21),
+ SMBF_SPY_VIDEO_STREAM = (1 << 22),
+ SMBF_SPY_VIDEO_STREAM_BLEG = (1 << 23)
} switch_media_bug_flag_enum_t;
typedef uint32_t switch_media_bug_flag_t;
SVR_FLUSH = (1 << 1)
} switch_video_read_flag_t;
+typedef enum {
+ SPY_LOWER_RIGHT_SMALL,
+ SPY_LOWER_RIGHT_LARGE,
+ SPY_DUAL_CROP
+} switch_vid_spy_fmt_t;
SWITCH_END_EXTERN_C
#endif
switch_channel_event_set_data(channel, event);
}
switch_event_fire(&event);
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "dispatched freeswitch event for INFO\n");
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG1, "dispatched freeswitch event for INFO\n");
}
nua_respond(nh, SIP_200_OK, NUTAG_WITH_THIS_MSG(de->data->e_msg), TAG_END());
/* mux or demux to match */
if (session->read_impl.number_of_channels != read_frame->codec->implementation->number_of_channels) {
uint32_t rlen = session->raw_read_frame.datalen / 2 / read_frame->codec->implementation->number_of_channels;
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "%s MUX READ\n", switch_channel_get_name(session->channel));
+ //switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "%s MUX READ\n", switch_channel_get_name(session->channel));
switch_mux_channels((int16_t *) session->raw_read_frame.data, rlen,
read_frame->codec->implementation->number_of_channels, session->read_impl.number_of_channels);
session->raw_write_frame.datalen = rlen * 2 * session->read_impl.number_of_channels;
switch_media_bug_t *bp;
switch_bool_t ok = SWITCH_TRUE;
int prune = 0;
+ int patched = 0;
switch_thread_rwlock_rdlock(session->bug_rwlock);
for (bp = session->bugs; bp; bp = bp->next) {
if (bp->ready && switch_test_flag(bp, SMBF_WRITE_VIDEO_STREAM)) {
switch_image_t *dimg = NULL;
+
switch_img_copy(img, &dimg);
switch_queue_push(bp->write_video_queue, dimg);
-
+
+ if (switch_core_media_bug_test_flag(bp, SMBF_SPY_VIDEO_STREAM_BLEG)) {
+ switch_core_media_bug_patch_spy_frame(bp, img, SWITCH_RW_WRITE);
+ patched = 1;
+ }
+
}
- if (bp->ready && img && switch_test_flag(bp, SMBF_WRITE_VIDEO_PING)) {
+ if (bp->ready && img &&
+ (switch_test_flag(bp, SMBF_WRITE_VIDEO_PING) || (switch_core_media_bug_test_flag(bp, SMBF_SPY_VIDEO_STREAM) && !patched))) {
switch_frame_t bug_frame = { 0 };
bug_frame.img = img;
bp->ping_frame = &bug_frame;
- if (bp->callback) {
+ if (bp->callback && switch_test_flag(bp, SMBF_WRITE_VIDEO_PING)) {
if (bp->callback(bp, bp->user_data, SWITCH_ABC_TYPE_WRITE_VIDEO_PING) == SWITCH_FALSE
|| (bp->stop_time && bp->stop_time <= switch_epoch_time_now(NULL))) {
ok = SWITCH_FALSE;
}
}
+
+ if (switch_core_media_bug_test_flag(bp, SMBF_SPY_VIDEO_STREAM_BLEG) && !patched) {
+ switch_core_media_bug_patch_spy_frame(bp, bp->ping_frame->img, SWITCH_RW_WRITE);
+ }
+
bp->ping_frame = NULL;
}
switch_media_bug_t *bp;
switch_bool_t ok = SWITCH_TRUE;
int prune = 0;
+ int patched = 0;
+
switch_thread_rwlock_rdlock(session->bug_rwlock);
for (bp = session->bugs; bp; bp = bp->next) {
if (switch_channel_test_flag(session->channel, CF_PAUSE_BUGS) && !switch_core_media_bug_test_flag(bp, SMBF_NO_PAUSE)) {
switch_image_t *img = NULL;
switch_img_copy((*frame)->img, &img);
switch_queue_push(bp->read_video_queue, img);
+ if (switch_core_media_bug_test_flag(bp, SMBF_SPY_VIDEO_STREAM)) {
+ switch_core_media_bug_patch_spy_frame(bp, (*frame)->img, SWITCH_RW_READ);
+ patched = 1;
+ }
}
}
- if (bp->ready && (*frame) && (*frame)->img && switch_test_flag(bp, SMBF_READ_VIDEO_PING)) {
+ if (bp->ready && (*frame) && (*frame)->img &&
+ (switch_test_flag(bp, SMBF_READ_VIDEO_PING) || (switch_core_media_bug_test_flag(bp, SMBF_SPY_VIDEO_STREAM) && !patched))) {
bp->ping_frame = *frame;
- if (bp->callback) {
+
+ if (bp->callback && switch_test_flag(bp, SMBF_READ_VIDEO_PING)) {
if (bp->callback(bp, bp->user_data, SWITCH_ABC_TYPE_READ_VIDEO_PING) == SWITCH_FALSE
|| (bp->stop_time && bp->stop_time <= switch_epoch_time_now(NULL))) {
ok = SWITCH_FALSE;
}
}
+
+ if (switch_core_media_bug_test_flag(bp, SMBF_SPY_VIDEO_STREAM) && !patched) {
+ switch_core_media_bug_patch_spy_frame(bp, (*frame)->img, SWITCH_RW_READ);
+ }
+
+
bp->ping_frame = NULL;
}
return SWITCH_STATUS_SUCCESS;
}
+SWITCH_DECLARE(switch_vid_spy_fmt_t) switch_media_bug_parse_spy_fmt(const char *name)
+{
+ 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_DECLARE(void) switch_media_bug_set_spy_fmt(switch_media_bug_t *bug, switch_vid_spy_fmt_t spy_fmt)
+{
+ bug->spy_fmt = spy_fmt;
+}
+
+SWITCH_DECLARE(switch_status_t) switch_core_media_bug_patch_spy_frame(switch_media_bug_t *bug, switch_image_t *img, switch_rw_t rw)
+{
+ 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_img_fit(&img_tmp, w / 2, h);
+
+ 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;
+}
+
static void *SWITCH_THREAD_FUNC video_bug_thread(switch_thread_t *thread, void *obj)
{
switch_media_bug_t *bug = (switch_media_bug_t *) obj;
if ((status = switch_queue_pop(main_q, &pop)) == SWITCH_STATUS_SUCCESS) {
switch_img_free(&img);
-
+
if (!pop) {
goto end;
}
w = img->d_w;
h = img->d_h;
-
+
if (other_q) {
if (other_img) {
if (other_img->d_w != w || other_img->d_h != h) {
}
switch_thread_rwlock_rdlock(bug->session->bug_rwlock);
- switch_mutex_lock(bug->read_mutex);
+ //switch_mutex_lock(bug->read_mutex);
frame.img = IMG;
bug->ping_frame = &frame;
if (bug->callback) {
}
}
bug->ping_frame = NULL;
- switch_mutex_unlock(bug->read_mutex);
+ //switch_mutex_unlock(bug->read_mutex);
switch_thread_rwlock_unlock(bug->session->bug_rwlock);
if (!ok) {
switch_img_free(&img);
switch_img_free(&other_img);
- while (switch_queue_pop(main_q, &pop) == SWITCH_STATUS_SUCCESS && pop) {
+ while (switch_queue_trypop(main_q, &pop) == SWITCH_STATUS_SUCCESS && pop) {
img = (switch_image_t *) pop;
switch_img_free(&img);
}
if (other_q) {
- while (switch_queue_pop(other_q, &pop) == SWITCH_STATUS_SUCCESS && pop) {
+ while (switch_queue_trypop(other_q, &pop) == SWITCH_STATUS_SUCCESS && pop) {
img = (switch_image_t *) pop;
switch_img_free(&img);
}
return NULL;
}
+SWITCH_DECLARE(switch_status_t) switch_core_media_bug_push_spy_frame(switch_media_bug_t *bug, switch_frame_t *frame, switch_rw_t rw)
+{
+
+ 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;
+}
#define MAX_BUG_BUFFER 1024 * 512
SWITCH_DECLARE(switch_status_t) switch_core_media_bug_add(switch_core_session_t *session,
bug->thread_id = switch_thread_self();
}
+ if (switch_test_flag(bug, SMBF_READ_VIDEO_STREAM) || switch_test_flag(bug, SMBF_WRITE_VIDEO_STREAM) || switch_test_flag(bug, SMBF_WRITE_VIDEO_PING)) {
+ switch_channel_set_flag_recursive(session->channel, CF_VIDEO_DECODED_READ);
+ }
+
+ if (switch_test_flag(bug, SMBF_SPY_VIDEO_STREAM) || switch_core_media_bug_test_flag(bug, SMBF_SPY_VIDEO_STREAM_BLEG)) {
+ switch_queue_create(&bug->spy_video_queue[0], SWITCH_CORE_QUEUE_LEN, switch_core_session_get_pool(session));
+ switch_queue_create(&bug->spy_video_queue[1], SWITCH_CORE_QUEUE_LEN, switch_core_session_get_pool(session));
+ }
+
+ if ((switch_test_flag(bug, SMBF_READ_VIDEO_STREAM) || switch_test_flag(bug, SMBF_WRITE_VIDEO_STREAM))) {
+ switch_memory_pool_t *pool = switch_core_session_get_pool(session);
+
+ if (switch_test_flag(bug, SMBF_READ_VIDEO_STREAM)) {
+ switch_queue_create(&bug->read_video_queue, SWITCH_CORE_QUEUE_LEN, pool);
+ }
+
+ if (switch_test_flag(bug, SMBF_WRITE_VIDEO_STREAM)) {
+ switch_queue_create(&bug->write_video_queue, SWITCH_CORE_QUEUE_LEN, pool);
+ }
+ }
+
+
if (bug->callback) {
switch_bool_t result = bug->callback(bug, bug->user_data, SWITCH_ABC_TYPE_INIT);
if (result == SWITCH_FALSE) {
}
}
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Attaching BUG to %s\n", switch_channel_get_name(session->channel));
bug->ready = 1;
+
+ if ((switch_test_flag(bug, SMBF_READ_VIDEO_STREAM) || switch_test_flag(bug, SMBF_WRITE_VIDEO_STREAM))) {
+ switch_threadattr_t *thd_attr = NULL;
+ switch_memory_pool_t *pool = switch_core_session_get_pool(session);
+ switch_threadattr_create(&thd_attr, pool);
+ switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
+ switch_thread_create(&bug->video_bug_thread, thd_attr, video_bug_thread, bug, pool);
+
+ }
+
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Attaching BUG to %s\n", switch_channel_get_name(session->channel));
switch_thread_rwlock_wrlock(session->bug_rwlock);
bug->next = session->bugs;
session->bugs = bug;
switch_thread_rwlock_unlock(session->bug_rwlock);
*new_bug = bug;
-
-
- if ((switch_test_flag(bug, SMBF_READ_VIDEO_STREAM) || switch_test_flag(bug, SMBF_WRITE_VIDEO_STREAM))) {
- switch_threadattr_t *thd_attr = NULL;
- switch_memory_pool_t *pool = switch_core_session_get_pool(session);
-
- if (switch_test_flag(bug, SMBF_READ_VIDEO_STREAM)) {
- switch_queue_create(&bug->read_video_queue, SWITCH_CORE_QUEUE_LEN, pool);
- }
-
- if (switch_test_flag(bug, SMBF_WRITE_VIDEO_STREAM)) {
- switch_queue_create(&bug->write_video_queue, SWITCH_CORE_QUEUE_LEN, pool);
- }
-
- switch_threadattr_create(&thd_attr, pool);
- switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
- switch_thread_create(&bug->video_bug_thread, thd_attr, video_bug_thread, bug, pool);
- }
-
if (tap_only) {
switch_set_flag(session, SSF_MEDIA_BUG_TAP_ONLY);
} else {
bp->callback(bp, bp->user_data, SWITCH_ABC_TYPE_CLOSE);
}
+ if (switch_test_flag(bp, SMBF_READ_VIDEO_STREAM) || switch_test_flag(bp, SMBF_WRITE_VIDEO_STREAM) || switch_test_flag(bp, SMBF_WRITE_VIDEO_PING)) {
+ switch_channel_clear_flag_recursive(bp->session->channel, CF_VIDEO_DECODED_READ);
+ }
+
bp->ready = 0;
+ switch_img_free(&bp->spy_img[0]);
+ switch_img_free(&bp->spy_img[1]);
+
if (bp->video_bug_thread) {
switch_status_t st;
-
+ int i;
+
+ for (i = 0; i < 2; i++) {
+ void *pop;
+ switch_image_t *img;
+
+ if (bp->spy_video_queue[i]) {
+ while (switch_queue_trypop(bp->spy_video_queue[i], &pop) == SWITCH_STATUS_SUCCESS && pop) {
+ img = (switch_image_t *) pop;
+ switch_img_free(&img);
+ }
+ }
+ }
+
if (bp->read_video_queue) {
switch_queue_push(bp->read_video_queue, NULL);
}
if (bp->write_video_queue) {
switch_queue_push(bp->write_video_queue, NULL);
}
-
+
switch_thread_join(&st, bp->video_bug_thread);
}
src = *srcP;
- if (!src || (src->d_w <= width && src->d_h <= height)) {
+ if (!src || (src->d_w == width && src->d_h == height)) {
return SWITCH_STATUS_SUCCESS;
}
new_w = src->d_w;
new_h = src->d_h;
- while(new_w > width || new_h > height) {
- if (new_w > width) {
- double m = (double) width / new_w;
+ if (src->d_w < width && src->d_h < height) {
+ float rw = (float)new_w / width;
+ float rh = (float)new_h / height;
+
+ if (rw > rh) {
+ new_h = (int)((float)new_h / rw);
new_w = width;
- new_h = (int) (new_h * m);
} else {
- double m = (double) height / new_h;
+ new_w = (int)((float)new_w / rh);
new_h = height;
- new_w = (int) (new_w * m);
+ }
+ } else {
+ while(new_w > width || new_h > height) {
+ if (new_w > width) {
+ double m = (double) width / new_w;
+ new_w = width;
+ new_h = (int) (new_h * m);
+ } else {
+ double m = (double) height / new_h;
+ new_h = height;
+ new_w = (int) (new_w * m);
+ }
}
}
}
- if (switch_core_file_has_video(rh->fh)) {
+ //if (switch_core_file_has_video(rh->fh)) {
//switch_core_media_set_video_file(session, NULL, SWITCH_RW_READ);
- switch_channel_clear_flag_recursive(session->channel, CF_VIDEO_DECODED_READ);
- }
+ //switch_channel_clear_flag_recursive(session->channel, CF_VIDEO_DECODED_READ);
+ //}
switch_core_file_close(rh->fh);
switch_core_session_t *eavesdropper;
uint32_t flags;
switch_frame_t demux_frame;
+ int set_decoded_read;
+ int errs;
uint8_t data[SWITCH_RECOMMENDED_BUFFER_SIZE];
};
+static switch_status_t video_eavesdrop_callback(switch_core_session_t *session, switch_frame_t *frame, void *user_data)
+{
+ switch_media_bug_t *bug = (switch_media_bug_t *) user_data;
+
+ if (frame->img) {
+ if (switch_core_media_bug_test_flag(bug, SMBF_SPY_VIDEO_STREAM)) {
+ switch_core_media_bug_push_spy_frame(bug, frame, SWITCH_RW_READ);
+ }
+
+ if (switch_core_media_bug_test_flag(bug, SMBF_SPY_VIDEO_STREAM_BLEG)) {
+ switch_core_media_bug_push_spy_frame(bug, frame, SWITCH_RW_WRITE);
+ }
+ }
+
+ return SWITCH_STATUS_SUCCESS;
+}
static switch_bool_t eavesdrop_callback(switch_media_bug_t *bug, void *user_data, switch_abc_type_t type)
{
struct eavesdrop_pvt *ep = (struct eavesdrop_pvt *) user_data;
uint8_t data[SWITCH_RECOMMENDED_BUFFER_SIZE];
switch_frame_t frame = { 0 };
+ switch_core_session_t *session = switch_core_media_bug_get_session(bug);
+ switch_channel_t *e_channel = switch_core_session_get_channel(ep->eavesdropper);
+ int show_spy = 0;
frame.data = data;
frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE;
+ show_spy = switch_core_media_bug_test_flag(bug, SMBF_SPY_VIDEO_STREAM) || switch_core_media_bug_test_flag(bug, SMBF_SPY_VIDEO_STREAM_BLEG);
+
+ if (show_spy) {
+ if (!ep->set_decoded_read) {
+ ep->set_decoded_read = 1;
+ switch_channel_set_flag_recursive(e_channel, CF_VIDEO_DECODED_READ);
+ switch_core_session_request_video_refresh(ep->eavesdropper);
+ }
+ } else {
+ if (ep->set_decoded_read) {
+ ep->set_decoded_read = 0;
+ switch_channel_clear_flag_recursive(e_channel, CF_VIDEO_DECODED_READ);
+ switch_core_session_request_video_refresh(ep->eavesdropper);
+ }
+ }
+
switch (type) {
case SWITCH_ABC_TYPE_INIT:
+
+ if (switch_core_media_bug_test_flag(bug, SMBF_READ_VIDEO_STREAM) ||
+ switch_core_media_bug_test_flag(bug, SMBF_WRITE_VIDEO_STREAM) ||
+ switch_core_media_bug_test_flag(bug, SMBF_READ_VIDEO_PING)) {
+ switch_core_session_set_video_read_callback(ep->eavesdropper, video_eavesdrop_callback, (void *)bug);
+ switch_channel_set_flag_recursive(switch_core_session_get_channel(session), CF_VIDEO_DECODED_READ);
+ }
break;
case SWITCH_ABC_TYPE_CLOSE:
+ if (ep->set_decoded_read) {
+ switch_channel_clear_flag_recursive(e_channel, CF_VIDEO_DECODED_READ);
+ }
+
+ if (switch_core_media_bug_test_flag(bug, SMBF_READ_VIDEO_STREAM) ||
+ switch_core_media_bug_test_flag(bug, SMBF_WRITE_VIDEO_STREAM) ||
+ switch_core_media_bug_test_flag(bug, SMBF_READ_VIDEO_PING)) {
+ switch_core_session_set_video_read_callback(ep->eavesdropper, NULL, NULL);
+ }
+
+ switch_channel_clear_flag_recursive(switch_core_session_get_channel(session), CF_VIDEO_DECODED_READ);
+
break;
case SWITCH_ABC_TYPE_WRITE:
break;
}
}
break;
+
case SWITCH_ABC_TYPE_READ_VIDEO_PING:
- if (!bug->ping_frame) break;
+ case SWITCH_ABC_TYPE_STREAM_VIDEO_PING:
+ {
- if (ep->eavesdropper && switch_core_session_read_lock(ep->eavesdropper) == SWITCH_STATUS_SUCCESS) {
- switch_channel_t *channel = switch_core_session_get_channel(ep->eavesdropper);
- if (switch_channel_test_flag(channel, CF_VIDEO)) {
- switch_core_session_write_video_frame(ep->eavesdropper, bug->ping_frame, SWITCH_IO_FLAG_NONE, 0);
+ if (!bug->ping_frame || !bug->ping_frame->img) {
+ break;
+ }
+
+ if (ep->eavesdropper && switch_core_session_read_lock(ep->eavesdropper) == SWITCH_STATUS_SUCCESS) {
+ if (switch_core_session_write_video_frame(ep->eavesdropper, bug->ping_frame, SWITCH_IO_FLAG_NONE, 0) != SWITCH_STATUS_SUCCESS) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error writing video to %s\n", switch_core_session_get_name(ep->eavesdropper));
+ ep->errs++;
+
+ if (ep->errs > 10) {
+ switch_channel_hangup(e_channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
+ switch_core_session_reset(ep->eavesdropper, SWITCH_TRUE, SWITCH_TRUE);
+ switch_core_session_rwunlock(ep->eavesdropper);
+ return SWITCH_FALSE;
+ }
+ } else {
+ ep->errs = 0;
+ }
+ switch_core_session_rwunlock(ep->eavesdropper);
}
- switch_core_session_rwunlock(ep->eavesdropper);
}
break;
default:
switch_caller_profile_t *cp = NULL;
uint32_t sanity = 600;
switch_media_bug_flag_t read_flags = 0, write_flags = 0;
+ const char *vval;
if (!switch_channel_media_up(channel)) {
goto end;
switch_buffer_create_dynamic(&ep->r_buffer, 2048, 2048, 8192);
switch_buffer_add_mutex(ep->r_buffer, ep->r_mutex);
-
if (flags & ED_BRIDGE_READ) {
read_flags = SMBF_READ_STREAM | SMBF_READ_REPLACE;
}
+
if (flags & ED_BRIDGE_WRITE) {
write_flags = SMBF_WRITE_STREAM | SMBF_WRITE_REPLACE;
}
+ if (switch_channel_test_flag(session->channel, CF_VIDEO) && switch_channel_test_flag(tsession->channel, CF_VIDEO)) {
+ if ((vval = switch_channel_get_variable(session->channel, "eavesdrop_show_listener_video"))) {
+ if (switch_true(vval) || !strcasecmp(vval, "aleg") || !strcasecmp(vval, "bleg") || !strcasecmp(vval, "both")) {
+ read_flags |= SMBF_SPY_VIDEO_STREAM;
+ }
+ if (switch_true(vval) || !strcasecmp(vval, "bleg") || !strcasecmp(vval, "both")) {
+ read_flags |= SMBF_SPY_VIDEO_STREAM_BLEG;
+ }
+ }
+
+ if ((vval = switch_channel_get_variable(session->channel, "eavesdrop_concat_video")) && switch_true(vval)) {
+ read_flags |= SMBF_READ_VIDEO_STREAM;
+ read_flags |= SMBF_WRITE_VIDEO_STREAM;
+ } else {
+ read_flags |= SMBF_READ_VIDEO_PING;
+ }
+ } else {
+ read_flags &= ~SMBF_READ_VIDEO_PING;
+ read_flags &= ~SMBF_READ_VIDEO_STREAM;
+ read_flags &= ~SMBF_WRITE_VIDEO_STREAM;
+ read_flags &= ~SMBF_SPY_VIDEO_STREAM;
+ read_flags &= ~SMBF_SPY_VIDEO_STREAM_BLEG;
+ }
+
+
if (switch_core_media_bug_add(tsession, "eavesdrop", uuid,
eavesdrop_callback, ep, 0,
read_flags | write_flags | SMBF_READ_PING | SMBF_THREAD_LOCK | SMBF_NO_PAUSE,
goto end;
}
+ if ((vval = switch_channel_get_variable(session->channel, "eavesdrop_video_spy_fmt"))) {
+ switch_media_bug_set_spy_fmt(bug, switch_media_bug_parse_spy_fmt(vval));
+ }
msg.from = __FILE__;
switch_event_t *event = NULL;
char *fcommand = NULL;
char db[2] = "";
+ int vid_bug = 0, vid_dual = 0;
status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
fcommand = db;
}
+ if (switch_core_media_bug_test_flag(bug, SMBF_READ_VIDEO_STREAM) ||
+ switch_core_media_bug_test_flag(bug, SMBF_WRITE_VIDEO_STREAM)) {
+ vid_dual = 1;
+ }
+
+ if (vid_dual || switch_core_media_bug_test_flag(bug, SMBF_READ_VIDEO_PING)) {
+ vid_bug = 1;
+ }
+
if (fcommand) {
char *d;
for (d = fcommand; *d; d++) {
case '1':
switch_set_flag(ep, ED_MUX_READ);
switch_clear_flag(ep, ED_MUX_WRITE);
+ if (vid_bug) {
+ switch_core_media_bug_set_flag(bug, SMBF_SPY_VIDEO_STREAM);
+ switch_core_media_bug_clear_flag(bug, SMBF_SPY_VIDEO_STREAM_BLEG);
+ switch_core_session_request_video_refresh(tsession);
+ }
break;
case '2':
switch_set_flag(ep, ED_MUX_WRITE);
switch_clear_flag(ep, ED_MUX_READ);
+ if (vid_bug) {
+ switch_core_media_bug_set_flag(bug, SMBF_SPY_VIDEO_STREAM_BLEG);
+ switch_core_media_bug_clear_flag(bug, SMBF_SPY_VIDEO_STREAM);
+ switch_core_session_request_video_refresh(tsession);
+ }
break;
case '3':
switch_set_flag(ep, ED_MUX_READ);
switch_set_flag(ep, ED_MUX_WRITE);
+ if (vid_bug) {
+ switch_core_media_bug_set_flag(bug, SMBF_SPY_VIDEO_STREAM);
+ switch_core_media_bug_set_flag(bug, SMBF_SPY_VIDEO_STREAM_BLEG);
+ switch_core_session_request_video_refresh(tsession);
+ }
+ break;
+
+ case '4':
+ switch_media_bug_set_spy_fmt(bug, switch_media_bug_parse_spy_fmt("dual-crop"));
+ break;
+ case '5':
+ switch_media_bug_set_spy_fmt(bug, switch_media_bug_parse_spy_fmt("lower-right-small"));
+ break;
+ case '6':
+ switch_media_bug_set_spy_fmt(bug, switch_media_bug_parse_spy_fmt("lower-right-large"));
break;
case '0':
switch_clear_flag(ep, ED_MUX_READ);
switch_clear_flag(ep, ED_MUX_WRITE);
+ if (vid_bug) {
+ switch_core_media_bug_clear_flag(bug, SMBF_SPY_VIDEO_STREAM);
+ switch_core_media_bug_clear_flag(bug, SMBF_SPY_VIDEO_STREAM_BLEG);
+ switch_core_session_request_video_refresh(tsession);
+ }
break;
case '*':
goto end_loop;
if (switch_core_file_has_video(fh)) {
//switch_core_media_set_video_file(session, fh, SWITCH_RW_READ);
- switch_channel_set_flag_recursive(session->channel, CF_VIDEO_DECODED_READ);
+ //switch_channel_set_flag_recursive(session->channel, CF_VIDEO_DECODED_READ);
if ((vval = switch_channel_get_variable(channel, "record_concat_video")) && switch_true(vval)) {
flags |= SMBF_READ_VIDEO_STREAM;
switch_channel_t *b_channel = switch_core_session_get_channel(vh->session_b);
switch_status_t status;
switch_frame_t *read_frame = 0;
+ int set_decoded_read = 0;
vh->up = 1;
switch_codec_t *a_codec = switch_core_session_get_video_read_codec(vh->session_a);
switch_codec_t *b_codec = switch_core_session_get_video_write_codec(vh->session_b);
- if ((!b_codec || !a_codec || a_codec->implementation->impl_id == b_codec->implementation->impl_id) &&
- !switch_channel_test_flag(b_channel, CF_VIDEO_DECODED_READ)) {
- switch_channel_clear_flag(channel, CF_VIDEO_DECODED_READ);
+ switch_assert(a_codec);
+ switch_assert(b_codec);
+
+ if (switch_channel_test_flag(channel, CF_VIDEO_DECODED_READ)) {
+ if (a_codec->implementation->impl_id == b_codec->implementation->impl_id && !switch_channel_test_flag(b_channel, CF_VIDEO_DECODED_READ)) {
+ if (set_decoded_read) {
+ switch_channel_clear_flag_recursive(channel, CF_VIDEO_DECODED_READ);
+ set_decoded_read = 0;
+ }
+ }
} else {
- switch_channel_set_flag(channel, CF_VIDEO_DECODED_READ);
+ if (a_codec->implementation->impl_id != b_codec->implementation->impl_id ||
+ switch_channel_test_flag(b_channel, CF_VIDEO_DECODED_READ)) {
+ switch_channel_set_flag_recursive(channel, CF_VIDEO_DECODED_READ);
+ set_decoded_read = 1;
+ }
}
status = switch_core_session_read_video_frame(vh->session_a, &read_frame, SWITCH_IO_FLAG_NONE, 0);
}
}
+ if (set_decoded_read) {
+ switch_channel_clear_flag_recursive(channel, CF_VIDEO_DECODED_READ);
+ }
+
switch_core_session_kill_channel(vh->session_b, SWITCH_SIG_BREAK);
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(vh->session_a), SWITCH_LOG_DEBUG, "%s video thread ended.\n", switch_channel_get_name(channel));
projects / thirdparty / freeswitch.git / commitdiff
