Changeset 205 for pjproject/trunk/pjmedia/src/pjmedia/conference.c

Timestamp:

Feb 21, 2006 12:11:18 AM (18 years ago)

Author:

bennylp

Message:

Initial conference implementation

File:

• pjproject/trunk/pjmedia/src/pjmedia/conference.c (moved) (moved from pjproject/trunk/pjmedia/src/pjmedia/audio_conf.c) (11 diffs)

pjproject/trunk/pjmedia/src/pjmedia/conference.c

@@ -17 +17 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
  */
-#include <pjmedia/audio_conf.h>
+#include <pjmedia/conference.h>
 #include <pjmedia/vad.h>
 #include <pjmedia/stream.h>
 #include <pjmedia/sound.h>
 #include <pjmedia/errno.h>
+#include <pjmedia/port.h>
 #include <pj/assert.h>
 #include <pj/log.h>
@@ -27 +28 @@
 #include <pj/string.h>
 
-
-
-#define THIS_FILE   "audio_conf.c"
+//#define CONF_DEBUG
+#ifdef CONF_DEBUG
+#   include <stdio.h>
+#   define TRACE_(x)   printf x
+#else
+#   define TRACE_(x)
+#endif
+
+
+#define THIS_FILE       "conference.c"
+#define RX_BUF_COUNT    8
+
+/*
+ * DON'T GET CONFUSED!!
+ *
+ * TX and RX directions are always viewed from the conference bridge's point
+ * of view, and NOT from the port's point of view. 
+ */
 
 
 struct conf_port
 {
-    pj_str_t             name;
-    pjmedia_stream_port *port;
-    pj_bool_t            online;
-    pj_bool_t            is_member;
-    pjmedia_vad         *vad;
-    pj_int32_t           level;
+    pj_str_t             name;          /**< Port name.                     */
+    pjmedia_port        *port;          /**< get_frame() and put_frame()    */
+    pjmedia_port_op      rx_setting;    /**< Can we receive from this port  */
+    pjmedia_port_op      tx_setting;    /**< Can we transmit to this port   */
+    pj_bool_t           *listeners;     /**< Array of listeners.            */
+    pjmedia_vad         *vad;           /**< VAD for this port.             */
+
+    /* Tx buffer contains the frame to be "transmitted" to this port
+     * (i.e. for put_frame()).
+     * We use dual buffer since the port may be accessed by two threads,
+     * and we don't want to use mutex for synchronization.
+     */
+    pj_int16_t          *cur_tx_buf;    /**< Buffer for put_frame().        */
+    pj_int16_t          *tx_buf1;       /**< Buffer 1.                      */
+    pj_int16_t          *tx_buf2;       /**< Buffer 2.                      */
+
+    /* Rx buffers is a special buffer for sound device port (port 0). 
+     * It's not used by other ports.
+     */
+    int                  rx_write, rx_read;
+    pj_int16_t          *rx_buf[RX_BUF_COUNT];  /**< Buffer                         */
+
+
+    /* Sum buf is a temporary buffer used to calculate the average signal
+     * received by this port from all other ports.
+     */
+    unsigned             sources;       /**< Number of sources.             */
+    pj_uint32_t         *sum_buf;       /**< Total sum of signal.           */
 };
 
+
 /*
  * Conference bridge.
@@ -47 +86 @@
 struct pjmedia_conf
 {
-    unsigned              max_ports;    /**< Maximum ports.             */
-    unsigned              port_cnt;     /**< Current number of ports.   */
-    pj_snd_stream        *snd_rec;      /**< Sound recorder stream.     */
-    pj_snd_stream        *snd_player;   /**< Sound player stream.       */
-    struct conf_port    **port;         /**< Array of ports.            */
-    pj_int16_t           *rec_buf;      /**< Sample buffer for rec.     */
-    pj_int16_t           *play_buf;     /**< Sample buffer for player   */
-    unsigned              samples_cnt;  /**< Samples per frame.         */
-    pj_size_t             buf_size;     /**< Buffer size, in bytes.     */
+    unsigned              max_ports;    /**< Maximum ports.                 */
+    unsigned              port_cnt;     /**< Current number of ports.       */
+    unsigned              connect_cnt;  /**< Total number of connections    */
+    pj_snd_stream        *snd_rec;      /**< Sound recorder stream.         */
+    pj_snd_stream        *snd_player;   /**< Sound player stream.           */
+    struct conf_port    **ports;        /**< Array of ports.                */
+    pj_uint16_t          *uns_buf;      /**< Buf for unsigned conversion    */
+    unsigned              sampling_rate;        /**< Sampling rate.         */
+    unsigned              samples_per_frame;    /**< Samples per frame.     */
+    unsigned              bits_per_sample;      /**< Bits per sample.       */
+    pj_snd_stream_info    snd_info;
 };
 
