Changeset 513 for pjproject

Timestamp:

Jun 16, 2006 3:54:43 PM (18 years ago)

Author:

bennylp

Message:

Optimizations mostly in the conference bridge (gained more than 3x faster)

Location:

pjproject/trunk

Files:

• pjlib/include/pj/doxygen.h (modified) (7 diffs)
• pjmedia/include/pjmedia/conference.h (modified) (1 diff)
• pjmedia/include/pjmedia/types.h (modified) (3 diffs)
• pjmedia/src/pjmedia/conference.c (modified) (27 diffs)
• pjmedia/src/pjmedia/dsound.c (modified) (2 diffs)
• pjmedia/src/pjmedia/resample.c (modified) (11 diffs)
• pjsip-apps/build/Samples-vc.mak (modified) (1 diff)
• pjsip-apps/build/samples.dsp (modified) (1 diff)
• pjsip-apps/src/samples/confbench.c (added)
• pjsip-apps/src/samples/confsample.c (modified) (1 diff)
• pjsip/src/pjsua-lib/pjsua_media.c (modified) (1 diff)

pjproject/trunk/pjlib/include/pj/doxygen.h

@@ -35 +35 @@
  * @section intro_sec What is PJLIB
  *
- * PJLIB is a small foundation library written in C for making scalable 
- * applications. Because of its small footprint, it can be used in embedded 
- * applications (we hope so!), but yet the library is also aimed for 
- * facilitating high performance protocol stacks.
- *
- * PJLIB is released under LGPL terms.
+ * PJLIB is an Open Source, small footprint framework library written in C for 
+ * making scalable applications. Because of its small footprint, it can be used
+ * in embedded applications (we hope so!), but yet the library is also aimed for
+ * facilitating the creation of high performance protocol stacks.
+ *
+ * PJLIB is released under GPL terms.
  *
  * @section download_sec Download
@@ -56 +56 @@
  * @subsection doc_ver_subsec Version
  *
- * This document corresponds to PJLIB version 0.3-pre2.
+ * This document corresponds to PJLIB version 0.5.6.
  *
  *
@@ -115 +115 @@
  * @subsection open_source_feat It's Open Source!
  *
- * PJLIB is currently released on LGPL license. We may release PJLIB under
- * additional schemes in the future (such as GPL or MPL) to incorporate
- * linking with specific application, however, one thing for sure is
- * we will NEVER be able to make PJLIB a proprietary software.
+ * PJLIB is currently released on GPL license, but other arrangements
+ * can be made with the author.
  *
  * @subsection extreme_portable_feat Extreme Portability
@@ -128 +126 @@
  * It can even run in environment where no ANSI LIBC is available. 
  *
- * Currently PJLIB is being ported to:
- *  - x86, Win32 (Win95/98/ME, NT/2000/XP/2003, mingw).
- *  - x86, Linux (user mode and as <b>kernel module</b>(!)).
- *  - alpha, Linux
- * And coming up:
- *  - x86, eCos
- *  - ultra-II, Solaris.
- *  - powerpc, MacOS
- *  - m68k, PalmOS.
- *  - arm, PocketPC
- *
- * No other library is known to have this extreme portability!
+ * Currently PJLIB is known to run on these platforms:
+ *  - Win32/x86 (Win95/98/ME, NT/2000/XP/2003, mingw).
+ *  - arm, WinCE and Windows Mobile.
+ *  - Linux/x86, (user mode and as <b>kernel module</b>(!)).
+ *  - Linux/alpha
+ *  - Solaris/ultra.
+ *  - MacOS X/powerpc
+ *  - RTEMS (x86 and powerpc).
+ *
+ * And efforts is under way to port PJLIB on:
+ *  - Symbian OS
+ *
  *
  * @subsection small_size_feat Small in Size
@@ -152 +150 @@
  * For more info, please see @ref pj_config.
  *
+ *
+ * @subsection big_perform_feat Big in Performance
+ *
+ * Almost everything in PJLIB is designed to achieve the highest possible
+ * performance out of the target platform. 
+ *
+ *
  * @subsection no_dyn_mem No Dynamic Memory Allocations
  *
