diff --git a/libs/xmlrpc-c/.update b/libs/xmlrpc-c/.update
index 61d9732fd3..60fffd18f9 100644
--- a/libs/xmlrpc-c/.update
+++ b/libs/xmlrpc-c/.update
@@ -1 +1 @@
-Wed Apr 25 16:05:00 EDT 2007
+date
diff --git a/libs/xmlrpc-c/include/xmlrpc-c/abyss.h b/libs/xmlrpc-c/include/xmlrpc-c/abyss.h
index 4a4fed1a09..b74a7a6e3f 100644
--- a/libs/xmlrpc-c/include/xmlrpc-c/abyss.h
+++ b/libs/xmlrpc-c/include/xmlrpc-c/abyss.h
@@ -48,7 +48,7 @@ extern "C" {
 ** Maximum numer of simultaneous connections
 *********************************************************************/
 
-#define MAX_CONN    16
+#define MAX_CONN    4000
 
 /*********************************************************************
 ** Server Info Definitions
@@ -443,6 +443,7 @@ typedef struct _TServer
     TList defaultfilenames;
     void *defaulthandler;
     abyss_bool advertise;
+	int running;
 #ifndef _WIN32
     uid_t uid;
     gid_t gid;
diff --git a/libs/xmlrpc-c/lib/abyss/src/server.c b/libs/xmlrpc-c/lib/abyss/src/server.c
index 3752d16249..00980a182b 100644
--- a/libs/xmlrpc-c/lib/abyss/src/server.c
+++ b/libs/xmlrpc-c/lib/abyss/src/server.c
@@ -770,8 +770,8 @@ ServerRunThreaded(TServer *srv)
         c[i].inUse = FALSE;
 
     s=srv->listensock;
-
-    while( 1 )
+	srv->running = 1;
+    while( srv->running )
     {
         /* collect all threads resources for closed connections */
         for (i=0;i<MAX_CONN;i++)
diff --git a/libs/xmlrpc-c/lib/abyss/src/thread.c b/libs/xmlrpc-c/lib/abyss/src/thread.c
index 52f47a51f8..b3d49c7d55 100644
--- a/libs/xmlrpc-c/lib/abyss/src/thread.c
+++ b/libs/xmlrpc-c/lib/abyss/src/thread.c
@@ -41,7 +41,7 @@
 #include "xmlrpc_config.h"
 
 /* 16K is the minimum size of stack on Win32 */
-#define  THREAD_STACK_SIZE    (16*1024)
+#define  THREAD_STACK_SIZE    (240*1024)
 
 /*********************************************************************
 ** Thread
diff --git a/src/include/switch_buffer.h b/src/include/switch_buffer.h
index 033e3cb6db..c3d09ee9a3 100644
--- a/src/include/switch_buffer.h
+++ b/src/include/switch_buffer.h
@@ -70,6 +70,11 @@ SWITCH_DECLARE(switch_status_t) switch_buffer_create(switch_memory_pool_t *pool,
 SWITCH_DECLARE(switch_status_t) switch_buffer_create_dynamic(switch_buffer_t **buffer, switch_size_t blocksize, switch_size_t start_len,
 															 switch_size_t max_len);
 
+SWITCH_DECLARE(void) switch_buffer_add_mutex(switch_buffer_t *buffer, switch_mutex_t *mutex);
+SWITCH_DECLARE(void) switch_buffer_lock(switch_buffer_t *buffer);
+SWITCH_DECLARE(switch_status_t) switch_buffer_trylock(switch_buffer_t *buffer);
+SWITCH_DECLARE(void) switch_buffer_unlock(switch_buffer_t *buffer);
+
 /*! \brief Get the length of a switch_buffer_t 
  * \param buffer any buffer of type switch_buffer_t
  * \return int size of the buffer.
@@ -137,6 +142,8 @@ SWITCH_DECLARE(void) switch_buffer_zero(switch_buffer_t *buffer);
  */
 SWITCH_DECLARE(void) switch_buffer_destroy(switch_buffer_t **buffer);
 
+SWITCH_DECLARE(switch_size_t) switch_buffer_zwrite(switch_buffer_t *buffer, const void *data, switch_size_t datalen);
+
 /** @} */
 
 SWITCH_END_EXTERN_C
diff --git a/src/include/switch_ivr.h b/src/include/switch_ivr.h
index fbc23153be..b019a4fc7a 100644
--- a/src/include/switch_ivr.h
+++ b/src/include/switch_ivr.h
@@ -204,7 +204,7 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_detect_speech_unload_grammar(switch_c
   \return SWITCH_STATUS_SUCCESS if all is well
 */
 SWITCH_DECLARE(switch_status_t) switch_ivr_record_session(switch_core_session_t *session, char *file, uint32_t limit, switch_file_handle_t *fh);
-
+SWITCH_DECLARE(switch_status_t) switch_ivr_eavesdrop_session(switch_core_session_t *session, const char *uuid, switch_eavesdrop_flag_t flags);
 SWITCH_DECLARE(switch_status_t) switch_ivr_displace_session(switch_core_session_t *session, char *file, uint32_t limit, const char *flags);
 SWITCH_DECLARE(switch_status_t) switch_ivr_stop_displace_session(switch_core_session_t *session, const char *file);
 
diff --git a/src/include/switch_resample.h b/src/include/switch_resample.h
index 24f351e506..5b1c791030 100644
--- a/src/include/switch_resample.h
+++ b/src/include/switch_resample.h
@@ -165,6 +165,8 @@ SWITCH_DECLARE(void) switch_generate_sln_silence(int16_t *data, uint32_t samples
 SWITCH_DECLARE(void) switch_change_sln_volume(int16_t *data, uint32_t samples, int32_t vol);
 ///\}
 
+SWITCH_DECLARE(uint32_t) switch_merge_sln(int16_t *data, uint32_t samples, int16_t *other_data, uint32_t other_samples);
+
 SWITCH_END_EXTERN_C
 #endif
 /* For Emacs:
diff --git a/src/include/switch_types.h b/src/include/switch_types.h
index bdae1ee9e0..f86e77c8f3 100644
--- a/src/include/switch_types.h
+++ b/src/include/switch_types.h
@@ -129,6 +129,12 @@ SWITCH_BEGIN_EXTERN_C
 #define SWITCH_BITS_PER_BYTE 8
 typedef uint8_t switch_byte_t;
 
+typedef enum {
+	ED_MUX_READ = (1 << 0),
+	ED_MUX_WRITE = (1 << 1),
+	ED_DTMF = (1 << 2)
+} switch_eavesdrop_flag_t;
+
 typedef enum {
 	SCF_NONE = 0,
 	SCF_USE_SQL = ( 1 << 0),
diff --git a/src/mod/applications/mod_dptools/mod_dptools.c b/src/mod/applications/mod_dptools/mod_dptools.c
index 4001d89728..8630972a2b 100644
--- a/src/mod/applications/mod_dptools/mod_dptools.c
+++ b/src/mod/applications/mod_dptools/mod_dptools.c
@@ -87,6 +87,29 @@ SWITCH_STANDARD_APP(exe_function)
 }
 
 
+
+
+#define eavesdrop_SYNTAX "<uuid>"
+SWITCH_STANDARD_APP(eavesdrop_function)
+{
+	char *argv[4];
+	int argc;
+	char *lbuf = NULL;
+	char *uuid;
+	
+	if (data && (lbuf = switch_core_session_strdup(session, data))
+		&& (argc = switch_separate_string(lbuf, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) {
+		uuid = argv[0];
+		
+		switch_ivr_eavesdrop_session(session, uuid, ED_DTMF);
+		
+	} else {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Usage: %s\n", eavesdrop_SYNTAX);
+	}
+}
+
+
+
 #define SET_USER_SYNTAX "<user>@<domain>"
 SWITCH_STANDARD_APP(set_user_function)
 {
@@ -1453,6 +1476,7 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_dptools_load)
 	SWITCH_ADD_APP(app_interface, "sched_broadcast", SCHED_BROADCAST_DESCR, SCHED_BROADCAST_DESCR, sched_broadcast_function, "[+]<time> <path> [aleg|bleg|both]", SAF_SUPPORT_NOMEDIA);
 	SWITCH_ADD_APP(app_interface, "sched_transfer", SCHED_TRANSF_DESCR, SCHED_TRANSF_DESCR, sched_transfer_function, "[+]<time> <extension> <dialplan> <context>", SAF_SUPPORT_NOMEDIA);
 	SWITCH_ADD_APP(app_interface, "execute_extension", "Execute an extension", "Execute an extension", exe_function, EXE_SYNTAX, SAF_SUPPORT_NOMEDIA);
+	SWITCH_ADD_APP(app_interface, "eavesdrop", "eavesdrop on a uuid", "eavesdrop on a uuid", eavesdrop_function, eavesdrop_SYNTAX, SAF_NONE);
 	SWITCH_ADD_APP(app_interface, "set_user", "Set a User", "Set a User", set_user_function, SET_USER_SYNTAX, SAF_SUPPORT_NOMEDIA);
 	SWITCH_ADD_APP(app_interface, "stop_dtmf", "stop inband dtmf", "Stop detecting inband dtmf.", stop_dtmf_session_function, "", SAF_NONE);
 	SWITCH_ADD_APP(app_interface, "start_dtmf", "Detect dtmf", "Detect inband dtmf on the session", dtmf_session_function, "", SAF_NONE);
diff --git a/src/mod/applications/mod_voicemail/mod_voicemail.c b/src/mod/applications/mod_voicemail/mod_voicemail.c
index de9ef72070..c54138d917 100644
--- a/src/mod/applications/mod_voicemail/mod_voicemail.c
+++ b/src/mod/applications/mod_voicemail/mod_voicemail.c
@@ -2660,6 +2660,10 @@ SWITCH_STANDARD_API(voicemail_api_function)
     char *path_info = NULL;
     int rss = 0, xarg = 0;
     
+	if (session) {
+		return SWITCH_STATUS_FALSE;
+	}
+
     if (stream->event) {
         host = switch_event_get_header(stream->event, "http-host");
         port = switch_event_get_header(stream->event, "http-port");
diff --git a/src/mod/formats/mod_shout/mod_shout.c b/src/mod/formats/mod_shout/mod_shout.c
index b9dbdeaeb8..d38dc9733b 100644
--- a/src/mod/formats/mod_shout/mod_shout.c
+++ b/src/mod/formats/mod_shout/mod_shout.c
@@ -306,7 +306,7 @@ static size_t decode_fd(shout_context_t * context, void *data, size_t bytes)
 
 	return 0;
 
-  error:
+ error:
 	switch_mutex_lock(context->audio_mutex);
 	context->err++;
 	switch_mutex_unlock(context->audio_mutex);
@@ -419,7 +419,7 @@ static size_t stream_callback(void *ptr, size_t size, size_t nmemb, void *data)
 
 	return realsize;
 
-  error:
+ error:
 	switch_mutex_lock(context->audio_mutex);
 	context->err++;
 	switch_mutex_unlock(context->audio_mutex);
@@ -512,7 +512,7 @@ static void *SWITCH_THREAD_FUNC write_stream_thread(switch_thread_t * thread, vo
 		switch_yield(100000);
 	}
 
-  error:
+ error:
 	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Thread Done\n");
 	context->thread_running = 0;
 	return NULL;
@@ -534,6 +534,7 @@ static void launch_write_stream_thread(shout_context_t * context)
 	switch_thread_create(&thread, thd_attr, write_stream_thread, context, context->memory_pool);
 }
 
+#define TC_BUFFER_SIZE 1024 * 32
 static switch_status_t shout_file_open(switch_file_handle_t *handle, const char *path)
 {
 	shout_context_t *context;
@@ -554,7 +555,7 @@ static switch_status_t shout_file_open(switch_file_handle_t *handle, const char
 	context->samplerate = handle->samplerate;
 
 	if (switch_test_flag(handle, SWITCH_FILE_FLAG_READ)) {
-		if (switch_buffer_create_dynamic(&context->audio_buffer, MY_BLOCK_SIZE, MY_BUF_LEN, 0) != SWITCH_STATUS_SUCCESS) {
+		if (switch_buffer_create_dynamic(&context->audio_buffer, TC_BUFFER_SIZE, TC_BUFFER_SIZE * 2, 0) != SWITCH_STATUS_SUCCESS) {
 			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Memory Error!\n");
 			goto error;
 		}
@@ -708,7 +709,7 @@ static switch_status_t shout_file_open(switch_file_handle_t *handle, const char
 
 	return SWITCH_STATUS_SUCCESS;
 
-  error:
+ error:
 	if (err) {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: %s\n", err);
 	}
@@ -916,46 +917,431 @@ static switch_status_t shout_file_get_string(switch_file_handle_t *handle, switc
 	return SWITCH_STATUS_FALSE;
 }
 
-static switch_file_interface_t shout_file_interface = {
-	/*.interface_name */ modname,
-	/*.file_open */ shout_file_open,
-	/*.file_close */ shout_file_close,
-	/*.file_read */ shout_file_read,
-	/*.file_write */ shout_file_write,
-	/*.file_seek */ shout_file_seek,
-	/*.file_set_string */ shout_file_set_string,
-	/*.file_get_string */ shout_file_get_string,
-	/*.extens */ NULL,
-	/*.next */ NULL,
+
+static switch_bool_t telecast_callback(switch_media_bug_t *bug, void *user_data, switch_abc_type_t type)
+{
+    switch_buffer_t *buffer = (switch_buffer_t *) user_data;
+	uint8_t data[SWITCH_RECOMMENDED_BUFFER_SIZE];
+	switch_frame_t frame = { 0 };
+
+	frame.data = data;
+	frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE;
+
+	switch (type) {
+	case SWITCH_ABC_TYPE_INIT:
+		break;
+	case SWITCH_ABC_TYPE_CLOSE:
+		break;
+	case SWITCH_ABC_TYPE_WRITE:
+		if (buffer) {
+			if (switch_core_media_bug_read(bug, &frame) == SWITCH_STATUS_SUCCESS) {
+                switch_buffer_lock(buffer);
+                switch_buffer_write(buffer, frame.data, frame.datalen);
+                switch_buffer_unlock(buffer);
+			}
+		} else {
+            return SWITCH_FALSE;
+        }
+		break;
+	case SWITCH_ABC_TYPE_READ:
+	default:
+		break;
+	}
+
+	return SWITCH_TRUE;
+}
+
+struct holder {
+    switch_stream_handle_t *stream;
+    switch_memory_pool_t *pool;
+    char *host;
+    char *port;
+    char *uri;
 };
 
-static switch_loadable_module_interface_t shout_module_interface = {
-	/*.module_name */ modname,
-	/*.endpoint_interface */ NULL,
-	/*.timer_interface */ NULL,
-	/*.dialplan_interface */ NULL,
-	/*.codec_interface */ NULL,
-	/*.application_interface */ NULL,
-	/*.api_interface */ NULL,
-	/*.file_interface */ &shout_file_interface,
-	/*.speech_interface */ NULL,
-	/*.directory_interface */ NULL
-};
+static int web_callback(void *pArg, int argc, char **argv, char **columnNames)
+{
+    struct holder *holder = (struct holder *) pArg;
+    char title_b4[128] = "";
+    char title_aft[128*3] = "";
+    char *mp3, *m3u;
+
+
+    /*
+      0  uuid  VARCHAR(255),
+      1  created  VARCHAR(255),
+      2  name  VARCHAR(255),
+      3  state  VARCHAR(255),
+      4  cid_name  VARCHAR(255),
+      5  cid_num  VARCHAR(255),
+      6  ip_addr  VARCHAR(255),
+      7  dest  VARCHAR(255),
+      8  application  VARCHAR(255),
+      9  application_data  VARCHAR(255),
+      10 read_codec  VARCHAR(255),
+      11 read_rate  VARCHAR(255),
+      12 write_codec  VARCHAR(255),
+      13 write_rate  VARCHAR(255)
+    */
+    
+
+
+    holder->stream->write_function(holder->stream, 
+                                   "<tr><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>", 
+                                   argv[1], argv[4], argv[5], argv[7], argv[8] ? argv[8] : "N/A", argv[9] ? argv[9] : "N/A", argv[10], argv[11]);
+    
+    snprintf(title_b4, sizeof(title_b4), "%s <%s>", argv[4], argv[5]);
+    switch_url_encode(title_b4, title_aft, sizeof(title_aft)-1);
+
+    mp3 = switch_mprintf("http://%s:%s%s/mp3/%s/%s.mp3", holder->host, holder->port, holder->uri, argv[0], argv[5]);
+    m3u = switch_mprintf("http://%s:%s%s/m3u/mp3/%s/%s.mp3.m3u", holder->host, holder->port, holder->uri, argv[0], argv[5]);
+
+    holder->stream->write_function(holder->stream, "[<a href=%s>mp3</a>] ", mp3);
+    holder->stream->write_function(holder->stream, "[<a href=%s>m3u</a>]</td></tr>\n", m3u);
+    
+    switch_safe_free(mp3);
+    switch_safe_free(m3u);
+    return 0;
+}
+
+
+void do_telecast(switch_stream_handle_t *stream)
+{
+    char *path_info = switch_event_get_header(stream->event, "http-path-info");
+    char *uuid = strdup(path_info + 4);
+    switch_core_session_t *tsession;
+    char *fname = "stream.mp3";
+
+    if ((fname = strchr(uuid, '/'))) {
+        *fname++ = '\0';
+    }
+
+    if (!(tsession = switch_core_session_locate(uuid))) {
+        char *ref = switch_event_get_header(stream->event, "http-referer");
+        stream->write_function(stream,"Content-type: text/html\r\n\r\n<h2>Not Found!</h2>\n"
+                               "<META http-equiv=\"refresh\" content=\"1;URL=%s\">",  ref);
+
+    } else {
+        switch_media_bug_t *bug = NULL;
+        switch_buffer_t *buffer;
+        switch_mutex_t *mutex;
+        switch_channel_t *channel = switch_core_session_get_channel(tsession);
+        lame_global_flags *gfp = NULL;
+        switch_codec_t *read_codec;
+        
+
+        if (!(gfp = lame_init())) {
+            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not allocate lame\n");
+            goto end;
+        }
+        read_codec = switch_core_session_get_read_codec(tsession);
+            
+        lame_set_num_channels(gfp, read_codec->implementation->number_of_channels);
+        lame_set_in_samplerate(gfp, read_codec->implementation->actual_samples_per_second);
+        lame_set_brate(gfp, 24);
+        lame_set_mode(gfp, 3);
+        lame_set_quality(gfp, 2);
+        lame_set_errorf(gfp, log_error);
+        lame_set_debugf(gfp, log_debug);
+        lame_set_msgf(gfp, log_msg);
+        lame_set_bWriteVbrTag(gfp, 0);
+        lame_mp3_tags_fid(gfp, NULL);
+        lame_init_params(gfp);
+        lame_print_config(gfp);
+            
+        switch_mutex_init(&mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(tsession));
+        switch_buffer_create_dynamic(&buffer, 1024, 2048, 0);
+        switch_buffer_add_mutex(buffer, mutex);
+            
+        if (switch_core_media_bug_add(tsession, telecast_callback, buffer, 0, SMBF_READ_STREAM | SMBF_WRITE_STREAM, &bug) != SWITCH_STATUS_SUCCESS) {
+            goto end;
+        }
+
+        stream->write_function(stream, 
+                               "Content-type: audio/mpeg\r\n"
+                               "Content-Disposition: inline; filename=\"%s\"\r\n\r\n", 
+                               fname);
+            
+        while(switch_channel_ready(channel)) {
+            unsigned char mp3buf[TC_BUFFER_SIZE] = "";
+            int rlen;
+            uint8_t buf[1024];
+            switch_size_t bytes = 0;
+
+            if (switch_buffer_inuse(buffer) >= 1024) {
+                switch_buffer_lock(buffer);
+                bytes = switch_buffer_read(buffer, buf, sizeof(buf));
+                switch_buffer_unlock(buffer);
+            } else {
+                memset(buf, 0, bytes);
+            }
+
+            if ((rlen = lame_encode_buffer(gfp, (void *)buf, NULL, bytes / 2, mp3buf, sizeof(mp3buf))) < 0) {
+                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "MP3 encode error %d!\n", rlen);
+                goto end;
+            }
+
+            if (rlen) {
+                if (stream->raw_write_function(stream, mp3buf, rlen)) {
+                    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Disconnected\n");
+                    goto end;
+                }
+            }
+        }
+
+
+    end:
+
+        switch_safe_free(uuid);
+
+        if (gfp) {
+            lame_close(gfp);
+            gfp = NULL;
+        }
+            
+        if (bug) {
+            switch_core_media_bug_remove(tsession, &bug);
+        }
+
+        if (buffer) {
+            switch_buffer_destroy(&buffer);
+        }
+
+        switch_core_session_rwunlock(tsession);
+    }
+
+}
+
+
+void do_broadcast(switch_stream_handle_t *stream)
+{
+    char *path_info = switch_event_get_header(stream->event, "http-path-info");
+    char *file;
+    lame_global_flags *gfp = NULL;
+    switch_file_handle_t fh = {0};
+    unsigned char mp3buf[TC_BUFFER_SIZE] = "";
+    uint8_t buf[1024];
+    int rlen;
+    int is_local = 0;
+
+    if (strstr(path_info + 7, "://")) {
+        file = strdup(path_info + 7);
+        is_local++;
+    } else {
+        file = switch_mprintf("%s/streamfiles/%s", SWITCH_GLOBAL_dirs.base_dir, path_info + 7);
+    }
+    assert(file);
+
+	if (switch_core_file_open(&fh,
+							  file,
+							  0,
+							  0,
+							  SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, NULL) != SWITCH_STATUS_SUCCESS) {
+        memset(&fh, 0, sizeof(fh));
+        stream->write_function(stream, "Content-type: text/html\r\n\r\n<h2>File not found</h2>\n");
+        goto end;
+	}
+
+    if (switch_test_flag((&fh), SWITCH_FILE_NATIVE)) {
+        stream->write_function(stream, "Content-type: text/html\r\n\r\n<h2>File format not supported</h2>\n");
+        goto end;
+    }
+
+    if (!(gfp = lame_init())) {
+        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not allocate lame\n");
+        goto end;
+    }
+            
+    lame_set_num_channels(gfp, fh.channels);
+    lame_set_in_samplerate(gfp, fh.samplerate);
+    lame_set_brate(gfp, 24);
+    lame_set_mode(gfp, 3);
+    lame_set_quality(gfp, 2);
+    lame_set_errorf(gfp, log_error);
+    lame_set_debugf(gfp, log_debug);
+    lame_set_msgf(gfp, log_msg);
+    lame_set_bWriteVbrTag(gfp, 0);
+    lame_mp3_tags_fid(gfp, NULL);
+    lame_init_params(gfp);
+    lame_print_config(gfp);
+    
+    stream->write_function(stream, 
+                           "Content-type: audio/mpeg\r\n"
+                           "Content-Disposition: inline; filename=\"%s.mp3\"\r\n\r\n", 
+                           path_info + 7);
+
+
+            
+    for(;;) {
+        switch_size_t samples = sizeof(buf) / 2;
+
+        switch_core_file_read(&fh, buf, &samples);
+
+        if (is_local) {
+            switch_yield(20000);
+        }
+
+        if (!samples) {
+            break;
+        }
+
+        if ((rlen = lame_encode_buffer(gfp, (void *)buf, NULL, samples, mp3buf, sizeof(mp3buf))) < 0) {
+            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "MP3 encode error %d!\n", rlen);
+            goto end;
+        }
+        
+        if (rlen) {
+            if (stream->raw_write_function(stream, mp3buf, rlen)) {
+                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Disconnected\n");
+                goto end;
+            }
+        }
+
+
+    }
+
+
+    while ((rlen = lame_encode_flush(gfp, mp3buf, sizeof(mp3buf))) > 0) {
+        if (stream->raw_write_function(stream, mp3buf, rlen)) {
+            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Disconnected\n");
+            goto end;
+        }
+    }
+
+
+ end:
+
+    if (fh.channels) {
+        switch_core_file_close(&fh);
+    }
+
+    switch_safe_free(file);
+
+    if (gfp) {
+        lame_close(gfp);
+        gfp = NULL;
+    }
+            
+}
+
+
+void do_index(switch_stream_handle_t *stream)
+{
+    switch_core_db_t *db = switch_core_db_handle();
+    const char *sql = "select * from channels";
+    struct holder holder;
+    char *errmsg;
+
+    holder.host = switch_event_get_header(stream->event, "http-host");
+    holder.port = switch_event_get_header(stream->event, "http-port");
+    holder.uri = switch_event_get_header(stream->event, "http-uri");
+    holder.stream = stream;
+    
+    stream->write_function(stream, "Content-type: text/html\r\n\r\n");
+
+
+    stream->write_function(stream,
+                           "<table align=center border=1 cellpadding=6 cellspacing=0>"
+                           "<tr><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td></tr>\n",
+                           "Created", "CID Name", "CID Num", "Ext", "App", "Data", "Codec", "Rate", "Listen"
+                           );
+    
+    switch_core_db_exec(db, sql, web_callback, &holder, &errmsg);
+    
+    stream->write_function(stream,
+                           "</table>");
+    
+    if (errmsg) {
+        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error [%s]\n", errmsg);    
+        switch_safe_free(errmsg);
+    }
+}
+
+#define TELECAST_SYNTAX ""
+
+SWITCH_STANDARD_API(telecast_api_function)
+{
+    char *host = NULL, *port = NULL, *uri = NULL, *path_info = NULL;
+
+    
+	if (session) {
+		return SWITCH_STATUS_FALSE;
+	}
+
+    if (stream->event) {
+        host = switch_event_get_header(stream->event, "http-host");
+        port = switch_event_get_header(stream->event, "http-port");
+        uri = switch_event_get_header(stream->event, "http-uri");
+        path_info = switch_event_get_header(stream->event, "http-path-info");
+    }
+
+    if (!path_info) {
+        return SWITCH_STATUS_FALSE;
+    } else {
+        if (!strncmp(path_info, "index", 5)) {
+            do_index(stream);
+            return SWITCH_STATUS_SUCCESS;
+        }
+
+        if (!strncmp(path_info, "m3u/", 4)) {
+            char *p;
+
+            if ((p = strstr(path_info, ".m3u"))) {
+                *p = '\0';
+            }
+
+            stream->write_function(stream, "Content-type: audio/x-mpegurl\r\n\r\nhttp://%s:%s%s/%s\n", host, port, uri, path_info + 4);
+            return SWITCH_STATUS_SUCCESS;
+        }
+
+        if (!strncmp(path_info, "mp3/", 4)) {
+            do_telecast(stream);
+            return SWITCH_STATUS_SUCCESS;
+        }
+
+        if (!strncmp(path_info, "stream/", 7)) {
+            do_broadcast(stream);
+            return SWITCH_STATUS_SUCCESS;
+        }
+    }
+    
+    stream->write_function(stream, "Content-type: text/html\r\n\r\n<h2>Invalid URL</h2>\n");
+
+    return SWITCH_STATUS_SUCCESS;
+}
 
 SWITCH_MODULE_LOAD_FUNCTION(mod_shout_load)
 {
+    switch_api_interface_t *shout_api_interface;
+    switch_file_interface_t *file_interface;
+
 	supported_formats[0] = "shout";
 	supported_formats[1] = "mp3";
-	shout_file_interface.extens = supported_formats;
 
 	curl_global_init(CURL_GLOBAL_ALL);
 
+	*module_interface = switch_loadable_module_create_module_interface(pool, modname);
+    file_interface = switch_loadable_module_create_interface(*module_interface, SWITCH_FILE_INTERFACE);
+    file_interface->interface_name = modname;
+    file_interface->extens = supported_formats;
+    file_interface->file_open = shout_file_open;
+    file_interface->file_close = shout_file_close;
+    file_interface->file_read = shout_file_read;
+    file_interface->file_write = shout_file_write;
+    file_interface->file_seek = shout_file_seek;
+    file_interface->file_set_string = shout_file_set_string;
+    file_interface->file_get_string = shout_file_get_string;
+
+
+
 	/* connect my internal structure to the blank pointer passed to me */
-	*module_interface = &shout_module_interface;
+	//*module_interface = &shout_module_interface;
 
 	shout_init();
 	InitMP3Constants();
 
+    SWITCH_ADD_API(shout_api_interface, "telecast", "telecast", telecast_api_function, TELECAST_SYNTAX);
+
 	/* indicate that the module should continue to be loaded */
 	return SWITCH_STATUS_SUCCESS;
 }
diff --git a/src/mod/xml_int/mod_xml_rpc/mod_xml_rpc.c b/src/mod/xml_int/mod_xml_rpc/mod_xml_rpc.c
index c4be9bb89d..3983d30aee 100644
--- a/src/mod/xml_int/mod_xml_rpc/mod_xml_rpc.c
+++ b/src/mod/xml_int/mod_xml_rpc/mod_xml_rpc.c
@@ -55,6 +55,7 @@ static struct {
 	char *realm;
 	char *user;
 	char *pass;
+	TServer abyssServer;
 } globals;
 
 SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_realm, globals.realm);