@@ -69 +110 @@
                             /* in*/   unsigned size);
 
+/*
+ * Create port.
+ */
+static pj_status_t create_conf_port( pj_pool_t *pool,
+                                     pjmedia_conf *conf,
+                                     const pj_str_t *name,
+                                     struct conf_port **p_conf_port)
+{
+    struct conf_port *conf_port;
+    pj_status_t status;
+
+    /* Create port. */
+    conf_port = pj_pool_zalloc(pool, sizeof(struct conf_port));
+    PJ_ASSERT_RETURN(conf_port, PJ_ENOMEM);
+
+    /* Set name */
+    pj_strdup(pool, &conf_port->name, name);
+
+    /* Default has tx and rx enabled. */
+    conf_port->rx_setting = PJMEDIA_PORT_ENABLE;
+    conf_port->tx_setting = PJMEDIA_PORT_ENABLE;
+
+    /* Create transmit flag array */
+    conf_port->listeners = pj_pool_zalloc(pool, 
+                                          conf->max_ports*sizeof(pj_bool_t));
+    PJ_ASSERT_RETURN(conf_port->listeners, PJ_ENOMEM);
+
+
+    /* Create and init vad. */
+    status = pjmedia_vad_create( pool, &conf_port->vad);
+    if (status != PJ_SUCCESS)
+        return status;
+
+    pjmedia_vad_set_adaptive(conf_port->vad, conf->samples_per_frame);
+
+
+    /* Create TX buffers. */
+    conf_port->tx_buf1 = pj_pool_zalloc(pool, conf->samples_per_frame *
+                                              sizeof(conf_port->tx_buf1[0]));
+    PJ_ASSERT_RETURN(conf_port->tx_buf1, PJ_ENOMEM);
+
+    conf_port->tx_buf2 = pj_pool_zalloc(pool, conf->samples_per_frame *
+                                              sizeof(conf_port->tx_buf2[0]));
+    PJ_ASSERT_RETURN(conf_port->tx_buf2, PJ_ENOMEM);
+
+    /* Set initial TX buffer */
+    conf_port->cur_tx_buf = conf_port->tx_buf1;
+
+    /* Create temporary buffer to calculate average signal received by
+     * this port.
+     */
+    conf_port->sum_buf = pj_pool_zalloc(pool, conf->samples_per_frame *
+                                              sizeof(conf_port->sum_buf[0]));
+
+    
+
+    /* Done */
+    *p_conf_port = conf_port;
+    return PJ_SUCCESS;
+}
+
+/*
+ * Create port zero for the sound device.
+ */
+static pj_status_t create_sound_port( pj_pool_t *pool,
+                                      pjmedia_conf *conf )
+{
+    struct conf_port *conf_port;
+    pj_str_t name = { "sound-device", 12 };
+    unsigned i;
+    pj_status_t status;
+
+
+    /* Init default sound device parameters. */
+    pj_memset(&conf->snd_info, 0, sizeof(conf->snd_info));
+    conf->snd_info.samples_per_sec = conf->sampling_rate;
+    conf->snd_info.bits_per_sample = conf->bits_per_sample;
+    conf->snd_info.samples_per_frame = conf->samples_per_frame;
+    conf->snd_info.bytes_per_frame = conf->samples_per_frame * 
+                               conf->bits_per_sample / 8;
+    conf->snd_info.frames_per_packet = 1;
+    
+
+    /* Create port */
+    status = create_conf_port(pool, conf, &name, &conf_port);
+    if (status != PJ_SUCCESS)
+        goto on_error;
+
+    /* Sound device has rx buffers. */
+    for (i=0; i<RX_BUF_COUNT; ++i) {
+        conf_port->rx_buf[i] = pj_pool_zalloc(pool, conf->samples_per_frame *
+                                              sizeof(conf_port->rx_buf[0][0]));
+        if (conf_port->rx_buf[i] == NULL) {
+            status = PJ_ENOMEM;
+            goto on_error;
+        }
+    }
+    conf_port->rx_write = 0;
+    conf_port->rx_read = 0;
+
+
+     /* Set to port zero */
+    conf->ports[0] = conf_port;
+    conf->port_cnt++;
+
+    PJ_LOG(5,(THIS_FILE, "Sound device successfully created for port 0"));
+    return PJ_SUCCESS;
+
+on_error:
+    return status;
+
+}
 
 /*
@@ -75 +228 @@
 PJ_DEF(pj_status_t) pjmedia_conf_create( pj_pool_t *pool,
                                          unsigned max_ports,
+                                         unsigned sampling_rate,
+                                         unsigned samples_per_frame,
+                                         unsigned bits_per_sample,
                                          pjmedia_conf **p_conf )
 {
     pjmedia_conf *conf;
-    pj_snd_stream_info snd_info;
     pj_status_t status;
 
+    PJ_LOG(5,(THIS_FILE, "Creating conference bridge with %d ports",
+              max_ports));
+
+    /* Create and init conf structure. */
     conf = pj_pool_zalloc(pool, sizeof(pjmedia_conf));