@@ -165 +170 @@
  *    destroyed.
  *
- * The performance gained on some systems can be as high as 10x speed up
- * against \a malloc() and \a free().
+ * The performance gained on some systems can be as high as 30x speed up
+ * against \a malloc() and \a free() on certain configurations, but of
+ * course your mileage may vary. 
  *
  * For more information, see \ref PJ_POOL_GROUP
@@ -384 +390 @@
  *
  * You MUST NOT use \a malloc() or any other memory allocation functions.
- * Use PJLIB pool instead! It's faster and most portable.
+ * Use PJLIB @ref PJ_POOL_GROUP instead! It's faster and most portable.
  *
  * @subsection logging_subsubsec Use Logging for Text Display
  *
- * DO NOT use <stdio.h> for text output. Use PJLIB logging instead.
+ * DO NOT use <stdio.h> for text output. Use PJLIB @ref PJ_LOG instead.
  *
  *

pjproject/trunk/pjmedia/include/pjmedia/conference.h

@@ -45 +45 @@
     pjmedia_port_op     tx_setting;         /**< Transmit settings.         */
     pjmedia_port_op     rx_setting;         /**< Receive settings.          */
-    pj_bool_t          *listener;           /**< Array of listeners.        */
+    unsigned            listener_cnt;       /**< Number of listeners.       */
+    unsigned           *listener_slots;     /**< Array of listeners.        */
     unsigned            clock_rate;         /**< Clock rate of the port.    */
     unsigned            channel_count;      /**< Number of channels.        */

pjproject/trunk/pjmedia/include/pjmedia/types.h

@@ -21 +21 @@
 
 #include <pjmedia/config.h>
-#include <pj/sock.h>
+#include <pj/sock.h>        /* pjmedia_sock_info        */
+#include <pj/string.h>      /* pj_memcpy(), pj_memset() */
+
 
 /** 
@@ -125 +127 @@
 PJ_INLINE(void) pjmedia_zero_samples(pj_int16_t *samples, unsigned count)
 {
+#if 1
+    pj_memset(samples, 0, count*sizeof(pj_int16_t));
+#elif 0
     unsigned i;
-    for (i=0; i<count; ++i)
-        samples[i] = 0;
+    for (i=0; i<count; ++i) samples[i] = 0;
+#else
+    unsigned i;
+    count >>= 1;
+    for (i=0; i<count; ++i) ((pj_int32_t*)samples)[i] = (pj_int32_t)0;
+#endif
 }
 
@@ -140 +149 @@
                                      unsigned count)
 {
+#if 1
+    pj_memcpy(dst, src, count*sizeof(pj_int16_t));
+#elif 0
     unsigned i;
-    for (i=0; i<count; ++i)
-        dst[i] = src[i];
+    for (i=0; i<count; ++i) dst[i] = src[i];
+#else
+    unsigned i;
+    count >>= 1;
+    for (i=0; i<count; ++i) 
+        ((pj_int32_t*)dst)[i] = ((pj_int32_t*)src)[i];
+#endif
 }
 

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

@@ -24 +24 @@
 #include <pjmedia/sound_port.h>
 #include <pjmedia/stream.h>
+#include <pj/array.h>
 #include <pj/assert.h>
 #include <pj/log.h>
@@ -58 +59 @@
 
 #define NORMAL_LEVEL        128
+#define SLOT_TYPE           unsigned
+#define INVALID_SLOT        ((SLOT_TYPE)-1)
 
 
@@ -79 +82 @@
     pjmedia_port_op      rx_setting;    /**< Can we receive from this port  */
     pjmedia_port_op      tx_setting;    /**< Can we transmit to this port   */
-    int                  listener_cnt;  /**< Number of listeners.           */
-    pj_bool_t           *listeners;     /**< Array of listeners.            */
+    unsigned             listener_cnt;  /**< Number of listeners.           */
+    SLOT_TYPE           *listener_slots;/**< Array of listeners.            */
+    unsigned             transmitter_cnt;/**<Number of transmitters.        */
     pjmedia_silence_det *vad;           /**< VAD for this port.             */
 