@@ -353,7 +354,7 @@ abyss_bool auth_hook(TSession * r)
 abyss_bool handler_hook(TSession * r)
 {
 	//char *mime = "text/html";
-	char buf[512] = "HTTP/1.1 200 OK\n";
+	char buf[80] = "HTTP/1.1 200 OK\n";
 	switch_stream_handle_t stream = { 0 };
 	char *command;
 	int i, j = 0;
@@ -542,6 +543,9 @@ abyss_bool handler_hook(TSession * r)
 
 	HTTPWrite(r, buf, (uint32_t) strlen(buf));
 
+	//HTTPWrite(r, "<pre>\n\n", 7);
+
+
 	/* generation of the date field */
 	if (DateToString(&r->date, buf)) {
 		ResponseAddField(r,"Date", buf);
@@ -559,14 +563,21 @@ abyss_bool handler_hook(TSession * r)
 	}
 
 	
+	snprintf(buf, sizeof(buf), "Connection: close\r\n");
+	ConnWrite(r->conn, buf, (uint32_t) strlen(buf));
+	
+
 	if (switch_api_execute(command, r->query, NULL, &stream) == SWITCH_STATUS_SUCCESS) {
+		ResponseStatus(r, 200);
 		r->done = TRUE;
 	} else {
 		ResponseStatus(r, 404);
 		ResponseError(r);
 	} 
 	
-	//HTTPWriteEnd(r);
+	SocketClose(&(r->conn->socket));
+	HTTPWriteEnd(r);
+	ConnClose(r->conn);
 
  end:
 
@@ -661,7 +672,7 @@ static xmlrpc_value *freeswitch_man(xmlrpc_env * const envP, xmlrpc_value * cons
 
 SWITCH_MODULE_RUNTIME_FUNCTION(mod_xml_rpc_runtime)
 {
-	TServer abyssServer;
+
 	xmlrpc_registry *registryP;
 	xmlrpc_env env;
 	char logfile[512];
@@ -690,22 +701,23 @@ SWITCH_MODULE_RUNTIME_FUNCTION(mod_xml_rpc_runtime)
 	}
 
 	snprintf(logfile, sizeof(logfile), "%s%s%s", SWITCH_GLOBAL_dirs.log_dir, SWITCH_PATH_SEPARATOR, "freeswitch_http.log");
-	ServerCreate(&abyssServer, "XmlRpcServer", globals.port, SWITCH_GLOBAL_dirs.htdocs_dir, logfile);
+	ServerCreate(&globals.abyssServer, "XmlRpcServer", globals.port, SWITCH_GLOBAL_dirs.htdocs_dir, logfile);
 
-	xmlrpc_server_abyss_set_handler(&env, &abyssServer, "/RPC2", registryP);
+	xmlrpc_server_abyss_set_handler(&env, &globals.abyssServer, "/RPC2", registryP);
 
-	if (ServerInit(&abyssServer) != TRUE) {
+	if (ServerInit(&globals.abyssServer) != TRUE) {
 		globals.running = 0;
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to start HTTP Port %d\n", globals.port);
 		return SWITCH_STATUS_TERM;
 	}
 
 
-	ServerAddHandler(&abyssServer, handler_hook);
-	ServerAddHandler(&abyssServer, auth_hook);
+	ServerAddHandler(&globals.abyssServer, handler_hook);
+	ServerAddHandler(&globals.abyssServer, auth_hook);
 	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Starting HTTP Port %d, DocRoot [%s]\n", globals.port, SWITCH_GLOBAL_dirs.htdocs_dir);
 	while (globals.running) {
-		ServerRunOnce2(&abyssServer, ABYSS_FOREGROUND);
+		//ServerRunOnce2(&globals.abyssServer, ABYSS_FOREGROUND);
+		ServerRun(&globals.abyssServer);
 	}
 
 
@@ -716,7 +728,9 @@ SWITCH_MODULE_RUNTIME_FUNCTION(mod_xml_rpc_runtime)
 
 SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_xml_rpc_shutdown)
 {
+	globals.abyssServer.running = 0;
 	globals.running = 0;
+	
 	return SWITCH_STATUS_SUCCESS;
 }
 
diff --git a/src/switch_buffer.c b/src/switch_buffer.c
index 3ad58159fa..9107e6d983 100644
--- a/src/switch_buffer.c
+++ b/src/switch_buffer.c
@@ -46,6 +46,7 @@ struct switch_buffer {
 	switch_size_t datalen;
 	switch_size_t max_len;
 	switch_size_t blocksize;
+	switch_mutex_t *mutex;
 	uint32_t flags;
 	uint32_t id;
 	int32_t loops;
@@ -95,6 +96,33 @@ SWITCH_DECLARE(switch_status_t) switch_buffer_create_dynamic(switch_buffer_t **b
 	return SWITCH_STATUS_MEMERR;
 }
 
+SWITCH_DECLARE(void) switch_buffer_add_mutex(switch_buffer_t *buffer, switch_mutex_t *mutex)
+{
+	buffer->mutex = mutex;
+}
+
+SWITCH_DECLARE(void) switch_buffer_lock(switch_buffer_t *buffer)
+{
+	if (buffer->mutex) {
+		switch_mutex_lock(buffer->mutex);
+	}
+}
+
+SWITCH_DECLARE(switch_status_t) switch_buffer_trylock(switch_buffer_t *buffer)
+{
+	if (buffer->mutex) {
+		return switch_mutex_lock(buffer->mutex);
+	}
+	return SWITCH_STATUS_FALSE;
+}
+
+SWITCH_DECLARE(void) switch_buffer_unlock(switch_buffer_t *buffer)
+{
+	if (buffer->mutex) {
+		switch_mutex_unlock(buffer->mutex);
+	}
+}
+
 SWITCH_DECLARE(switch_size_t) switch_buffer_len(switch_buffer_t *buffer)
 {
 
@@ -224,7 +252,7 @@ SWITCH_DECLARE(switch_size_t) switch_buffer_write(switch_buffer_t *buffer, const
 	   }
 	 */
 	if (switch_test_flag(buffer, SWITCH_BUFFER_FLAG_DYNAMIC)) {
-		if (freespace < datalen) {
+		if (freespace < datalen && (!buffer->max_len || (buffer->datalen + datalen <= buffer->max_len))) {
 			switch_size_t new_size, new_block_size;
 
 			new_size = buffer->datalen + datalen;
@@ -266,6 +294,18 @@ SWITCH_DECLARE(void) switch_buffer_zero(switch_buffer_t *buffer)
 	buffer->head = buffer->data;
 }
 
+SWITCH_DECLARE(switch_size_t) switch_buffer_zwrite(switch_buffer_t *buffer, const void *data, switch_size_t datalen)
+{
+	switch_size_t w;
+	
+	if (!(w = switch_buffer_write(buffer, data, datalen))) {
+		switch_buffer_zero(buffer);
+		return switch_buffer_write(buffer, data, datalen);
+	}
+
+	return w;
+}
+
 SWITCH_DECLARE(void) switch_buffer_destroy(switch_buffer_t **buffer)
 {
 	if (buffer && *buffer) { 
diff --git a/src/switch_core_io.c b/src/switch_core_io.c
index 8006663a07..f08a7f0811 100644
--- a/src/switch_core_io.c
+++ b/src/switch_core_io.c
@@ -150,7 +150,7 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_read_frame(switch_core_sessi
 		goto done;
 	}
 
-	if ((*frame)->codec->implementation->actual_samples_per_second != session->write_codec->implementation->actual_samples_per_second) {
+	if ((*frame)->codec->implementation->actual_samples_per_second != session->read_codec->implementation->actual_samples_per_second) {
 		do_resample = 1;
 	}
 
@@ -246,7 +246,9 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_read_frame(switch_core_sessi
 						}
 					}
 					switch_mutex_unlock(bp->read_mutex);
-				} else if (switch_test_flag(bp, SMBF_READ_REPLACE)) {
+				} 
+
+				if (switch_test_flag(bp, SMBF_READ_REPLACE)) {
 					do_bugs = 0;
 					if (bp->callback) {
 						bp->read_replace_frame_in = read_frame;
@@ -432,7 +434,7 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_write_frame(switch_core_sess
 		need_codec = 1;
 	}
 
-	if (frame->codec->implementation->actual_samples_per_second != session->read_codec->implementation->actual_samples_per_second) {
+	if (frame->codec->implementation->actual_samples_per_second != session->write_codec->implementation->actual_samples_per_second) {
 		need_codec = 1;
 		do_resample = 1;
 	}
@@ -489,6 +491,7 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_write_frame(switch_core_sess
 				return status;
 			}
 		}
+
 		if (session->write_resampler) {
 			short *data = write_frame->data;
 
@@ -509,6 +512,12 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_write_frame(switch_core_sess
 			write_frame->rate = session->write_resampler->to_rate;
 		}
 
+		if (do_bugs) {
+			do_write = 1;
+			write_frame = frame;
+			goto done;
+		}
+
 		if (session->bugs) {
 			switch_media_bug_t *bp, *dp, *last = NULL;
 
@@ -525,7 +534,9 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_write_frame(switch_core_sess
 					if (bp->callback) {
 						ok = bp->callback(bp, bp->user_data, SWITCH_ABC_TYPE_WRITE);
 					}
-				} else if (switch_test_flag(bp, SMBF_WRITE_REPLACE)) {
+				} 
+
+				if (switch_test_flag(bp, SMBF_WRITE_REPLACE)) {
 					do_bugs = 0;
 					if (bp->callback) {
 						bp->write_replace_frame_in = write_frame;
@@ -561,12 +572,6 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_write_frame(switch_core_sess
 			switch_thread_rwlock_unlock(session->bug_rwlock);
 		}
 
-		if (do_bugs) {
-			do_write = 1;
-			write_frame = frame;
-			goto done;
-		}
-
 		if (session->write_codec) {
 			if (write_frame->datalen == session->write_codec->implementation->bytes_per_frame) {
 				perfect = TRUE;
diff --git a/src/switch_core_state_machine.c b/src/switch_core_state_machine.c
index e8faf203c2..9c0a66e501 100644
--- a/src/switch_core_state_machine.c
+++ b/src/switch_core_state_machine.c
@@ -130,7 +130,8 @@ static void switch_core_standard_on_execute(switch_core_session_t *session)
 
 	while (switch_channel_get_state(session->channel) == CS_EXECUTE && extension->current_application) {
 		char *expanded = NULL;
-
+		int nomedia = 0;
+		
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Execute %s(%s)\n",
 						  extension->current_application->application_name, switch_str_nil(extension->current_application->application_data));
 		if ((application_interface = switch_loadable_module_get_application_interface(extension->current_application->application_name)) == 0) {
@@ -138,19 +139,19 @@ static void switch_core_standard_on_execute(switch_core_session_t *session)
 			switch_channel_hangup(session->channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
 			return;
 		}
-
-		if (switch_channel_test_flag(session->channel, CF_BYPASS_MEDIA) && !switch_test_flag(application_interface, SAF_SUPPORT_NOMEDIA)) {
-			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Application %s Cannot be used with NO_MEDIA mode!\n",
-							  extension->current_application->application_name);
-			switch_channel_hangup(session->channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
-			return;
-		}
-
+		
 		if (!application_interface->application_function) {
 			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No Function for %s\n", extension->current_application->application_name);
 			switch_channel_hangup(session->channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
 			return;
 		}
+		
+		if (switch_channel_test_flag(session->channel, CF_BYPASS_MEDIA) && !switch_test_flag(application_interface, SAF_SUPPORT_NOMEDIA)) {
+			switch_ivr_media(session->uuid_str, SMF_NONE);
+			nomedia++;
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Application %s Requires media!\n",
+							  extension->current_application->application_name);
+		}
 
 		if ((expanded =
 			 switch_channel_expand_variables(session->channel,
@@ -177,6 +178,12 @@ static void switch_core_standard_on_execute(switch_core_session_t *session)
 			goto top;
 		}
 
+		if (nomedia) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Application %s Releasing media\n",
+							  extension->current_application->application_name);
+			switch_ivr_nomedia(session->uuid_str, SMF_NONE);
+		}
+
 		extension->current_application = extension->current_application->next;
 	}
 
diff --git a/src/switch_ivr_async.c b/src/switch_ivr_async.c
index f3bf5212fd..cb0a4eb355 100644
--- a/src/switch_ivr_async.c
+++ b/src/switch_ivr_async.c
@@ -307,6 +307,274 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_stop_record_session(switch_core_sessi
 
 }
 
+
+struct eavesdrop_pvt {
+	switch_buffer_t *buffer;
+	switch_mutex_t *mutex;
+	switch_buffer_t *r_buffer;
+	switch_mutex_t *r_mutex;
+	switch_buffer_t *w_buffer;
+	switch_mutex_t *w_mutex;
+	uint32_t flags;
+};
+
+
+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 };
+	
+	frame.data = data;
+	frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE;
+
+	switch (type) {
+	case SWITCH_ABC_TYPE_INIT:
+		break;
+	case SWITCH_ABC_TYPE_CLOSE:
+		break;
+	case SWITCH_ABC_TYPE_WRITE:
+		if (ep->buffer) {
+			if (switch_core_media_bug_read(bug, &frame) == SWITCH_STATUS_SUCCESS) {
+                switch_buffer_lock(ep->buffer);
+                switch_buffer_zwrite(ep->buffer, frame.data, frame.datalen);
+                switch_buffer_unlock(ep->buffer);
+			}
+		} else {
+            return SWITCH_FALSE;
+        }
+		break;
+	case SWITCH_ABC_TYPE_READ:
+		break;
+
+	case SWITCH_ABC_TYPE_READ_REPLACE:
+		{
+			if (switch_test_flag(ep, ED_MUX_READ)) {
+				switch_frame_t *frame = switch_core_media_bug_get_read_replace_frame(bug);
+			
+				if (switch_buffer_inuse(ep->r_buffer) >= frame->datalen) {
+					uint32_t bytes;
+					switch_buffer_lock(ep->r_buffer);
+					bytes = (uint32_t) switch_buffer_read(ep->r_buffer, data, frame->datalen);
+			
+					frame->datalen = switch_merge_sln(frame->data, frame->samples, (int16_t *)data, bytes / 2) * 2;
+					frame->samples = frame->datalen / 2;
+				
+					switch_buffer_unlock(ep->r_buffer);
+					switch_core_media_bug_set_read_replace_frame(bug, frame);
+				}
+			}
+		}
+		break;
+
+	case SWITCH_ABC_TYPE_WRITE_REPLACE:
+		{
+			if (switch_test_flag(ep, ED_MUX_WRITE)) {
+				switch_frame_t *frame = switch_core_media_bug_get_write_replace_frame(bug);
+			
+				if (switch_buffer_inuse(ep->w_buffer) >= frame->datalen) {
+					uint32_t bytes;
+					switch_buffer_lock(ep->w_buffer);
+					bytes = (uint32_t) switch_buffer_read(ep->w_buffer, data, frame->datalen);
+			
+					frame->datalen = switch_merge_sln(frame->data, frame->samples, (int16_t *)data, bytes / 2) * 2;
+					frame->samples = frame->datalen / 2;
+				
+					switch_buffer_unlock(ep->w_buffer);
+					switch_core_media_bug_set_write_replace_frame(bug, frame);
+				}
+			}
+		}
+		break;
+
+	default:
+		break;
+	}
+
+	return SWITCH_TRUE;
+}
+
+
+SWITCH_DECLARE(switch_status_t) switch_ivr_eavesdrop_session(switch_core_session_t *session, const char *uuid, switch_eavesdrop_flag_t flags)
+{
+	switch_core_session_t *tsession;
+	switch_status_t status = SWITCH_STATUS_FALSE;
+	switch_channel_t *channel = switch_core_session_get_channel(session);
+	switch_codec_t *read_codec = switch_core_session_get_read_codec(session);
+	
+	if ((tsession = switch_core_session_locate(uuid))) {
+		struct eavesdrop_pvt ep = { 0 };
+		switch_media_bug_t *bug = NULL;
+		switch_channel_t *tchannel = switch_core_session_get_channel(tsession);
+		switch_frame_t *read_frame, write_frame = { 0 };
+		switch_codec_t codec = {0};
+		int16_t buf[1024];
+		switch_codec_t *tread_codec = switch_core_session_get_read_codec(tsession);
+		
+		
+		switch_channel_pre_answer(channel);
+		
+		if (switch_core_codec_init(&codec,
+								   "L16",
+								   NULL, 
+								   tread_codec->implementation->actual_samples_per_second,
+								   tread_codec->implementation->microseconds_per_frame / 1000,
+								   tread_codec->implementation->number_of_channels, 
+								   SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, 
+								   NULL, switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot init codec\n");
+			return status;
+		}
+		
+		switch_core_session_set_read_codec(session, &codec);
+		write_frame.codec = &codec;
+		write_frame.data = buf;
+		write_frame.buflen = sizeof(buf);
+		write_frame.rate = read_codec->implementation->actual_samples_per_second;
+		
+		ep.flags = flags;
+		switch_mutex_init(&ep.mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(tsession));
+		switch_buffer_create_dynamic(&ep.buffer, 1024, 2048, 2048);
+		switch_buffer_add_mutex(ep.buffer, ep.mutex);
+
+		switch_mutex_init(&ep.w_mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(tsession));
+		switch_buffer_create_dynamic(&ep.w_buffer, 1024, 2048, 2048);
+		switch_buffer_add_mutex(ep.w_buffer, ep.w_mutex);
+
+		switch_mutex_init(&ep.r_mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(tsession));
+		switch_buffer_create_dynamic(&ep.r_buffer, 1024, 2048, 2048);
+		switch_buffer_add_mutex(ep.r_buffer, ep.r_mutex);
+
+		
+		if (switch_core_media_bug_add(tsession, eavesdrop_callback, &ep, 0, 
+									  SMBF_READ_STREAM | SMBF_WRITE_STREAM | SMBF_READ_REPLACE | SMBF_WRITE_REPLACE, 
+									  &bug) != SWITCH_STATUS_SUCCESS) {
+			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot attach bug\n");
+			goto end;
+		}
+		
+        while(switch_channel_ready(tchannel) && switch_channel_ready(channel)) {
+			uint32_t len = sizeof(buf);
+			switch_event_t *event = NULL;
+			char *fcommand = NULL;
+			
+			status = switch_core_session_read_frame(session, &read_frame, 1000, 0);
+			
+			if (!SWITCH_READ_ACCEPTABLE(status)) {
+				goto end;
+			}
+
+			if (switch_core_session_dequeue_event(session, &event) == SWITCH_STATUS_SUCCESS) {
+				char *command = switch_event_get_header(event, "eavesdrop-command");
+				if (command) {
+					fcommand = command;
+				}
+				switch_event_destroy(&event);
+			}
+
+			if ((flags & ED_DTMF) && switch_channel_has_dtmf(channel)) {
+				char dtmf[128] = "";
+				switch_channel_dequeue_dtmf(channel, dtmf, sizeof(dtmf));
+				fcommand = dtmf;
+			}
+
+			if (fcommand) {
+				char *d;
+				for(d = fcommand; *d; d++) {
+					int z = 1;
+					
+					switch (*d) {
+					case '1':
+						switch_set_flag((&ep), ED_MUX_READ);
+						switch_clear_flag((&ep), ED_MUX_WRITE);
+						break;
+					case '2':
+						switch_set_flag((&ep), ED_MUX_WRITE);
+						switch_clear_flag((&ep), ED_MUX_READ);
+						break;
+					case '3':
+						switch_set_flag((&ep), ED_MUX_READ);
+						switch_set_flag((&ep), ED_MUX_WRITE);
+						break;
+					case '0':
+						switch_clear_flag((&ep), ED_MUX_READ);
+						switch_clear_flag((&ep), ED_MUX_WRITE);
+						break;
+					default:
+						z = 0;
+						break;
+
+					}
+					
+					if (z) {
+						switch_buffer_lock(ep.r_buffer);
+						switch_buffer_zero(ep.r_buffer);
+						switch_buffer_unlock(ep.r_buffer);
+						
+						switch_buffer_lock(ep.w_buffer);
+						switch_buffer_zero(ep.w_buffer);
+						switch_buffer_unlock(ep.w_buffer);
+					}
+				}
+			}
+
+			if (!switch_test_flag(read_frame, SFF_CNG)) {
+				switch_buffer_lock(ep.r_buffer);
+				switch_buffer_zwrite(ep.r_buffer, read_frame->data, read_frame->datalen);
+				switch_buffer_unlock(ep.r_buffer);
+
+				switch_buffer_lock(ep.w_buffer);
+				switch_buffer_zwrite(ep.w_buffer, read_frame->data, read_frame->datalen);
+				switch_buffer_unlock(ep.w_buffer);
+			}
+
+
+			if (len > tread_codec->implementation->samples_per_frame * 2) {
+				len = tread_codec->implementation->samples_per_frame * 2;
+			}
+			
+            if (switch_buffer_inuse(ep.buffer) >= len) {
+                switch_buffer_lock(ep.buffer);				
+                write_frame.datalen = switch_buffer_read(ep.buffer, buf, len);
+				write_frame.samples = write_frame.datalen / 2;
+				if (switch_core_session_write_frame(session, &write_frame, 1000, 0) != SWITCH_STATUS_SUCCESS) {
+					goto end;
+				}
+                switch_buffer_unlock(ep.buffer);
+            }
+        }
+
+
+    end:
+
+		switch_core_codec_destroy(&codec);
+
+        if (bug) {
+            switch_core_media_bug_remove(tsession, &bug);
+        }
+
+        if (ep.buffer) {
+            switch_buffer_destroy(&ep.buffer);
+        }
+
+        if (ep.r_buffer) {
+            switch_buffer_destroy(&ep.r_buffer);
+        }
+
+        if (ep.w_buffer) {
+            switch_buffer_destroy(&ep.w_buffer);
+        }
+
+        switch_core_session_rwunlock(tsession);
+		status = SWITCH_STATUS_SUCCESS;
+
+		switch_core_session_set_read_codec(session, read_codec);
+		switch_core_session_reset(session);
+    }
+	
+	return status;
+}
+
 SWITCH_DECLARE(switch_status_t) switch_ivr_record_session(switch_core_session_t *session, char *file, uint32_t limit, switch_file_handle_t *fh)
 {
 	switch_channel_t *channel;
diff --git a/src/switch_resample.c b/src/switch_resample.c
index f56ff3cb34..ba2d6f3f8f 100644
--- a/src/switch_resample.c
+++ b/src/switch_resample.c
@@ -215,6 +215,27 @@ SWITCH_DECLARE(void) switch_generate_sln_silence(int16_t *data, uint32_t samples
 	}
 }
 
+SWITCH_DECLARE(uint32_t) switch_merge_sln(int16_t *data, uint32_t samples, int16_t *other_data, uint32_t other_samples)
+{
+	int i;
+	int32_t x, z;
+
+	if (samples > other_samples) {
+		x = other_samples;
+	} else {
+		x = samples;
+	}
+
+	for(i = 0; i < x; i++) {
+		z = data[i] + other_data[i];
+		switch_normalize_to_16bit(z);
+		data[i] = (int16_t) z;
+	}
+
+	return x;
+
+}
+
 
 SWITCH_DECLARE(void) switch_change_sln_volume(int16_t *data, uint32_t samples, int32_t vol)
 {