+    PJ_ASSERT_RETURN(conf, PJ_ENOMEM);
+
+    conf->ports = pj_pool_zalloc(pool, max_ports*sizeof(void*));
+    PJ_ASSERT_RETURN(conf->ports, PJ_ENOMEM);
+
     conf->max_ports = max_ports;
-    conf->port = pj_pool_zalloc(pool, max_ports*sizeof(void*));
-
-    /* Create default parameters. */
-    pj_memset(&snd_info, 0, sizeof(snd_info));
-    snd_info.samples_per_sec = 8000;
-    snd_info.bits_per_sample = 16;
-    snd_info.samples_per_frame = 160;
-    snd_info.bytes_per_frame = 16000;
-    snd_info.frames_per_packet = 1;
-
-    /* Create buffers. */
-    conf->samples_cnt = snd_info.samples_per_frame;
-    conf->buf_size = snd_info.samples_per_frame * snd_info.bits_per_sample / 8;
-    conf->rec_buf = pj_pool_alloc(pool,  conf->buf_size);
-    conf->play_buf = pj_pool_alloc(pool, conf->buf_size );
-
-
+    conf->sampling_rate = sampling_rate;
+    conf->samples_per_frame = samples_per_frame;
+    conf->bits_per_sample = bits_per_sample;
+
+
+    /* Create port zero for sound device. */
+    status = create_sound_port(pool, conf);
+    if (status != PJ_SUCCESS)
+        return status;
+
+    /* Create temporary buffer. */
+    conf->uns_buf = pj_pool_zalloc(pool, samples_per_frame *
+                                         sizeof(conf->uns_buf[0]));
+    /* Done */
+
+    *p_conf = conf;
+
+    return PJ_SUCCESS;
+}
+
+
+/*
+ * Create sound device
+ */
+static pj_status_t create_sound( pjmedia_conf *conf )
+{
     /* Open recorder. */
-    conf->snd_rec = pj_snd_open_recorder(-1 ,&snd_info, &rec_cb, conf);
+    conf->snd_rec = pj_snd_open_recorder(-1 ,&conf->snd_info, &rec_cb, conf);
     if (conf->snd_rec == NULL) {
-        status = -1;
-        goto on_error;
+        return -1;
     }
 
     /* Open player */
-    conf->snd_player = pj_snd_open_player(-1, &snd_info, &play_cb, conf);
+    conf->snd_player = pj_snd_open_player(-1, &conf->snd_info, &play_cb, conf);
     if (conf->snd_player == NULL) {
-        status = -1;
-        goto on_error;
-    }
-
-    /* Done */
-
-    *p_conf = conf;
-
-    return PJ_SUCCESS;
-
-
-on_error:
+        pj_snd_stream_close(conf->snd_rec);
+        return -1;
+    }
+
+    return PJ_SUCCESS;
+}
+
+/*
+ * Destroy sound device
+ */
+static pj_status_t destroy_sound( pjmedia_conf *conf )
+{
     if (conf->snd_rec) {
-        pj_snd_stream_stop(conf->snd_rec);
         pj_snd_stream_close(conf->snd_rec);
         conf->snd_rec = NULL;
     }
     if (conf->snd_player) {
-        pj_snd_stream_stop(conf->snd_player);
         pj_snd_stream_close(conf->snd_player);
         conf->snd_player = NULL;
     }
-    return status;
+    return PJ_SUCCESS;
 }
 