@@ -88 +92 @@
 
     /* Calculated signal levels: */
-    pj_bool_t            need_tx_level; /**< Need to calculate tx level?    */
     unsigned             tx_level;      /**< Last tx level to this port.    */
     unsigned             rx_level;      /**< Last rx level from this port.  */
@@ -122 +125 @@
      * received by this port from all other ports. Samples from all ports
      * that are transmitting to this port will be accumulated here, then
-     * they will be divided by the sources count before the samples are put
+     * they will be divided by the source level before the samples are put
      * to the TX buffer of this port.
      *
@@ -130 +133 @@
      * Note that the samples here are unsigned 32bit.
      */
-    unsigned             sources;       /**< Number of sources.             */
+    unsigned             src_level;     /**< Sum of input levels            */
+    unsigned             src_cnt;       /**< Number of sources.             */
     pj_uint32_t         *mix_buf;       /**< Total sum of signal.           */
 
@@ -224 +228 @@
 
     /* 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);
-
+    conf_port->listener_slots = pj_pool_zalloc(pool, 
+                                          conf->max_ports * sizeof(SLOT_TYPE));
+    PJ_ASSERT_RETURN(conf_port->listener_slots, PJ_ENOMEM);
 
     /* Save some port's infos, for convenience. */
@@ -667 +670 @@
     struct conf_port *src_port, *dst_port;
     pj_bool_t start_sound = PJ_FALSE;
+    unsigned i;
 
     /* Check arguments */
@@ -684 +688 @@
     dst_port = conf->ports[sink_slot];
 