@@ -138 +308 @@
  * Activate sound device.
  */
-static pj_status_t activate_conf( pjmedia_conf *conf )
+static pj_status_t resume_sound( pjmedia_conf *conf )
 {
     char errmsg[PJ_ERR_MSG_SIZE];
     pj_status_t status;
 
+    if (conf->snd_rec == NULL) {
+        status = create_sound(conf);
+        if (status != PJ_SUCCESS)
+            return status;
+    }
+
     /* Start recorder. */
-    status = pj_snd_stream_start(conf->snd_rec);
-    if (status != PJ_SUCCESS)
-        goto on_error;
+    if (conf->snd_rec) {
+        status = pj_snd_stream_start(conf->snd_rec);
+        if (status != PJ_SUCCESS)
+            goto on_error;
+    }
 
     /* Start player. */
-    status = pj_snd_stream_start(conf->snd_rec);
-    if (status != PJ_SUCCESS)
-        goto on_error;
+    if (conf->snd_player) {
+        status = pj_snd_stream_start(conf->snd_player);
+        if (status != PJ_SUCCESS)
+            goto on_error;
+    }
 
     return PJ_SUCCESS;
@@ -166 +346 @@
  * Suspend sound device
  */
-static void suspend_conf( pjmedia_conf *conf )
-{
-    pj_snd_stream_stop(conf->snd_rec);
-    pj_snd_stream_stop(conf->snd_player);
+static void suspend_sound( pjmedia_conf *conf )
+{
+    if (conf->snd_rec)
+        pj_snd_stream_stop(conf->snd_rec);
+    if (conf->snd_player)
+        pj_snd_stream_stop(conf->snd_player);
+}
+
+
+/**
+ * Destroy conference bridge.
+ */
+PJ_DEF(pj_status_t) pjmedia_conf_destroy( pjmedia_conf *conf )
+{
+    PJ_ASSERT_RETURN(conf != NULL, PJ_EINVAL);
+
+    suspend_sound(conf);
+
+    pj_snd_stream_close(conf->snd_rec);
+    conf->snd_rec = NULL;
+    pj_snd_stream_close(conf->snd_player);
+    conf->snd_player = NULL;
+
+    return PJ_SUCCESS;
 }
 
@@ -178 +378 @@
 PJ_DEF(pj_status_t) pjmedia_conf_add_port( pjmedia_conf *conf,
                                            pj_pool_t *pool,
-                                           pjmedia_stream_port *strm_port,
+                                           pjmedia_port *strm_port,
                                            const pj_str_t *port_name,
                                            unsigned *p_port )
@@ -194 +394 @@
     }
 
+    /* Find empty port in the conference bridge. */
+    for (index=0; index < conf->max_ports; ++index) {
+        if (conf->ports[index] == NULL)
+            break;
+    }
+
+    pj_assert(index != conf->max_ports);
+
     /* Create port structure. */
-    conf_port = pj_pool_zalloc(pool, sizeof(struct conf_port));
-    pj_strdup_with_null(pool, &conf_port->name, port_name);
-    conf_port->port = strm_port;
-    conf_port->online = PJ_TRUE;
-    conf_port->level = 0;
-
-    /* Create VAD for this port. */
-    status = pjmedia_vad_create(pool, &conf_port->vad);
+    status = create_conf_port(pool, conf, port_name, &conf_port);
     if (status != PJ_SUCCESS)
         return status;
 
-    /* Set vad settings. */
-    pjmedia_vad_set_adaptive(conf_port->vad, conf->samples_cnt);
-
-    /* Find empty port in the conference bridge. */
-    for (index=0; index < conf->max_ports; ++index) {
-        if (conf->port[index] == NULL)
-            break;
-    }
-
-    pj_assert(index != conf->max_ports);
+    /* Set the port */
+    conf_port->port = strm_port;
 
     /* Put the port. */
-    conf->port[index] = conf_port;
+    conf->ports[index] = conf_port;
     conf->port_cnt++;
 
-    /* If this is the first port, activate sound device. */
-    if (conf->port_cnt == 1) {
-        status = activate_conf(conf);;
-        if (status != PJ_SUCCESS) {
-            conf->port[index] = NULL;
-            --conf->port_cnt;
-            return status;
+    /* Done. */
+    *p_port = index;
+
+    return PJ_SUCCESS;
+}
+
+
+/*
+ * Change TX and RX settings for the port.
+ */
+PJ_DECL(pj_status_t) pjmedia_conf_configure_port( pjmedia_conf *conf,
+                                                  unsigned slot,
+                                                  pjmedia_port_op tx,
+                                                  pjmedia_port_op rx)
+{
+    struct conf_port *conf_port;
+
+    /* Check arguments */
+    PJ_ASSERT_RETURN(conf && slot<conf->max_ports, PJ_EINVAL);
+
+    /* Port must be valid. */
+    PJ_ASSERT_RETURN(conf->ports[slot] != NULL, PJ_EINVAL);
+
+    conf_port = conf->ports[slot];
+
+    if (tx != PJMEDIA_PORT_NO_CHANGE)
+        conf_port->tx_setting = tx;
+
+    if (rx != PJMEDIA_PORT_NO_CHANGE)
+        conf_port->rx_setting = rx;
+
+    return PJ_SUCCESS;
+}
+
+
+/*
+ * Connect port.
+ */
+PJ_DEF(pj_status_t) pjmedia_conf_connect_port( pjmedia_conf *conf,
+                                               unsigned src_slot,
+                                               unsigned sink_slot )
+{
+    struct conf_port *src_port, *dst_port;
+
+    /* Check arguments */
+    PJ_ASSERT_RETURN(conf && src_slot<conf->max_ports && 
+                     sink_slot<conf->max_ports, PJ_EINVAL);
+
+    /* Ports must be valid. */
+    PJ_ASSERT_RETURN(conf->ports[src_slot] != NULL, PJ_EINVAL);
+    PJ_ASSERT_RETURN(conf->ports[sink_slot] != NULL, PJ_EINVAL);
+
+    src_port = conf->ports[src_slot];
+    dst_port = conf->ports[sink_slot];
+
+    if (src_port->listeners[sink_slot] == 0) {
+        src_port->listeners[sink_slot] = 1;
+        ++conf->connect_cnt;
+
+        if (conf->connect_cnt == 1)
+            resume_sound(conf);
+
+        PJ_LOG(5,(THIS_FILE,"Port %.*s transmitting to port %.*s",
+                  (int)src_port->name.slen,
+                  src_port->name.ptr,
+                  (int)dst_port->name.slen,
+                  dst_port->name.ptr));
+    }
+
+    return PJ_SUCCESS;
+}
+
+
+/*
+ * Disconnect port
+ */
+PJ_DEF(pj_status_t) pjmedia_conf_disconnect_port( pjmedia_conf *conf,
+                                                  unsigned src_slot,
+                                                  unsigned sink_slot )
+{
+    struct conf_port *src_port, *dst_port;
+
+    /* Check arguments */
+    PJ_ASSERT_RETURN(conf && src_slot<conf->max_ports && 
+                     sink_slot<conf->max_ports, PJ_EINVAL);
+
+    /* Ports must be valid. */
+    PJ_ASSERT_RETURN(conf->ports[src_slot] != NULL, PJ_EINVAL);
+    PJ_ASSERT_RETURN(conf->ports[sink_slot] != NULL, PJ_EINVAL);
+
+    src_port = conf->ports[src_slot];
+    dst_port = conf->ports[sink_slot];
+
+    if (src_port->listeners[sink_slot] != 0) {
+        src_port->listeners[sink_slot] = 0;
+        --conf->connect_cnt;
+
+        PJ_LOG(5,(THIS_FILE,"Port %.*s stop transmitting to port %.*s",
+                  (int)src_port->name.slen,
+                  src_port->name.ptr,
+                  (int)dst_port->name.slen,
+                  dst_port->name.ptr));
+
+        if (conf->connect_cnt == 0) {
+            suspend_sound(conf);
+            destroy_sound(conf);
         }
     }
 
-    /* Done. */
-    return PJ_SUCCESS;
-}
-
-
-/*
- * Mute or unmute port.
- */
-PJ_DEF(pj_status_t) pjmedia_conf_set_mute( pjmedia_conf *conf,
-                                           unsigned port,
-                                           pj_bool_t mute )
-{
+    return PJ_SUCCESS;
+}
+
+
+/*
+ * Remove the specified port.
+ */
+PJ_DEF(pj_status_t) pjmedia_conf_remove_port( pjmedia_conf *conf,
+                                              unsigned port )
+{
+    struct conf_port *conf_port;
+    unsigned i;
+
     /* Check arguments */
     PJ_ASSERT_RETURN(conf && port < conf->max_ports, PJ_EINVAL);
 
     /* Port must be valid. */
-    PJ_ASSERT_RETURN(conf->port[port] != NULL, PJ_EINVAL);
-
-    conf->port[port]->online = !mute;
-    
-    return PJ_SUCCESS;
-}
-
-
-/*
- * Set the specified port to be member of conference bridge.
- */
-PJ_DEF(pj_status_t) pjmedia_conf_set_membership( pjmedia_conf *conf,
-                                                 unsigned port,
-                                                 pj_bool_t enabled )
-{
-    /* Check arguments */
-    PJ_ASSERT_RETURN(conf && port < conf->max_ports, PJ_EINVAL);
-
-    /* Port must be valid. */
-    PJ_ASSERT_RETURN(conf->port[port] != NULL, PJ_EINVAL);
-
-    conf->port[port]->is_member = enabled;
-    
-    return PJ_SUCCESS;
-}
-
-
-/*
- * Remove the specified port.
- */
-PJ_DEF(pj_status_t) pjmedia_conf_remove_port( pjmedia_conf *conf,
-                                              unsigned port )
-{
-    /* Check arguments */
-    PJ_ASSERT_RETURN(conf && port < conf->max_ports, PJ_EINVAL);
-
-    /* Port must be valid. */
-    PJ_ASSERT_RETURN(conf->port[port] != NULL, PJ_EINVAL);
+    PJ_ASSERT_RETURN(conf->ports[port] != NULL, PJ_EINVAL);
 
     /* Suspend the sound devices.
      * Don't want to remove port while port is being accessed by sound
-     * device's threads.
+     * device's threads!
      */
-    suspend_conf(conf);
+    //suspend_sound(conf);
+
+    conf_port = conf->ports[port];
+    conf_port->tx_setting = PJMEDIA_PORT_DISABLE;
+    conf_port->rx_setting = PJMEDIA_PORT_DISABLE;
+
+    /* Remove this port from transmit array of other ports. */
+    for (i=0; i<conf->max_ports; ++i) {
+        conf_port = conf->ports[i];
+
+        if (!conf_port)
+            continue;
+
+        if (conf_port->listeners[port] != 0) {
+            --conf->connect_cnt;
+            conf_port->listeners[port] = 0;
+        }
+    }
+
+    /* Remove all ports listening from this port. */
+    conf_port = conf->ports[port];
+    for (i=0; i<conf->max_ports; ++i) {
+        if (conf_port->listeners[i])
+            --conf->connect_cnt;
+    }
 
     /* Remove the port. */
-    conf->port[port] = NULL;
+    conf->ports[port] = NULL;
     --conf->port_cnt;
 
-    /* Reactivate sound device if ports are not zero */
-    if (conf->port_cnt != 0)
-        activate_conf(conf);
-
-    return PJ_SUCCESS;
-}
-
+    /* Reactivate sound device if there are connections */
+    if (conf->connect_cnt != 0) {
+        //resume_sound(conf);
+    } else {
+        destroy_sound(conf);
+    }
+
+    pj_thread_sleep(60);
+    return PJ_SUCCESS;
+}
+
+/*
+ * Get port info
+ */
+PJ_DEF(pj_status_t) pjmedia_conf_get_port_info( pjmedia_conf *conf,
+                                                unsigned slot,
+                                                pjmedia_conf_port_info *info)
+{
+    struct conf_port *conf_port;
+
+    /* Check arguments */
+    PJ_ASSERT_RETURN(conf && slot<conf->max_ports, PJ_EINVAL);
+
+    /* Port must be valid. */
+    PJ_ASSERT_RETURN(conf->ports[slot] != NULL, PJ_EINVAL);
+
+    conf_port = conf->ports[slot];
+
+    info->name = conf_port->name;
+    info->tx_setting = conf_port->tx_setting;
+    info->rx_setting = conf_port->rx_setting;
+    info->listener = conf_port->listeners;
+
+    return PJ_SUCCESS;
+}
+
+
+/* Convert signed 16bit pcm sample to unsigned 16bit sample */
+static pj_uint16_t pcm2unsigned(pj_int32_t pcm)
+{
+    return (pj_uint16_t)(pcm + 32767);
+}
+
+/* Convert unsigned 16bit sample to signed 16bit pcm sample */
+static pj_int16_t unsigned2pcm(pj_uint32_t uns)
+{
+    return (pj_int16_t)(uns - 32767);
+}
 
 /*
@@ -314 +635 @@
     pjmedia_conf *conf = user_data;
     pj_int16_t *output_buf = output;
-    pj_int32_t highest_level = 0;
-    int highest_index = -1;
-    unsigned sources = 0;
     unsigned i, j;
     
     PJ_UNUSED_ARG(timestamp);
-
-    /* Clear temporary buffer. */
-    pj_memset(output_buf, 0, size);
-
-    /* Get frames from ports. */
+    PJ_UNUSED_ARG(size);
+
+    TRACE_(("p"));
+
+    /* Clear all port's tmp buffers. */
     for (i=0; i<conf->max_ports; ++i) {
-        struct conf_port *conf_port = conf->port[i];
+        struct conf_port *conf_port = conf->ports[i];
+        pj_uint32_t *sum_buf;
+
+        if (!conf_port)
+            continue;
+
+        conf_port->sources = 0;
+        sum_buf = conf_port->sum_buf;
+
+        for (j=0; j<conf->samples_per_frame; ++j)
+            sum_buf[j] = 0;
+    }
+
+    /* Get frames from all ports, and "add" the signal 
+     * to sum_buf of all listeners of the port.
+     */
+    for (i=0; i<conf->max_ports; ++i) {
+        struct conf_port *conf_port = conf->ports[i];
         pj_int32_t level;
         pj_bool_t silence;
 
+        /* Skip empty port. */
         if (!conf_port)
             continue;
 
-        conf_port->port->get_frame(conf->play_buf, conf->samples_cnt);
+        /* Skip if we're not allowed to receive from this port. */
+        if (conf_port->rx_setting == PJMEDIA_PORT_DISABLE) {
+            TRACE_(("rxdis:%d ", i));
+            continue;
+        }
+
+        /* Get frame from this port. 
+         * If port has rx_buffer, then get the frame from the rx_buffer
+         * instead.
+         */
+        if (i==0/*conf_port->cur_rx_buf*/) {
+            pj_int16_t *rx_buf;
+
+            if (conf_port->rx_read == conf_port->rx_write)
+                conf_port->rx_read = (conf_port->rx_write+RX_BUF_COUNT-RX_BUF_COUNT/2) % RX_BUF_COUNT;
+
+            rx_buf = conf_port->rx_buf[conf_port->rx_read];
+            for (j=0; j<conf->samples_per_frame; ++j) {
+                ((pj_int16_t*)output)[j] = rx_buf[j];
+            }
+            conf_port->rx_read = (conf_port->rx_read+1) % RX_BUF_COUNT;
+        } else {
+            pjmedia_frame frame;
+
+            pj_memset(&frame, 0, sizeof(frame));
+            frame.buf = output;
+            frame.size = size;
+            pjmedia_port_get_frame(conf_port->port, &frame);
+        }
+
+        /* Skip (after receiving the frame) if this port is muted. */
+        if (conf_port->rx_setting == PJMEDIA_PORT_MUTE)
+            continue;
+
+        /* Do we have signal? */
         silence = pjmedia_vad_detect_silence(conf_port->vad,
-                                             conf->play_buf, 
-                                             conf->samples_cnt,
+                                             output, 
+                                             conf->samples_per_frame,
                                              &level);
-        if (!silence) {
-            if (level > highest_level) {
-                highest_index = i;
-                highest_level = level;
-            }
-
-            ++sources;
-
-            for (j=0; j<conf->samples_cnt; ++j) {
-                output_buf[j] = (pj_int16_t)(output_buf[j] + conf->play_buf[j]);
+
+        /* Skip if we don't have signal. */
+        if (silence) {
+            TRACE_(("sil:%d ", i));
+            continue;
+        }
+
+        /* Convert the buffer to unsigned value */
+        for (j=0; j<conf->samples_per_frame; ++j)
+            conf->uns_buf[j] = pcm2unsigned(((pj_int16_t*)output)[j]);
+
+        /* Add the signal to all listeners. */
+        for (j=0; j<conf->max_ports; ++j) {
+            struct conf_port *listener = conf->ports[j];
+            pj_uint32_t *sum_buf;
+            unsigned k;
+
+            if (conf_port->listeners[j] == 0)
+                continue;
+
+            /* Skip if this listener doesn't want to receive audio */
+            if (listener->tx_setting != PJMEDIA_PORT_ENABLE)
+                continue;
+
+            //TRACE_(("mix:%d->%d ", i, j));
+
+            sum_buf = listener->sum_buf;
+            for (k=0; k<conf->samples_per_frame; ++k)
+                sum_buf[k] += conf->uns_buf[k];
+
+            listener->sources++;
+        }
+    }
+
+    /* For all ports, calculate avg signal. */
+    for (i=0; i<conf->max_ports; ++i) {
+        struct conf_port *conf_port = conf->ports[i];
+        pjmedia_frame frame;
+        pj_int16_t *target_buf;
+
+        if (!conf_port)
+            continue;
+
+
+        target_buf = (conf_port->cur_tx_buf==conf_port->tx_buf1?
+                        conf_port->tx_buf2 : conf_port->tx_buf1);
+
+        if (!conf_port->sources) {
+            for (j=0; j<conf->samples_per_frame; ++j)
+                target_buf[j] = 0;
+        } else {
+            for (j=0; j<conf->samples_per_frame; ++j) {
+                target_buf[j] = unsigned2pcm(conf_port->sum_buf[j] / conf_port->sources);
             }
         }
-    }
-
-    /* Calculate average signal. */
-    if (sources) {
-        for (j=0; j<conf->samples_cnt; ++j) {
-            output_buf[j] = (pj_int16_t)(output_buf[j] / sources);
-        }
-    }
-
-    /* Broadcast to conference member. */
-    for (i=0; i<conf->max_ports; ++i) {
-        struct conf_port *conf_port = conf->port[i];
-
-        if (!conf_port)
+
+        /* Switch buffer. */
+        conf_port->cur_tx_buf = target_buf;
+
+        if (conf_port->tx_setting != PJMEDIA_PORT_ENABLE)
             continue;
 
-        if (!conf_port->is_member)
-            continue;
-
-        conf_port->port->put_frame(output_buf, conf->samples_cnt);
-    }
-
-    return PJ_SUCCESS;
-}
+        pj_memset(&frame, 0, sizeof(frame));
+        frame.type = PJMEDIA_FRAME_TYPE_AUDIO;
+        frame.buf = conf_port->cur_tx_buf;
+        frame.size = conf->samples_per_frame * conf->bits_per_sample / 8;
+        frame.timestamp.u64 = timestamp;
+
+        if (conf_port->port)
+            pjmedia_port_put_frame(conf_port->port, &frame);
+
+    }
+
+    /* Return sound playback frame. */
+    for (j=0; j<conf->samples_per_frame; ++j)
+        output_buf[j] = conf->ports[0]->cur_tx_buf[j];
+
+    return PJ_SUCCESS;
+}
+
 
 /*
@@ -381 +795 @@
                             /* in */  pj_uint32_t timestamp,
                             /* in */  const void *input,
-                            /* in*/   unsigned size)
+                            /* in */  unsigned size)
 {
     pjmedia_conf *conf = user_data;
+    struct conf_port *snd_port = conf->ports[0];
+    pj_int16_t *target_rx_buf;
     unsigned i;
 
     PJ_UNUSED_ARG(timestamp);
-    PJ_UNUSED_ARG(size);
-
-    for (i=0; i<conf->max_ports; ++i) {
-        struct conf_port *conf_port = conf->port[i];
+    
+    TRACE_(("r"));
+
+    if (size != conf->samples_per_frame*2) {
+        TRACE_(("rxerr "));
+    }
+
+
+    /* Determine which rx_buffer to fill in */
+    target_rx_buf = snd_port->rx_buf[snd_port->rx_write];
+    
+    /* Copy samples from audio device to target rx_buffer */
+    for (i=0; i<conf->samples_per_frame; ++i) {
+        target_rx_buf[i] = ((pj_int16_t*)input)[i];
+    }
+
+    /* Switch buffer */
+    snd_port->rx_write = (snd_port->rx_write+1)%RX_BUF_COUNT;
+
+
+    /* Time for all ports (except sound port) to transmit frames */
+    /*
+    for (i=1; i<conf->max_ports; ++i) {
+        struct conf_port *conf_port = conf->ports[i];
+        pjmedia_frame frame;
 
         if (!conf_port)
             continue;
 
-        if (!conf_port->online)
-            continue;
-
-        conf_port->port->put_frame(input, conf->samples_cnt);
-    }
+    }
+    */
     
     return PJ_SUCCESS;