-    if (src_port->listeners[sink_slot] == 0) {
-        src_port->listeners[sink_slot] = 1;
+    /* Check if connection has been made */
+    for (i=0; i<src_port->listener_cnt; ++i) {
+        if (src_port->listener_slots[i] == sink_slot)
+            break;
+    }
+
+    if (i == src_port->listener_cnt) {
+        src_port->listener_slots[src_port->listener_cnt] = sink_slot;
         ++conf->connect_cnt;
         ++src_port->listener_cnt;
+        ++dst_port->transmitter_cnt;
 
         if (conf->connect_cnt == 1)
             start_sound = 1;
 
-        PJ_LOG(4,(THIS_FILE,"Port %.*s transmitting to port %.*s",
+        PJ_LOG(4,(THIS_FILE,"Port %d (%.*s) transmitting to port %d (%.*s)",
+                  src_slot,
                   (int)src_port->name.slen,
                   src_port->name.ptr,
+                  sink_slot,
                   (int)dst_port->name.slen,
                   dst_port->name.ptr));
@@ -719 +732 @@
 {
     struct conf_port *src_port, *dst_port;
+    unsigned i;
 
     /* Check arguments */
@@ -733 +747 @@
     dst_port = conf->ports[sink_slot];
 
-    if (src_port->listeners[sink_slot] != 0) {
-        src_port->listeners[sink_slot] = 0;
+    /* Check if connection has been made */
+    for (i=0; i<src_port->listener_cnt; ++i) {
+        if (src_port->listener_slots[i] == sink_slot)
+            break;
+    }
+
+    if (i != src_port->listener_cnt) {
+        pj_assert(src_port->listener_cnt > 0 && 
+                  src_port->listener_cnt < conf->max_ports);
+        pj_assert(dst_port->transmitter_cnt > 0 && 
+                  dst_port->transmitter_cnt < conf->max_ports);
+        pj_array_erase(src_port->listener_slots, sizeof(SLOT_TYPE), 
+                       src_port->listener_cnt, i);
         --conf->connect_cnt;
         --src_port->listener_cnt;
-
-        PJ_LOG(4,(THIS_FILE,"Port %.*s stop transmitting to port %.*s",
+        --dst_port->transmitter_cnt;
+
+        PJ_LOG(4,(THIS_FILE,
+                  "Port %d (%.*s) stop transmitting to port %d (%.*s)",
+                  src_slot,
                   (int)src_port->name.slen,
                   src_port->name.ptr,
+                  sink_slot,
                   (int)dst_port->name.slen,
                   dst_port->name.ptr));
@@ -785 +814 @@
     /* Remove this port from transmit array of other ports. */
     for (i=0; i<conf->max_ports; ++i) {
+        unsigned j;
+
         conf_port = conf->ports[i];
 
@@ -790 +821 @@
             continue;
 
-        if (conf_port->listeners[port] != 0) {
-            --conf->connect_cnt;
-            --conf_port->listener_cnt;
-            conf_port->listeners[port] = 0;
+        if (conf_port->listener_cnt == 0)
+            continue;
+
+        for (j=0; j<conf_port->listener_cnt; ++j) {
+            if (conf_port->listener_slots[j] == port) {
+                pj_array_erase(conf_port->listener_slots, sizeof(SLOT_TYPE),
+                               conf_port->listener_cnt, j);
+                --conf->connect_cnt;
+                --conf_port->listener_cnt;
+                break;
+            }
         }
     }
 
-    /* Remove all ports listening from this port. */
+    /* Update conf's connection count. */
     conf_port = conf->ports[port];
-    for (i=0; i<conf->max_ports; ++i) {
-        if (conf_port->listeners[i]) {
-            --conf->connect_cnt;
-            --conf_port->listener_cnt;
-        }
-    }
+    conf->connect_cnt -= conf_port->listener_cnt;
 
     /* Remove the port. */
@@ -865 +898 @@
     info->tx_setting = conf_port->tx_setting;
     info->rx_setting = conf_port->rx_setting;
-    info->listener = conf_port->listeners;
+    info->listener_cnt = conf_port->listener_cnt;
+    info->listener_slots = conf_port->listener_slots;
     info->clock_rate = conf_port->clock_rate;
     info->channel_count = conf->channel_count;
@@ -917 +951 @@
 
     if (tx_level != NULL) {
-        conf_port->need_tx_level = 1;
         *tx_level = conf_port->tx_level;
     }
@@ -1121 +1154 @@
      */
     /* note:
-     *  the "cport->sources==0" checking will cause discontinuous
+     *  the "cport->src_level==0" checking will cause discontinuous
      *  transmission for RTP stream.
      */
-    if (cport->tx_setting == PJMEDIA_PORT_MUTE || cport->sources==0) {
+    if (cport->tx_setting == PJMEDIA_PORT_MUTE || cport->src_level==0) {
 
         pjmedia_frame frame;
@@ -1144 +1177 @@
     }
 
+    buf = (pj_int16_t*)cport->mix_buf;
+
+    /* This is the convention set in get_frame(). For optimization purpose,
+     * if we only have one transmitter transmitting to this port, then
+     * the transmitter will directly copy the original 16bit frame to
+     * mix_buf.
+     */
+    if (cport->transmitter_cnt==1 && cport->src_cnt == 1) {
+
+        /* But still see if we need to adjust the level */
+        if (cport->tx_adj_level != NORMAL_LEVEL) {
+            pj_int16_t *input = buf;
+            pj_int32_t adj = cport->tx_adj_level;
+
+            for (j=0; j<conf->samples_per_frame; ++j) {
+                pj_int32_t itemp;
+
+                /* For the level adjustment, we need to store the sample to
+                 * a temporary 32bit integer value to avoid overflowing the
+                 * 16bit sample storage.
+                 */
+                itemp = input[j];
+                itemp = itemp * adj / NORMAL_LEVEL;
+
+                /* Clip the signal if it's too loud */
+                if (itemp > 32767) itemp = 32767;
+                else if (itemp < -32768) itemp = -32768;
+
+                input[j] = (pj_int16_t) itemp;
+            }
+        }
+
+    } 
     /* If there are sources in the mix buffer, convert the mixed samples
      * to the mixed samples itself. This is possible because mixed sample
@@ -1151 +1217 @@
      * TX signal, we adjust is here too.
      */
-    buf = (pj_int16_t*)cport->mix_buf;
-
-    if (cport->tx_adj_level != NORMAL_LEVEL && cport->sources) {
+    else if (cport->tx_adj_level != NORMAL_LEVEL && cport->src_level) {
 
         unsigned adj_level = cport->tx_adj_level;
@@ -1164 +1228 @@
              * 16bit signed integer.
              */
-            itemp = unsigned2pcm(cport->mix_buf[j] / cport->sources);
+            itemp = unsigned2pcm(cport->mix_buf[j] / cport->src_level);
 
             /* Adjust the level */
@@ -1177 +1241 @@
         }
 
-    } else if (cport->sources) {
+    } else if (cport->src_level) {
         /* No need to adjust signal level. */
         for (j=0; j<conf->samples_per_frame; ++j) {
-            buf[j] = unsigned2pcm(cport->mix_buf[j] / cport->sources);
+            buf[j] = unsigned2pcm(cport->mix_buf[j] / cport->src_level);
         }
     } else {
         // Not necessarry. Buffer has been zeroed before.
         // pjmedia_zero_samples(buf, conf->samples_per_frame);
-        pj_assert(buf[0] == 0);
+        //pj_assert(buf[0] == 0);
+
+        // This shouldn't happen. Function should've already bailed out when
+        // cport->src_level == 0.
+        pj_assert(0);
     }
 
@@ -1197 +1265 @@
      * indication of the signal level of the port.
      */
-    if (cport->need_tx_level && cport->sources) {
-        pj_uint32_t level;
-
-        /* Get the signal level. */
-        level = pjmedia_calc_avg_signal(buf, conf->samples_per_frame);
-
-        /* Convert level to 8bit complement ulaw */
-        cport->tx_level = linear2ulaw(level) ^ 0xff;
-
+    if (cport->src_cnt) {
+        cport->tx_level = cport->src_level / cport->src_cnt;
     } else {
         cport->tx_level = 0;
@@ -1311 +1372 @@
                              conf->bits_per_sample / 8);
 
-    /* Must lock mutex (must we??) */
+    /* Must lock mutex */
     pj_mutex_lock(conf->mutex);
 
-    /* Zero all port's temporary buffers. */
+    /* Reset port source count. We will only reset port's mix
+     * buffer when we have someone transmitting to it.
+     */
     for (i=0, ci=0; i<conf->max_ports && ci < conf->port_cnt; ++i) {
         struct conf_port *conf_port = conf->ports[i];
-        pj_uint32_t *mix_buf;
 
         /* Skip empty slot. */
@@ -1325 +1387 @@
         ++ci;
 
-        conf_port->sources = 0;
-        mix_buf = conf_port->mix_buf;
-
-        pj_memset(mix_buf, 0, conf->samples_per_frame*sizeof(mix_buf[0]));
+        /* Reset sources */
+        conf_port->src_level = 0;
+        conf_port->src_cnt = 0;
     }
 
@@ -1442 +1503 @@
         conf_port->rx_level = level;
 
+        /* Skip processing frame if level is zero */
+        if (level == 0)
+            continue;
+
         /* Convert the buffer to unsigned 16bit value */
         for (j=0; j<conf->samples_per_frame; ++j)
@@ -1447 +1512 @@
 
         /* Add the signal to all listeners. */
-        for (j=0, cj=0; 
-             j<conf->max_ports && cj<(unsigned)conf_port->listener_cnt;
-             ++j) 
+        for (cj=0; cj < conf_port->listener_cnt; ++cj) 
         {
-            struct conf_port *listener = conf->ports[j];
+            struct conf_port *listener;
             pj_uint32_t *mix_buf;
             unsigned k;
 
-            if (listener == 0)
-                continue;
-
-            /* Skip if this is not the listener. */
-            if (!conf_port->listeners[j])
-                continue;
-
-            /* Var "cj" is the number of listeners we have visited so far */
-            ++cj;
+            listener = conf->ports[conf_port->listener_slots[cj]];
 
             /* Skip if this listener doesn't want to receive audio */
@@ -1469 +1524 @@
                 continue;
 
-            /* Mix the buffer */
+            /* Mix the buffer. If this is the first source for target port,
+             * zero the mix buffer of target port first.
+             */
             mix_buf = listener->mix_buf;
-            for (k=0; k<conf->samples_per_frame; ++k)
-                mix_buf[k] += (conf->uns_buf[k] * level);
-
-            listener->sources += level;
+            if (listener->src_level == 0) {
+                pj_memset(mix_buf, 0, 
+                          conf->samples_per_frame*sizeof(mix_buf[0]));
+            }
+
+            /* A little bit of optimization:
+             *  When "conf_port" is the only transmitter to "listener",
+             *  just add copy the frame directly from the original
+             *  16bit frame (avoiding unsigned2pcm() conversion).
+             *  But write_port() needs to be aware of this trick!
+             */
+            if (listener->transmitter_cnt == 1) {
+                pjmedia_copy_samples((pj_int16_t*)mix_buf, 
+                                     frame->buf, conf->samples_per_frame);
+                listener->src_level = level;
+            } else {
+                for (k=0; k<conf->samples_per_frame; ++k)
+                    mix_buf[k] += (conf->uns_buf[k] * level);
+
+                listener->src_level += level;
+            }
+            listener->src_cnt++;
         }
     }
@@ -1511 +1586 @@
 
     /* Return sound playback frame. */
-    if (conf->ports[0]->sources) {
+    if (conf->ports[0]->src_level) {
         TRACE_((THIS_FILE, "write to audio, count=%d", 
                            conf->samples_per_frame));

pjproject/trunk/pjmedia/src/pjmedia/dsound.c

@@ -369 +369 @@
     if SUCCEEDED(hr) { 
         // Read from pointers. 
-        CopyMemory(lpbSoundData, lpvPtr1, dwBytes1); 
+        pj_memcpy(lpbSoundData, lpvPtr1, dwBytes1); 
         if (lpvPtr2 != NULL)
-            CopyMemory(lpbSoundData+dwBytes1, lpvPtr2, dwBytes2); 
+            pj_memcpy(lpbSoundData+dwBytes1, lpvPtr2, dwBytes2); 
         
         // Release the data back to DirectSound. 
@@ -408 +408 @@
     } 
     if SUCCEEDED(hr) { 
-        CopyMemory(lpvPtr1, lpbSoundData, dwBytes1); 
+        pj_memcpy(lpvPtr1, lpbSoundData, dwBytes1); 
         if (NULL != lpvPtr2) 
-            CopyMemory(lpvPtr2, lpbSoundData+dwBytes1, dwBytes2); 
+            pj_memcpy(lpvPtr2, lpbSoundData+dwBytes1, dwBytes2); 
         
         hr = IDirectSoundBuffer_Unlock(lpDsb, lpvPtr1, dwBytes1, lpvPtr2, dwBytes2); 

pjproject/trunk/pjmedia/src/pjmedia/resample.c

@@ -59 +59 @@
  *  - move stddefs.h and resample.h to this file.
  *  - const correctness.
- *  - fixed SrcLinear() may write pass output buffer.
- *  - assume the same for SrcUp() and SrcUD(), so put the same
- *    protection.
  */
 #include <pjmedia/resample.h>
@@ -261 +258 @@
     Yend = Ystart + (unsigned)(nx * pFactor);
     endTime = time + (1<<Np)*(WORD)nx;
-    while (time < endTime && Y < Yend)  /* bennylp fix: added Y < Yend */
+    while (time < endTime)
     {
         iconst = (time) & Pmask;
@@ -400 +397 @@
     Yend = Ystart + (unsigned)(nx * pFactor);
     endTime = time + (1<<Np)*(WORD)nx;
-    while (time < endTime && Y < Yend)  /* bennylp fix: protect Y */
+    while (time < endTime)
     {
         xp = &X[time>>Np];      /* Ptr to current input sample */
@@ -444 +441 @@
     Yend = Ystart + (unsigned)(nx * pFactor);
     endTime = time + (1<<Np)*(WORD)nx;
-    while (time < endTime && Y < Yend) /* bennylp fix: protect Y */
+    while (time < endTime)
     {
         xp = &X[time>>Np];      /* Ptr to current input sample */
@@ -496 +493 @@
     /*
      * If we're downsampling, always use the fast algorithm since it seems
-     * to yield the same performance.
+     * to yield the same quality.
      */
     if (rate_out < rate_in) {
+        //no this is not a good idea. It sounds pretty good with speech,
+        //but very poor with background noise etc.
         //high_quality = 0;
     }
@@ -534 +533 @@
     if (high_quality) {
         unsigned size;
-        unsigned i;
 
         /* This is a bug in xoff calculation, thanks Stephane Lussier
@@ -552 +550 @@
         PJ_ASSERT_RETURN(resample->buffer, PJ_ENOMEM);
 
-        for (i=0; i<resample->xoff*2; ++i) {
-            resample->buffer[i] = 0;
-        }
+        pjmedia_zero_samples(resample->buffer, resample->xoff*2);
 
 
@@ -562 +558 @@
 
     *p_resample = resample;
+
+    PJ_LOG(5,(THIS_FILE, "resample created: %s qualiy, %s filter, in/out "
+                          "rate=%d/%d", 
+                          (high_quality?"high":"low"),
+                          (large_filter?"large":"small"),
+                          rate_in, rate_out));
     return PJ_SUCCESS;
 }
@@ -574 +576 @@
 
     if (resample->high_quality) {
-        unsigned i;
         pj_int16_t *dst_buf;
         const pj_int16_t *src_buf;
@@ -645 +646 @@
          */
         dst_buf = resample->buffer + resample->xoff*2;
-        for (i=0; i<resample->frame_size; ++i) dst_buf[i] = input[i];
+        pjmedia_copy_samples(dst_buf, input, resample->frame_size);
             
         if (resample->factor >= 1) {
@@ -689 +690 @@
         dst_buf = resample->buffer;
         src_buf = input + resample->frame_size - resample->xoff*2;
-        for (i=0; i<resample->xoff * 2; ++i) {
-            dst_buf[i] = src_buf[i];
-        }
+        pjmedia_copy_samples(dst_buf, src_buf, resample->xoff * 2);
 
     } else {

pjproject/trunk/pjsip-apps/build/Samples-vc.mak

@@ -37 +37 @@
 
 SAMPLES = $(BINDIR)\confsample.exe \
+          $(BINDIR)\confbench.exe \
           $(BINDIR)\level.exe \
           $(BINDIR)\playfile.exe \

pjproject/trunk/pjsip-apps/build/samples.dsp

@@ -87 +87 @@
 # Begin Source File
 
+SOURCE=..\src\samples\confbench.c
+# End Source File
+# Begin Source File
+
 SOURCE=..\src\samples\confsample.c
 # End Source File

pjproject/trunk/pjsip-apps/src/samples/confsample.c

@@ -476 +476 @@
         
         txlist[0] = '\0';
-        for (j=0; j<count; ++j) {
+        for (j=0; j<port_info->listener_cnt; ++j) {
             char s[10];
-            if (port_info->listener[j]) {
-                pj_ansi_sprintf(s, "#%d ", j);
-                pj_ansi_strcat(txlist, s);
-            }
+            pj_ansi_sprintf(s, "#%d ", port_info->listener_slots[j]);
+            pj_ansi_strcat(txlist, s);
+
         }
 

pjproject/trunk/pjsip/src/pjsua-lib/pjsua_media.c

@@ -549 +549 @@
 
     /* Build array of listeners */
-    count = pjsua_var.media_cfg.max_media_ports;
-    for (i=0; i<count; ++i) {
-        if (cinfo.listener[i]) {
-            info->listeners[info->listener_cnt++] = i;
-        }
+    info->listener_cnt = cinfo.listener_cnt;
+    for (i=0; i<cinfo.listener_cnt; ++i) {
+        info->listeners[i] = cinfo.listener_slots[i];
     }