HUGE changeset to make the rest of the libraries compile with C++ mode

git-svn-id: http://svn.pjsip.org/repos/pjproject/trunk@1266 74dad513-b988-da41-8d7b-12977e46ad98

35 files changed, 229 insertions, 200 deletions

diff --git a/pjmedia/src/pjmedia-codec/gsm.c b/pjmedia/src/pjmedia-codec/gsm.c
index d21956ae..c909339b 100644
--- a/pjmedia/src/pjmedia-codec/gsm.c
+++ b/pjmedia/src/pjmedia-codec/gsm.c
@@ -122,8 +122,8 @@ static struct gsm_codec_factory
 /* GSM codec private data. */
 struct gsm_data
 {
-    void		*encoder;
-    void		*decoder;
+    gsm_state		*encoder;
+    gsm_state		*decoder;
     pj_bool_t		 plc_enabled;
 #if !PLC_DISABLED
     pjmedia_plc		*plc;
@@ -323,14 +323,12 @@ static pj_status_t gsm_alloc_codec( pjmedia_codec_factory *factory,
 	codec = gsm_codec_factory.codec_list.next;
 	pj_list_erase(codec);
     } else {
-	codec = pj_pool_zalloc(gsm_codec_factory.pool, 
-			       sizeof(pjmedia_codec));
+	codec = PJ_POOL_ZALLOC_T(gsm_codec_factory.pool, pjmedia_codec);
 	PJ_ASSERT_RETURN(codec != NULL, PJ_ENOMEM);
 	codec->op = &gsm_op;
 	codec->factory = factory;
 
-	gsm_data = pj_pool_zalloc(gsm_codec_factory.pool, 
-				  sizeof(struct gsm_data));
+	gsm_data = PJ_POOL_ZALLOC_T(gsm_codec_factory.pool, struct gsm_data);
 	codec->codec_data = gsm_data;
 
 #if !PLC_DISABLED
@@ -371,7 +369,7 @@ static pj_status_t gsm_dealloc_codec( pjmedia_codec_factory *factory,
     PJ_ASSERT_RETURN(factory && codec, PJ_EINVAL);
     PJ_ASSERT_RETURN(factory == &gsm_codec_factory.base, PJ_EINVAL);
 
-    gsm_data = codec->codec_data;
+    gsm_data = (struct gsm_data*) codec->codec_data;
 
     /* Close codec, if it's not closed. */
     gsm_codec_close(codec);
@@ -417,7 +415,7 @@ static pj_status_t gsm_codec_init( pjmedia_codec *codec,
 static pj_status_t gsm_codec_open( pjmedia_codec *codec, 
 				   pjmedia_codec_param *attr )
 {
-    struct gsm_data *gsm_data = codec->codec_data;
+    struct gsm_data *gsm_data = (struct gsm_data*) codec->codec_data;
 
     pj_assert(gsm_data != NULL);
     pj_assert(gsm_data->encoder == NULL && gsm_data->decoder == NULL);
@@ -441,7 +439,7 @@ static pj_status_t gsm_codec_open( pjmedia_codec *codec,
  */
 static pj_status_t gsm_codec_close( pjmedia_codec *codec )
 {
-    struct gsm_data *gsm_data = codec->codec_data;
+    struct gsm_data *gsm_data = (struct gsm_data*) codec->codec_data;
 
     pj_assert(gsm_data != NULL);
 
@@ -464,7 +462,7 @@ static pj_status_t gsm_codec_close( pjmedia_codec *codec )
 static pj_status_t  gsm_codec_modify(pjmedia_codec *codec, 
 				     const pjmedia_codec_param *attr )
 {
-    struct gsm_data *gsm_data = codec->codec_data;
+    struct gsm_data *gsm_data = (struct gsm_data*) codec->codec_data;
 
     pj_assert(gsm_data != NULL);
     pj_assert(gsm_data->encoder != NULL && gsm_data->decoder != NULL);
@@ -516,7 +514,7 @@ static pj_status_t gsm_codec_encode( pjmedia_codec *codec,
 				     unsigned output_buf_len, 
 				     struct pjmedia_frame *output)
 {
-    struct gsm_data *gsm_data = codec->codec_data;
+    struct gsm_data *gsm_data = (struct gsm_data*) codec->codec_data;
 
     pj_assert(gsm_data != NULL);
     PJ_ASSERT_RETURN(input && output, PJ_EINVAL);
@@ -535,7 +533,7 @@ static pj_status_t gsm_codec_encode( pjmedia_codec *codec,
 					       &input->timestamp);
 
 	is_silence = pjmedia_silence_det_detect(gsm_data->vad, 
-					        input->buf,
+					        (const pj_int16_t*) input->buf,
 						(input->size >> 1),
 						NULL);
 	if (is_silence &&
@@ -570,7 +568,7 @@ static pj_status_t gsm_codec_decode( pjmedia_codec *codec,
 				     unsigned output_buf_len, 
 				     struct pjmedia_frame *output)
 {
-    struct gsm_data *gsm_data = codec->codec_data;
+    struct gsm_data *gsm_data = (struct gsm_data*) codec->codec_data;
 
     pj_assert(gsm_data != NULL);
     PJ_ASSERT_RETURN(input && output, PJ_EINVAL);
diff --git a/pjmedia/src/pjmedia-codec/ilbc.c b/pjmedia/src/pjmedia-codec/ilbc.c
index 32e03833..7819867f 100644
--- a/pjmedia/src/pjmedia-codec/ilbc.c
+++ b/pjmedia/src/pjmedia-codec/ilbc.c
@@ -319,7 +319,7 @@ static pj_status_t ilbc_alloc_codec(pjmedia_codec_factory *factory,
 				     2000, 2000);
     PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
 
-    codec = pj_pool_zalloc(pool, sizeof(struct ilbc_codec));
+    codec = PJ_POOL_ZALLOC_T(pool, struct ilbc_codec);
     codec->base.op = &ilbc_op;
     codec->base.factory = factory;
     codec->pool = pool;
@@ -530,7 +530,7 @@ static pj_status_t ilbc_codec_encode(pjmedia_codec *codec,
 					      &input->timestamp);
 
 	is_silence = pjmedia_silence_det_detect(ilbc_codec->vad, 
-					        input->buf,
+					        (const pj_int16_t*)input->buf,
 						(input->size >> 1),
 						NULL);
 	if (is_silence &&
@@ -585,7 +585,7 @@ static pj_status_t ilbc_codec_decode(pjmedia_codec *codec,
 	return PJMEDIA_CODEC_EFRMINLEN;
 
     /* Decode to temporary buffer */
-    iLBC_decode(ilbc_codec->dec_block, input->buf,
+    iLBC_decode(ilbc_codec->dec_block, (unsigned char*) input->buf,
 		&ilbc_codec->dec, 1);
 
     /* Convert decodec samples from float to short */
diff --git a/pjmedia/src/pjmedia-codec/l16.c b/pjmedia/src/pjmedia-codec/l16.c
index 629ea588..df456045 100644
--- a/pjmedia/src/pjmedia-codec/l16.c
+++ b/pjmedia/src/pjmedia-codec/l16.c
@@ -428,7 +428,7 @@ static pj_status_t l16_alloc_codec( pjmedia_codec_factory *factory,
     /* Allocate new codec if no more is available */
     if (pj_list_empty(&l16_factory.codec_list)) {
 
-	codec = pj_pool_alloc(l16_factory.pool, sizeof(pjmedia_codec));
+	codec = PJ_POOL_ALLOC_T(l16_factory.pool, pjmedia_codec);
 	codec->codec_data = pj_pool_alloc(l16_factory.pool, 
 					  sizeof(struct l16_data));
 	codec->factory = factory;
@@ -441,7 +441,7 @@ static pj_status_t l16_alloc_codec( pjmedia_codec_factory *factory,
 
     /* Init private data */
     ptime = GET_PTIME(id->clock_rate);
-    data = codec->codec_data;
+    data = (struct l16_data*) codec->codec_data;
     data->frame_size = ptime * id->clock_rate * id->channel_cnt * 2 / 1000;
 
     /* Zero the list, for error detection in l16_dealloc_codec */
diff --git a/pjmedia/src/pjmedia-codec/speex_codec.c b/pjmedia/src/pjmedia-codec/speex_codec.c
index e79dc90c..955377bc 100644
--- a/pjmedia/src/pjmedia-codec/speex_codec.c
+++ b/pjmedia/src/pjmedia-codec/speex_codec.c
@@ -481,8 +481,7 @@ static pj_status_t spx_alloc_codec( pjmedia_codec_factory *factory,
 	codec = spx_factory.codec_list.next;
 	pj_list_erase(codec);
     } else {
-	codec = pj_pool_zalloc(spx_factory.pool, 
-			       sizeof(pjmedia_codec));
+	codec = PJ_POOL_ZALLOC_T(spx_factory.pool, pjmedia_codec);
 	PJ_ASSERT_RETURN(codec != NULL, PJ_ENOMEM);
 	codec->op = &spx_op;
 	codec->factory = factory;
@@ -736,7 +735,8 @@ static pj_status_t spx_codec_encode( pjmedia_codec *codec,
     speex_bits_reset(&spx->enc_bits);
 
     /* Encode the frame */
-    tx = speex_encode_int(spx->enc, input->buf, &spx->enc_bits);
+    tx = speex_encode_int(spx->enc, (spx_int16_t*)input->buf, 
+			  &spx->enc_bits);
 
     /* Check if we need not to transmit the frame (DTX) */
     if (tx == 0) {
@@ -753,7 +753,7 @@ static pj_status_t spx_codec_encode( pjmedia_codec *codec,
 
     /* Copy the bits to an array of char that can be written */
     output->size = speex_bits_write(&spx->enc_bits, 
-				    output->buf, output_buf_len);
+				    (char*)output->buf, output_buf_len);
     output->type = PJMEDIA_FRAME_TYPE_AUDIO;
     output->timestamp = input->timestamp;
 
@@ -781,14 +781,14 @@ static pj_status_t spx_codec_decode( pjmedia_codec *codec,
     }
 
     /* Copy the data into the bit-stream struct */
-    speex_bits_read_from(&spx->dec_bits, input->buf, input->size);
+    speex_bits_read_from(&spx->dec_bits, (char*)input->buf, input->size);
 
     /* Decode the data */
-    speex_decode_int(spx->dec, &spx->dec_bits, output->buf);
+    speex_decode_int(spx->dec, &spx->dec_bits, (spx_int16_t*)output->buf);
 
     output->type = PJMEDIA_FRAME_TYPE_AUDIO;
     output->size = speex_bits_nbytes(&spx->dec_bits);
-    pj_assert(output->size <= (int)output_buf_len);
+    pj_assert(output->size <= (unsigned)output_buf_len);
     output->timestamp.u64 = input->timestamp.u64;
 
 
@@ -814,7 +814,7 @@ static pj_status_t  spx_codec_recover(pjmedia_codec *codec,
     pj_assert(count <= output_buf_len/2);
 
     /* Recover packet loss */
-    speex_decode_int(spx->dec, NULL, output->buf);
+    speex_decode_int(spx->dec, NULL, (spx_int16_t*) output->buf);
 
     output->size = count * 2;
 
diff --git a/pjmedia/src/pjmedia/clock_thread.c b/pjmedia/src/pjmedia/clock_thread.c
index b1064a81..6dd8a25f 100644
--- a/pjmedia/src/pjmedia/clock_thread.c
+++ b/pjmedia/src/pjmedia/clock_thread.c
@@ -66,7 +66,7 @@ PJ_DEF(pj_status_t) pjmedia_clock_create( pj_pool_t *pool,
     PJ_ASSERT_RETURN(pool && clock_rate && samples_per_frame && p_clock,
 		     PJ_EINVAL);
 
-    clock = pj_pool_alloc(pool, sizeof(pjmedia_clock));
+    clock = PJ_POOL_ALLOC_T(pool, pjmedia_clock);
 
     
     status = pj_get_timestamp_freq(&clock->freq);
@@ -197,7 +197,7 @@ PJ_DEF(pj_bool_t) pjmedia_clock_wait( pjmedia_clock *clock,
 static int clock_thread(void *arg)
 {
     pj_timestamp now;
-    pjmedia_clock *clock = arg;
+    pjmedia_clock *clock = (pjmedia_clock*) arg;
 
     /* Get the first tick */
     pj_get_timestamp(&clock->next_tick);
diff --git a/pjmedia/src/pjmedia/conference.c b/pjmedia/src/pjmedia/conference.c
index b3619d58..aa6b1faf 100644
--- a/pjmedia/src/pjmedia/conference.c
+++ b/pjmedia/src/pjmedia/conference.c
@@ -239,7 +239,7 @@ static pj_status_t create_conf_port( pj_pool_t *pool,
     pj_status_t status;
 
     /* Create port. */
-    conf_port = pj_pool_zalloc(pool, sizeof(struct conf_port));
+    conf_port = PJ_POOL_ZALLOC_T(pool, struct conf_port);
     PJ_ASSERT_RETURN(conf_port, PJ_ENOMEM);
 
     /* Set name */
@@ -254,7 +254,8 @@ static pj_status_t create_conf_port( pj_pool_t *pool,
     conf_port->rx_adj_level = NORMAL_LEVEL;
 
     /* Create transmit flag array */
-    conf_port->listener_slots = pj_pool_zalloc(pool, 
+    conf_port->listener_slots = (SLOT_TYPE*)
+				pj_pool_zalloc(pool, 
 					  conf->max_ports * sizeof(SLOT_TYPE));
     PJ_ASSERT_RETURN(conf_port->listener_slots, PJ_ENOMEM);
 
@@ -335,21 +336,24 @@ static pj_status_t create_conf_port( pj_pool_t *pool,
 					   conf_port->clock_rate * 1.0 /
 					   conf->clock_rate);
 	conf_port->rx_buf_count = 0;
-	conf_port->rx_buf = pj_pool_alloc(pool, conf_port->rx_buf_cap *
+	conf_port->rx_buf = (pj_int16_t*)
+			    pj_pool_alloc(pool, conf_port->rx_buf_cap *
 						sizeof(conf_port->rx_buf[0]));
 	PJ_ASSERT_RETURN(conf_port->rx_buf, PJ_ENOMEM);
 
 	/* Create TX buffer. */
 	conf_port->tx_buf_cap = conf_port->rx_buf_cap;
 	conf_port->tx_buf_count = 0;
-	conf_port->tx_buf = pj_pool_alloc(pool, conf_port->tx_buf_cap *
+	conf_port->tx_buf = (pj_int16_t*)
+			    pj_pool_alloc(pool, conf_port->tx_buf_cap *
 						sizeof(conf_port->tx_buf[0]));
 	PJ_ASSERT_RETURN(conf_port->tx_buf, PJ_ENOMEM);
     }
 
 
     /* Create mix buffer. */
-    conf_port->mix_buf = pj_pool_zalloc(pool, conf->samples_per_frame *
+    conf_port->mix_buf = (pj_uint32_t*)
+			 pj_pool_zalloc(pool, conf->samples_per_frame *
 					      sizeof(conf_port->mix_buf[0]));
     PJ_ASSERT_RETURN(conf_port->mix_buf, PJ_ENOMEM);
 
@@ -380,7 +384,8 @@ static pj_status_t create_pasv_port( pjmedia_conf *conf,
 
     /* Passive port has rx buffers. */
     for (i=0; i<RX_BUF_COUNT; ++i) {
-	conf_port->snd_buf[i] = pj_pool_zalloc(pool, conf->samples_per_frame *
+	conf_port->snd_buf[i] = (pj_int16_t*)
+				pj_pool_zalloc(pool, conf->samples_per_frame *
 					      sizeof(conf_port->snd_buf[0][0]));
 	if (conf_port->snd_buf[i] == NULL) {
 	    return PJ_ENOMEM;
@@ -486,10 +491,11 @@ PJ_DEF(pj_status_t) pjmedia_conf_create( pj_pool_t *pool,
 	      max_ports));
 
     /* Create and init conf structure. */
-    conf = pj_pool_zalloc(pool, sizeof(pjmedia_conf));
+    conf = PJ_POOL_ZALLOC_T(pool, pjmedia_conf);
     PJ_ASSERT_RETURN(conf, PJ_ENOMEM);
 
-    conf->ports = pj_pool_zalloc(pool, max_ports*sizeof(void*));
+    conf->ports = (struct conf_port**) 
+		  pj_pool_zalloc(pool, max_ports*sizeof(void*));
     PJ_ASSERT_RETURN(conf->ports, PJ_ENOMEM);
 
     conf->options = options;
@@ -501,7 +507,7 @@ PJ_DEF(pj_status_t) pjmedia_conf_create( pj_pool_t *pool,
 
     
     /* Create and initialize the master port interface. */
-    conf->master_port = pj_pool_zalloc(pool, sizeof(pjmedia_port));
+    conf->master_port = PJ_POOL_ZALLOC_T(pool, pjmedia_port);
     PJ_ASSERT_RETURN(conf->master_port, PJ_ENOMEM);
     
     pjmedia_port_info_init(&conf->master_port->info, &name, SIGNATURE,
@@ -522,7 +528,8 @@ PJ_DEF(pj_status_t) pjmedia_conf_create( pj_pool_t *pool,
 	return status;
 
     /* Create temporary buffer. */
-    conf->uns_buf = pj_pool_zalloc(pool, samples_per_frame *
+    conf->uns_buf = (pj_uint16_t*)
+		    pj_pool_zalloc(pool, samples_per_frame *
 					 sizeof(conf->uns_buf[0]));
 
     /* Create mutex. */
@@ -597,7 +604,7 @@ PJ_DEF(pj_status_t) pjmedia_conf_destroy( pjmedia_conf *conf )
  */
 static pj_status_t destroy_port(pjmedia_port *this_port)
 {
-    pjmedia_conf *conf = this_port->port_data.pdata;
+    pjmedia_conf *conf = (pjmedia_conf*) this_port->port_data.pdata;
     return pjmedia_conf_destroy(conf);
 }
 
@@ -625,7 +632,7 @@ PJ_DEF(pjmedia_port*) pjmedia_conf_get_master_port(pjmedia_conf *conf)
 PJ_DEF(pj_status_t) pjmedia_conf_set_port0_name(pjmedia_conf *conf,
 						const pj_str_t *name)
 {
-    int len;
+    unsigned len;
 
     /* Sanity check. */
     PJ_ASSERT_RETURN(conf != NULL && name != NULL, PJ_EINVAL);
@@ -763,12 +770,12 @@ PJ_DEF(pj_status_t) pjmedia_conf_add_passive_port( pjmedia_conf *conf,
     if (name == NULL) {
 	name = &tmp;
 
-	tmp.ptr = pj_pool_alloc(pool, 32);
+	tmp.ptr = (char*) pj_pool_alloc(pool, 32);
 	tmp.slen = pj_ansi_snprintf(tmp.ptr, 32, "ConfPort#%d", index);
     }
 
     /* Create and initialize the media port structure. */
-    port = pj_pool_zalloc(pool, sizeof(pjmedia_port));
+    port = PJ_POOL_ZALLOC_T(pool, pjmedia_port);
     PJ_ASSERT_RETURN(port, PJ_ENOMEM);
     
     pjmedia_port_info_init(&port->info, name, SIGNATURE_PORT,
@@ -1600,7 +1607,7 @@ static pj_status_t write_port(pjmedia_conf *conf, struct conf_port *cport,
 static pj_status_t get_frame(pjmedia_port *this_port, 
 			     pjmedia_frame *frame)
 {
-    pjmedia_conf *conf = this_port->port_data.pdata;
+    pjmedia_conf *conf = (pjmedia_conf*) this_port->port_data.pdata;
     pjmedia_frame_type speaker_frame_type = PJMEDIA_FRAME_TYPE_NONE;
     unsigned ci, cj, i, j;
     
@@ -1676,7 +1683,8 @@ static pj_status_t get_frame(pjmedia_port *this_port,
 	    }
 
 	    snd_buf = conf_port->snd_buf[conf_port->snd_read_pos];
-	    pjmedia_copy_samples(frame->buf, snd_buf, conf->samples_per_frame);
+	    pjmedia_copy_samples((pj_int16_t*)frame->buf, snd_buf, 
+				 conf->samples_per_frame);
 	    conf_port->snd_read_pos = (conf_port->snd_read_pos+1) % RX_BUF_COUNT;
 
 	} else {
@@ -1684,7 +1692,7 @@ static pj_status_t get_frame(pjmedia_port *this_port,
 	    pj_status_t status;
 	    pjmedia_frame_type frame_type;
 
-	    status = read_port(conf, conf_port, frame->buf, 
+	    status = read_port(conf, conf_port, (pj_int16_t*)frame->buf, 
 			       conf->samples_per_frame, &frame_type);
 	    
 	    if (status != PJ_SUCCESS) {
@@ -1710,7 +1718,7 @@ static pj_status_t get_frame(pjmedia_port *this_port,
 	 * Otherwise just calculate the averate level.
 	 */
 	if (conf_port->rx_adj_level != NORMAL_LEVEL) {
-	    pj_int16_t *input = frame->buf;
+	    pj_int16_t *input = (pj_int16_t*) frame->buf;
 	    pj_int32_t adj = conf_port->rx_adj_level;
 
 	    level = 0;
@@ -1738,7 +1746,7 @@ static pj_status_t get_frame(pjmedia_port *this_port,
 	    level /= conf->samples_per_frame;
 
 	} else {
-	    level = pjmedia_calc_avg_signal(frame->buf, 
+	    level = pjmedia_calc_avg_signal((pj_int16_t*) frame->buf, 
 					    conf->samples_per_frame);
 	}
 
@@ -1799,7 +1807,8 @@ static pj_status_t get_frame(pjmedia_port *this_port,
 	     */
 	    if (listener->transmitter_cnt == 1) {
 		pjmedia_copy_samples((pj_int16_t*)mix_buf, 
-				     frame->buf, conf->samples_per_frame);
+				     (const pj_int16_t*)frame->buf, 
+				     conf->samples_per_frame);
 		listener->src_level = level;
 	    } else {
 		for (k=0; k<conf->samples_per_frame; ++k)
@@ -1856,10 +1865,11 @@ static pj_status_t get_frame(pjmedia_port *this_port,
 	TRACE_((THIS_FILE, "write to audio, count=%d", 
 			   conf->samples_per_frame));
 
-	pjmedia_copy_samples( frame->buf, (pj_int16_t*)conf->ports[0]->mix_buf, 
+	pjmedia_copy_samples( (pj_int16_t*)frame->buf, 
+			      (const pj_int16_t*)conf->ports[0]->mix_buf, 
 			      conf->samples_per_frame);
     } else {
-	pjmedia_zero_samples( frame->buf, conf->samples_per_frame ); 
+	pjmedia_zero_samples((pj_int16_t*)frame->buf, conf->samples_per_frame); 
     }
 
     /* MUST set frame type */
@@ -1897,9 +1907,9 @@ static pj_status_t get_frame_pasv(pjmedia_port *this_port,
 static pj_status_t put_frame(pjmedia_port *this_port, 
 			     const pjmedia_frame *frame)
 {
-    pjmedia_conf *conf = this_port->port_data.pdata;
+    pjmedia_conf *conf = (pjmedia_conf*) this_port->port_data.pdata;
     struct conf_port *port = conf->ports[this_port->port_data.ldata];
-    const pj_int16_t *input = frame->buf;
+    const pj_int16_t *input = (const pj_int16_t*) frame->buf;
     pj_int16_t *target_snd_buf;
 
     /* Check for correct size. */
diff --git a/pjmedia/src/pjmedia/echo_common.c b/pjmedia/src/pjmedia/echo_common.c
index cccf5c91..5f392ef6 100644
--- a/pjmedia/src/pjmedia/echo_common.c
+++ b/pjmedia/src/pjmedia/echo_common.c
@@ -145,7 +145,7 @@ PJ_DEF(pj_status_t) pjmedia_echo_create( pj_pool_t *pool,
     options |= PJMEDIA_ECHO_SIMPLE;
 #endif
 
-    ec = pj_pool_zalloc(pool, sizeof(struct pjmedia_echo_state));
+    ec = PJ_POOL_ZALLOC_T(pool, struct pjmedia_echo_state);
 
     if (options & PJMEDIA_ECHO_SIMPLE) {
 	ec->op = &echo_supp_op;
diff --git a/pjmedia/src/pjmedia/echo_port.c b/pjmedia/src/pjmedia/echo_port.c
index 9f291411..e8895d2f 100644
--- a/pjmedia/src/pjmedia/echo_port.c
+++ b/pjmedia/src/pjmedia/echo_port.c
@@ -59,7 +59,7 @@ PJ_DEF(pj_status_t) pjmedia_echo_port_create(pj_pool_t *pool,
 		     PJ_EINVAL);
 
     /* Create the port and the AEC itself */
-    ec = pj_pool_zalloc(pool, sizeof(struct ec));
+    ec = PJ_POOL_ZALLOC_T(pool, struct ec);
     
     pjmedia_port_info_init(&ec->base.info, &AEC, SIGNATURE,
 			   dn_port->info.clock_rate, 
@@ -100,7 +100,7 @@ static pj_status_t ec_put_frame( pjmedia_port *this_port,
     PJ_ASSERT_RETURN(frame->size == this_port->info.samples_per_frame * 2,
 		     PJ_EINVAL);
 
-    pjmedia_echo_capture(ec->ec, frame->buf, 0);
+    pjmedia_echo_capture(ec->ec, (pj_int16_t*)frame->buf, 0);
 
     return pjmedia_port_put_frame(ec->dn_port, frame);
 }
@@ -116,10 +116,11 @@ static pj_status_t ec_get_frame( pjmedia_port *this_port,
 
     status = pjmedia_port_get_frame(ec->dn_port, frame);
     if (status!=PJ_SUCCESS || frame->type!=PJMEDIA_FRAME_TYPE_AUDIO) {
-	pjmedia_zero_samples(frame->buf, this_port->info.samples_per_frame);
+	pjmedia_zero_samples((pj_int16_t*)frame->buf, 
+			     this_port->info.samples_per_frame);
     }
 
-    pjmedia_echo_playback(ec->ec, frame->buf);
+    pjmedia_echo_playback(ec->ec, (pj_int16_t*)frame->buf);
 
     return status;
 }
diff --git a/pjmedia/src/pjmedia/echo_speex.c b/pjmedia/src/pjmedia/echo_speex.c
index 3eaa3243..daf19d42 100644
--- a/pjmedia/src/pjmedia/echo_speex.c
+++ b/pjmedia/src/pjmedia/echo_speex.c
@@ -77,7 +77,7 @@ PJ_DEF(pj_status_t) pjmedia_frame_queue_create( pj_pool_t *pool,
     pjmedia_frame_queue *fq;
     unsigned i;
 
-    fq = pj_pool_zalloc(pool, sizeof(pjmedia_frame_queue));
+    fq = PJ_POOL_ZALLOC_T(pool, pjmedia_frame_queue);
 
     pj_ansi_snprintf(fq->obj_name, sizeof(fq->obj_name), name, fq);
     fq->obj_name[sizeof(fq->obj_name)-1] = '\0';
@@ -93,7 +93,7 @@ PJ_DEF(pj_status_t) pjmedia_frame_queue_create( pj_pool_t *pool,
     for (i=0; i<max_count; ++i) {
 	struct fq_frame *f;
 
-	f = pj_pool_zalloc(pool, sizeof(struct fq_frame));
+	f = PJ_POOL_ZALLOC_T(pool, struct fq_frame);
 	f->buf = pj_pool_alloc(pool, frame_size);
 
 	pj_list_push_back(&fq->free_list, f);
@@ -294,7 +294,7 @@ PJ_DEF(pj_status_t) speex_aec_create(pj_pool_t *pool,
 
     *p_echo = NULL;
 
-    echo = pj_pool_zalloc(pool, sizeof(speex_ec));
+    echo = PJ_POOL_ZALLOC_T(pool, speex_ec);
     PJ_ASSERT_RETURN(echo != NULL, PJ_ENOMEM);
 
     if (options & PJMEDIA_ECHO_NO_LOCK) {
@@ -355,11 +355,12 @@ PJ_DEF(pj_status_t) speex_aec_create(pj_pool_t *pool,
 
 
     /* Create temporary frame for echo cancellation */
-    echo->tmp_frame = pj_pool_zalloc(pool, 2 * samples_per_frame);
+    echo->tmp_frame = (pj_int16_t*) pj_pool_zalloc(pool, 2 * samples_per_frame);
     PJ_ASSERT_RETURN(echo->tmp_frame != NULL, PJ_ENOMEM);
 
     /* Create temporary frame to receive residue */
-    echo->residue = pj_pool_zalloc(pool, sizeof(spx_int32_t) * 
+    echo->residue = (spx_int32_t*)
+		    pj_pool_zalloc(pool, sizeof(spx_int32_t) * 
 					    (samples_per_frame+1));
     PJ_ASSERT_RETURN(echo->residue != NULL, PJ_ENOMEM);
 
@@ -391,7 +392,7 @@ PJ_DEF(pj_status_t) speex_aec_create(pj_pool_t *pool,
  */
 PJ_DEF(pj_status_t) speex_aec_destroy(void *state )
 {
-    speex_ec *echo = state;
+    speex_ec *echo = (speex_ec*) state;
 
     PJ_ASSERT_RETURN(echo && echo->state, PJ_EINVAL);
 
@@ -423,7 +424,7 @@ PJ_DEF(pj_status_t) speex_aec_destroy(void *state )
 PJ_DEF(pj_status_t) speex_aec_playback(void *state,
 				       pj_int16_t *play_frm )
 {
-    speex_ec *echo = state;
+    speex_ec *echo = (speex_ec*) state;
 
     /* Sanity checks */
     PJ_ASSERT_RETURN(echo && play_frm, PJ_EINVAL);
@@ -481,7 +482,7 @@ PJ_DEF(pj_status_t) speex_aec_capture( void *state,
 				       pj_int16_t *rec_frm,
 				       unsigned options )
 {
-    speex_ec *echo = state;
+    speex_ec *echo = (speex_ec*) state;
     pj_status_t status = PJ_SUCCESS;
 
     /* Sanity checks */
@@ -551,7 +552,7 @@ PJ_DEF(pj_status_t) speex_aec_cancel_echo( void *state,
 					   unsigned options,
 					   void *reserved )
 {
-    speex_ec *echo = state;
+    speex_ec *echo = (speex_ec*) state;
 
     /* Sanity checks */
     PJ_ASSERT_RETURN(echo && rec_frm && play_frm && options==0 &&
diff --git a/pjmedia/src/pjmedia/echo_suppress.c b/pjmedia/src/pjmedia/echo_suppress.c
index e2991618..93a3cba2 100644
--- a/pjmedia/src/pjmedia/echo_suppress.c
+++ b/pjmedia/src/pjmedia/echo_suppress.c
@@ -85,7 +85,7 @@ PJ_DEF(pj_status_t) echo_supp_create( pj_pool_t *pool,
     PJ_UNUSED_ARG(options);
     PJ_UNUSED_ARG(latency_ms);
 
-    ec = pj_pool_zalloc(pool, sizeof(struct echo_supp));
+    ec = PJ_POOL_ZALLOC_T(pool, struct echo_supp);
     ec->samples_per_frame = samples_per_frame;
     ec->tail_ms = tail_ms;
 
@@ -119,7 +119,7 @@ PJ_DEF(pj_status_t) echo_supp_destroy(void *state)
 PJ_DEF(pj_status_t) echo_supp_playback( void *state,
 					pj_int16_t *play_frm )
 {
-    echo_supp *ec = state;
+    echo_supp *ec = (echo_supp*) state;
     pj_bool_t silence;
     pj_bool_t last_suppressing = ec->suppressing;
 
@@ -149,7 +149,7 @@ PJ_DEF(pj_status_t) echo_supp_capture( void *state,
 				       pj_int16_t *rec_frm,
 				       unsigned options )
 {
-    echo_supp *ec = state;
+    echo_supp *ec = (echo_supp*) state;
     pj_time_val now;
     unsigned delay_ms;
 
@@ -185,7 +185,7 @@ PJ_DEF(pj_status_t) echo_supp_cancel_echo( void *state,
 					   unsigned options,
 					   void *reserved )
 {
-    echo_supp *ec = state;
+    echo_supp *ec = (echo_supp*) state;
     pj_bool_t silence;
 
     PJ_UNUSED_ARG(options);
diff --git a/pjmedia/src/pjmedia/endpoint.c b/pjmedia/src/pjmedia/endpoint.c
index 65c6128f..ea93e877 100644
--- a/pjmedia/src/pjmedia/endpoint.c
+++ b/pjmedia/src/pjmedia/endpoint.c
@@ -126,7 +126,7 @@ PJ_DEF(pj_status_t) pjmedia_endpt_create(pj_pool_factory *pf,
     if (!pool)
 	return PJ_ENOMEM;
 
-    endpt = pj_pool_zalloc(pool, sizeof(struct pjmedia_endpt));
+    endpt = PJ_POOL_ZALLOC_T(pool, struct pjmedia_endpt);
     endpt->pool = pool;
     endpt->pf = pf;
     endpt->ioqueue = ioqueue;
@@ -246,7 +246,7 @@ PJ_DEF(pj_ioqueue_t*) pjmedia_endpt_get_ioqueue(pjmedia_endpt *endpt)
  */
 static int PJ_THREAD_FUNC worker_proc(void *arg)
 {
-    pjmedia_endpt *endpt = arg;
+    pjmedia_endpt *endpt = (pjmedia_endpt*) arg;
 
     while (!endpt->quit_flag) {
 	pj_time_val timeout = { 0, 500 };
@@ -293,7 +293,7 @@ PJ_DEF(pj_status_t) pjmedia_endpt_create_sdp( pjmedia_endpt *endpt,
 		     PJ_ETOOMANY);
 
     /* Create and initialize basic SDP session */
-    sdp = pj_pool_zalloc (pool, sizeof(pjmedia_sdp_session));
+    sdp = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_session);
 
     pj_gettimeofday(&tv);
     sdp->origin.user = pj_str("-");
@@ -307,7 +307,7 @@ PJ_DEF(pj_status_t) pjmedia_endpt_create_sdp( pjmedia_endpt *endpt,
     /* Since we only support one media stream at present, put the
      * SDP connection line in the session level.
      */
-    sdp->conn = pj_pool_zalloc (pool, sizeof(pjmedia_sdp_conn));
+    sdp->conn = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_conn);
     sdp->conn->net_type = STR_IN;
     sdp->conn->addr_type = STR_IP4;
     pj_strdup2(pool, &sdp->conn->addr, 
@@ -321,7 +321,7 @@ PJ_DEF(pj_status_t) pjmedia_endpt_create_sdp( pjmedia_endpt *endpt,
     /* Create media stream 0: */
 
     sdp->media_count = 1;
-    m = pj_pool_zalloc (pool, sizeof(pjmedia_sdp_media));
+    m = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_media);
     sdp->media[0] = m;
 
     /* Standard media info: */
@@ -337,9 +337,9 @@ PJ_DEF(pj_status_t) pjmedia_endpt_create_sdp( pjmedia_endpt *endpt,
     /* Add "rtcp" attribute */
 #if defined(PJMEDIA_HAS_RTCP_IN_SDP) && PJMEDIA_HAS_RTCP_IN_SDP!=0
     if (sock_info->rtcp_addr_name.sin_family != 0) {
-	attr = pj_pool_alloc(pool, sizeof(pjmedia_sdp_attr));
+	attr = PJ_POOL_ALLOC_T(pool, pjmedia_sdp_attr);
 	attr->name = pj_str("rtcp");
-	attr->value.ptr = pj_pool_alloc(pool, 80);
+	attr->value.ptr = (char*) pj_pool_alloc(pool, 80);
 	attr->value.slen = 
 	    pj_ansi_snprintf(attr->value.ptr, 80,
 			    "%u IN IP4 %s",
@@ -367,7 +367,7 @@ PJ_DEF(pj_status_t) pjmedia_endpt_create_sdp( pjmedia_endpt *endpt,
 					    &codec_param);
 	fmt = &m->desc.fmt[m->desc.fmt_count++];
 
-	fmt->ptr = pj_pool_alloc(pool, 8);
+	fmt->ptr = (char*) pj_pool_alloc(pool, 8);
 	fmt->slen = pj_utoa(codec_info->pt, fmt->ptr);
 
 	rtpmap.pt = *fmt;
@@ -399,10 +399,10 @@ PJ_DEF(pj_status_t) pjmedia_endpt_create_sdp( pjmedia_endpt *endpt,
 	/* Add fmtp mode where applicable */
 	if (codec_param.setting.dec_fmtp_mode != 0) {
 	    const pj_str_t fmtp = { "fmtp", 4 };
-	    attr = pj_pool_zalloc(pool, sizeof(pjmedia_sdp_attr));
+	    attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr);
 
 	    attr->name = fmtp;
-	    attr->value.ptr = pj_pool_alloc(pool, 32);
+	    attr->value.ptr = (char*) pj_pool_alloc(pool, 32);
 	    attr->value.slen = 
 		pj_ansi_snprintf( attr->value.ptr, 32,
 				  "%d mode=%d",
@@ -413,7 +413,7 @@ PJ_DEF(pj_status_t) pjmedia_endpt_create_sdp( pjmedia_endpt *endpt,
     }
 
     /* Add sendrecv attribute. */
-    attr = pj_pool_zalloc(pool, sizeof(pjmedia_sdp_attr));
+    attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr);
     attr->name = STR_SENDRECV;
     m->attr[m->attr_count++] = attr;
 
@@ -427,14 +427,14 @@ PJ_DEF(pj_status_t) pjmedia_endpt_create_sdp( pjmedia_endpt *endpt,
 	pj_str(PJMEDIA_RTP_PT_TELEPHONE_EVENTS_STR);
 
     /* Add rtpmap. */
-    attr = pj_pool_zalloc(pool, sizeof(pjmedia_sdp_attr));
+    attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr);
     attr->name = pj_str("rtpmap");
     attr->value = pj_str(PJMEDIA_RTP_PT_TELEPHONE_EVENTS_STR 
 			 " telephone-event/8000");
     m->attr[m->attr_count++] = attr;
 
     /* Add fmtp */
-    attr = pj_pool_zalloc(pool, sizeof(pjmedia_sdp_attr));
+    attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr);
     attr->name = pj_str("fmtp");
     attr->value = pj_str(PJMEDIA_RTP_PT_TELEPHONE_EVENTS_STR " 0-15");
     m->attr[m->attr_count++] = attr;
diff --git a/pjmedia/src/pjmedia/g711.c b/pjmedia/src/pjmedia/g711.c
index 0a8def01..b2c08199 100644
--- a/pjmedia/src/pjmedia/g711.c
+++ b/pjmedia/src/pjmedia/g711.c
@@ -319,9 +319,8 @@ static pj_status_t g711_alloc_codec( pjmedia_codec_factory *factory,
     if (pj_list_empty(&g711_factory.codec_list)) {
 	struct g711_private *codec_priv;
 
-	codec = pj_pool_alloc(g711_factory.pool, sizeof(pjmedia_codec));
-	codec_priv = pj_pool_zalloc(g711_factory.pool, 
-				    sizeof(struct g711_private));
+	codec = PJ_POOL_ALLOC_T(g711_factory.pool, pjmedia_codec);
+	codec_priv = PJ_POOL_ZALLOC_T(g711_factory.pool, struct g711_private);
 	if (!codec || !codec_priv) {
 	    pj_mutex_unlock(g711_factory.mutex);
 	    return PJ_ENOMEM;
@@ -371,7 +370,7 @@ static pj_status_t g711_alloc_codec( pjmedia_codec_factory *factory,
 static pj_status_t g711_dealloc_codec(pjmedia_codec_factory *factory, 
 				      pjmedia_codec *codec )
 {
-    struct g711_private *priv = codec->codec_data;
+    struct g711_private *priv = (struct g711_private*) codec->codec_data;
     int i = 0;
 
     PJ_ASSERT_RETURN(factory==&g711_factory.base, PJ_EINVAL);
@@ -420,7 +419,7 @@ static pj_status_t g711_init( pjmedia_codec *codec, pj_pool_t *pool )
 static pj_status_t g711_open(pjmedia_codec *codec, 
 			     pjmedia_codec_param *attr )
 {
-    struct g711_private *priv = codec->codec_data;
+    struct g711_private *priv = (struct g711_private*) codec->codec_data;
     priv->pt = attr->info.pt;
 #if !PLC_DISABLED
     priv->plc_enabled = (attr->setting.plc != 0);
@@ -439,7 +438,7 @@ static pj_status_t g711_close( pjmedia_codec *codec )
 static pj_status_t  g711_modify(pjmedia_codec *codec, 
 			        const pjmedia_codec_param *attr )
 {
-    struct g711_private *priv = codec->codec_data;
+    struct g711_private *priv = (struct g711_private*) codec->codec_data;
 
     if (attr->info.pt != priv->pt)
 	return PJMEDIA_EINVALIDPT;
@@ -487,7 +486,7 @@ static pj_status_t  g711_encode(pjmedia_codec *codec,
 				struct pjmedia_frame *output)
 {
     pj_int16_t *samples = (pj_int16_t*) input->buf;
-    struct g711_private *priv = codec->codec_data;
+    struct g711_private *priv = (struct g711_private*) codec->codec_data;
 
     /* Check output buffer length */
     if (output_buf_len < (input->size >> 1))
@@ -501,7 +500,8 @@ static pj_status_t  g711_encode(pjmedia_codec *codec,
 	silence_period = pj_timestamp_diff32(&priv->last_tx,
 					     &input->timestamp);
 
-	is_silence = pjmedia_silence_det_detect(priv->vad, input->buf, 
+	is_silence = pjmedia_silence_det_detect(priv->vad, 
+						(const pj_int16_t*) input->buf, 
 						(input->size >> 1), NULL);
 	if (is_silence && 
 	    PJMEDIA_CODEC_MAX_SILENCE_PERIOD != -1 &&
@@ -520,7 +520,7 @@ static pj_status_t  g711_encode(pjmedia_codec *codec,
     /* Encode */
     if (priv->pt == PJMEDIA_RTP_PT_PCMA) {
 	unsigned i, n;
-	pj_uint8_t *dst = output->buf;
+	pj_uint8_t *dst = (pj_uint8_t*) output->buf;
 
 	n = (input->size >> 1);
 	for (i=0; i!=n; ++i, ++dst) {
@@ -528,7 +528,7 @@ static pj_status_t  g711_encode(pjmedia_codec *codec,
 	}
     } else if (priv->pt == PJMEDIA_RTP_PT_PCMU) {
 	unsigned i, n;
-	pj_uint8_t *dst = output->buf;
+	pj_uint8_t *dst = (pj_uint8_t*) output->buf;
 
 	n = (input->size >> 1);
 	for (i=0; i!=n; ++i, ++dst) {
@@ -550,7 +550,7 @@ static pj_status_t  g711_decode(pjmedia_codec *codec,
 				unsigned output_buf_len, 
 				struct pjmedia_frame *output)
 {
-    struct g711_private *priv = codec->codec_data;
+    struct g711_private *priv = (struct g711_private*) codec->codec_data;
 
     /* Check output buffer length */
     PJ_ASSERT_RETURN(output_buf_len >= (input->size << 1),
@@ -563,16 +563,16 @@ static pj_status_t  g711_decode(pjmedia_codec *codec,
     /* Decode */
     if (priv->pt == PJMEDIA_RTP_PT_PCMA) {
 	unsigned i;
-	pj_uint8_t *src = input->buf;
-	pj_uint16_t *dst = output->buf;
+	pj_uint8_t *src = (pj_uint8_t*) input->buf;
+	pj_uint16_t *dst = (pj_uint16_t*) output->buf;
 
 	for (i=0; i!=input->size; ++i) {
 	    *dst++ = (pj_uint16_t) pjmedia_alaw2linear(*src++);
 	}
     } else if (priv->pt == PJMEDIA_RTP_PT_PCMU) {
 	unsigned i;
-	pj_uint8_t *src = input->buf;
-	pj_uint16_t *dst = output->buf;
+	pj_uint8_t *src = (pj_uint8_t*) input->buf;
+	pj_uint16_t *dst = (pj_uint16_t*) output->buf;
 
 	for (i=0; i!=input->size; ++i) {
 	    *dst++ = (pj_uint16_t) pjmedia_ulaw2linear(*src++);
diff --git a/pjmedia/src/pjmedia/jbuf.c b/pjmedia/src/pjmedia/jbuf.c
index 5a52b130..7d840a9f 100644
--- a/pjmedia/src/pjmedia/jbuf.c
+++ b/pjmedia/src/pjmedia/jbuf.c
@@ -30,7 +30,7 @@
 #define THIS_FILE   "jbuf.c"
 
 
-struct jb_framelist
+typedef struct jb_framelist_t
 {
     char	*flist_buffer;
     int		*flist_frame_type;
@@ -40,15 +40,13 @@ struct jb_framelist
     unsigned	 flist_head;
     unsigned	 flist_tail;
     unsigned	 flist_origin;
-};
-
+} jb_framelist_t;
 
-typedef struct jb_framelist jb_framelist;
 
 struct pjmedia_jbuf
 {
     pj_str_t	    name;		  // jitter buffer name
-    jb_framelist    jb_framelist;
+    jb_framelist_t  jb_framelist;
     pj_size_t	    jb_frame_size;	  // frame size	
     unsigned	    jb_frame_ptime;	  // frame duration.
     pj_size_t	    jb_max_count;	  // max frames in the jitter framelist->flist_buffer
@@ -92,21 +90,22 @@ struct pjmedia_jbuf
 
 
 static pj_status_t jb_framelist_init( pj_pool_t *pool,
-				      jb_framelist *framelist,
+				      jb_framelist_t *framelist,
 				      unsigned frame_size,
 				      unsigned max_count) 
 {
     PJ_ASSERT_RETURN(pool && framelist, PJ_EINVAL);
 
-    pj_bzero(framelist, sizeof(jb_framelist));
+    pj_bzero(framelist, sizeof(jb_framelist_t));
 
     framelist->flist_frame_size = frame_size;
     framelist->flist_max_count = max_count;
-    framelist->flist_buffer = pj_pool_zalloc(pool,
+    framelist->flist_buffer = (char*) 
+			      pj_pool_zalloc(pool,
 					     framelist->flist_frame_size * 
 					     framelist->flist_max_count);
 
-    framelist->flist_frame_type = 
+    framelist->flist_frame_type = (int*)
 	pj_pool_zalloc(pool, sizeof(framelist->flist_frame_type[0]) * 
 				framelist->flist_max_count);
 
@@ -116,14 +115,14 @@ static pj_status_t jb_framelist_init( pj_pool_t *pool,
 
 }
 
-static pj_status_t jb_framelist_destroy(jb_framelist *framelist) 
+static pj_status_t jb_framelist_destroy(jb_framelist_t *framelist) 
 {
     PJ_UNUSED_ARG(framelist);
     return PJ_SUCCESS;
 }
 
 
-static unsigned jb_framelist_size(jb_framelist *framelist) 
+static unsigned jb_framelist_size(jb_framelist_t *framelist) 
 {
     if (framelist->flist_tail == framelist->flist_head) {
 	return framelist->flist_empty ? 0 : framelist->flist_max_count;
@@ -134,7 +133,7 @@ static unsigned jb_framelist_size(jb_framelist *framelist)
 }
 
 
-static pj_bool_t jb_framelist_get(jb_framelist *framelist,
+static pj_bool_t jb_framelist_get(jb_framelist_t *framelist,
 				  void *frame,
 				  pjmedia_jb_frame_type *p_type) 
 {
@@ -167,7 +166,7 @@ static pj_bool_t jb_framelist_get(jb_framelist *framelist,
 }
 
 
-static void jb_framelist_remove_head( jb_framelist *framelist,
+static void jb_framelist_remove_head( jb_framelist_t *framelist,
 				      unsigned count) 
 {
     unsigned cur_size;
@@ -214,7 +213,7 @@ static void jb_framelist_remove_head( jb_framelist *framelist,
 }
 
 
-static pj_bool_t jb_framelist_put_at(jb_framelist *framelist,
+static pj_bool_t jb_framelist_put_at(jb_framelist_t *framelist,
 				     unsigned index,
 				     const void *frame,
 				     unsigned frame_size) 
@@ -282,7 +281,7 @@ PJ_DEF(pj_status_t) pjmedia_jbuf_create(pj_pool_t *pool,
     pjmedia_jbuf *jb;
     pj_status_t status;
 
-    jb = pj_pool_zalloc(pool, sizeof(pjmedia_jbuf));
+    jb = PJ_POOL_ZALLOC_T(pool, pjmedia_jbuf);
 
     status = jb_framelist_init(pool, &jb->jb_framelist, frame_size, max_count);
     if (status != PJ_SUCCESS)
diff --git a/pjmedia/src/pjmedia/master_port.c b/pjmedia/src/pjmedia/master_port.c
index ffab40e9..85099a48 100644
--- a/pjmedia/src/pjmedia/master_port.c
+++ b/pjmedia/src/pjmedia/master_port.c
@@ -84,7 +84,7 @@ PJ_DEF(pj_status_t) pjmedia_master_port_create( pj_pool_t *pool,
 
 
     /* Create the master port instance */
-    m = pj_pool_zalloc(pool, sizeof(pjmedia_master_port));
+    m = PJ_POOL_ZALLOC_T(pool, pjmedia_master_port);
     m->options = options;
     m->u_port = u_port;
     m->d_port = d_port;
@@ -144,7 +144,7 @@ PJ_DEF(pj_status_t) pjmedia_master_port_stop(pjmedia_master_port *m)
  */
 static void clock_callback(const pj_timestamp *ts, void *user_data)
 {
-    pjmedia_master_port *m = user_data;
+    pjmedia_master_port *m = (pjmedia_master_port*) user_data;
     pjmedia_frame frame;
     pj_status_t status;
 
diff --git a/pjmedia/src/pjmedia/mem_capture.c b/pjmedia/src/pjmedia/mem_capture.c
index d5e7481f..074f377f 100644
--- a/pjmedia/src/pjmedia/mem_capture.c
+++ b/pjmedia/src/pjmedia/mem_capture.c
@@ -73,7 +73,7 @@ PJ_DECL(pj_status_t) pjmedia_mem_capture_create(pj_pool_t *pool,
     PJ_ASSERT_RETURN(bits_per_sample == 16, PJ_EINVAL);
 
 
-    rec = pj_pool_zalloc(pool, sizeof(struct mem_rec));
+    rec = PJ_POOL_ZALLOC_T(pool, struct mem_rec);
     PJ_ASSERT_RETURN(rec != NULL, PJ_ENOMEM);
 
     /* Create the rec */
diff --git a/pjmedia/src/pjmedia/mem_player.c b/pjmedia/src/pjmedia/mem_player.c
index a0842a47..95add9a5 100644
--- a/pjmedia/src/pjmedia/mem_player.c
+++ b/pjmedia/src/pjmedia/mem_player.c
@@ -75,7 +75,7 @@ PJ_DEF(pj_status_t) pjmedia_mem_player_create( pj_pool_t *pool,
     PJ_ASSERT_RETURN(bits_per_sample == 16, PJ_EINVAL);
 
 
-    port = pj_pool_zalloc(pool, sizeof(struct mem_player));
+    port = PJ_POOL_ZALLOC_T(pool, struct mem_player);
     PJ_ASSERT_RETURN(port != NULL, PJ_ENOMEM);
 
     /* Create the port */
diff --git a/pjmedia/src/pjmedia/null_port.c b/pjmedia/src/pjmedia/null_port.c
index 16258f94..29ca26f5 100644
--- a/pjmedia/src/pjmedia/null_port.c
+++ b/pjmedia/src/pjmedia/null_port.c
@@ -44,7 +44,7 @@ PJ_DEF(pj_status_t) pjmedia_null_port_create( pj_pool_t *pool,
 
     PJ_ASSERT_RETURN(pool && p_port, PJ_EINVAL);
 
-    port = pj_pool_zalloc(pool, sizeof(pjmedia_port));
+    port = PJ_POOL_ZALLOC_T(pool, pjmedia_port);
     PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
 
     pjmedia_port_info_init(&port->info, &name, SIGNATURE, sampling_rate,
@@ -83,7 +83,8 @@ static pj_status_t null_get_frame(pjmedia_port *this_port,
     frame->type = PJMEDIA_FRAME_TYPE_AUDIO;
     frame->size = this_port->info.samples_per_frame * 2;
     frame->timestamp.u32.lo += this_port->info.samples_per_frame;
-    pjmedia_zero_samples(frame->buf, this_port->info.samples_per_frame);
+    pjmedia_zero_samples((pj_int16_t*)frame->buf, 
+			 this_port->info.samples_per_frame);
 
     return PJ_SUCCESS;
 }
diff --git a/pjmedia/src/pjmedia/pasound.c b/pjmedia/src/pjmedia/pasound.c
index 27887494..a2ec6276 100644
--- a/pjmedia/src/pjmedia/pasound.c
+++ b/pjmedia/src/pjmedia/pasound.c
@@ -84,7 +84,7 @@ static int PaRecorderCallback(const void *input,
 			      PaStreamCallbackFlags statusFlags,
 			      void *userData )
 {
-    pjmedia_snd_stream *stream = userData;
+    pjmedia_snd_stream *stream = (pjmedia_snd_stream*) userData;
     pj_status_t status;
 
     PJ_UNUSED_ARG(output);
@@ -130,7 +130,7 @@ static int PaPlayerCallback( const void *input,
 			     PaStreamCallbackFlags statusFlags,
 			     void *userData )
 {
-    pjmedia_snd_stream *stream = userData;
+    pjmedia_snd_stream *stream = (pjmedia_snd_stream*) userData;
     pj_status_t status;
     unsigned size = frameCount * stream->bytes_per_sample *
 		    stream->channel_count;
@@ -388,7 +388,7 @@ PJ_DEF(pj_status_t) pjmedia_snd_open_rec( int index,
     if (!pool)
 	return PJ_ENOMEM;
 
-    stream = pj_pool_zalloc(pool, sizeof(*stream));
+    stream = PJ_POOL_ZALLOC_T(pool, pjmedia_snd_stream);
     stream->pool = pool;
     pj_strdup2_with_null(pool, &stream->name, paDevInfo->name);
     stream->dir = PJMEDIA_DIR_CAPTURE;
@@ -484,7 +484,7 @@ PJ_DEF(pj_status_t) pjmedia_snd_open_player( int index,
     if (!pool)
 	return PJ_ENOMEM;
 
-    stream = pj_pool_calloc(pool, 1, sizeof(*stream));
+    stream = PJ_POOL_ZALLOC_T(pool, pjmedia_snd_stream);
     stream->pool = pool;
     pj_strdup2_with_null(pool, &stream->name, paDevInfo->name);
     stream->dir = stream->dir = PJMEDIA_DIR_PLAYBACK;
@@ -604,7 +604,7 @@ PJ_DEF(pj_status_t) pjmedia_snd_open( int rec_id,
     if (!pool)
 	return PJ_ENOMEM;
 
-    stream = pj_pool_zalloc(pool, sizeof(*stream));
+    stream = PJ_POOL_ZALLOC_T(pool, pjmedia_snd_stream);
     stream->pool = pool;
     pj_strdup2_with_null(pool, &stream->name, paRecDevInfo->name);
     stream->dir = PJMEDIA_DIR_CAPTURE_PLAYBACK;
diff --git a/pjmedia/src/pjmedia/plc_common.c b/pjmedia/src/pjmedia/plc_common.c
index 04ed88cb..764ad0af 100644
--- a/pjmedia/src/pjmedia/plc_common.c
+++ b/pjmedia/src/pjmedia/plc_common.c
@@ -86,7 +86,7 @@ PJ_DEF(pj_status_t) pjmedia_plc_create( pj_pool_t *pool,
 
     PJ_UNUSED_ARG(options);
 
-    plc = pj_pool_zalloc(pool, sizeof(pjmedia_plc));
+    plc = PJ_POOL_ZALLOC_T(pool, pjmedia_plc);
 
     if (0)
 	;
@@ -150,17 +150,17 @@ static void* plc_replay_create(pj_pool_t *pool, unsigned clock_rate,
 
     PJ_UNUSED_ARG(clock_rate);
 
-    o = pj_pool_alloc(pool, sizeof(struct replay_plc));
+    o = PJ_POOL_ALLOC_T(pool, struct replay_plc);
     o->size = samples_per_frame * 2;
     o->replay_cnt = 0;
-    o->frame = pj_pool_zalloc(pool, o->size);
+    o->frame = (pj_int16_t*) pj_pool_zalloc(pool, o->size);
 
     return o;
 }
 
 static void plc_replay_save(void *plc, pj_int16_t *frame)
 {
-    struct replay_plc *o = plc;
+    struct replay_plc *o = (struct replay_plc*) plc;
 
     pj_memcpy(o->frame, frame, o->size);
     o->replay_cnt = 0;
@@ -168,7 +168,7 @@ static void plc_replay_save(void *plc, pj_int16_t *frame)
 
 static void plc_replay_generate(void *plc, pj_int16_t *frame)
 {
-    struct replay_plc *o = plc;
+    struct replay_plc *o = (struct replay_plc*) plc;
     unsigned i, count;
     pj_int16_t *samp;
 
diff --git a/pjmedia/src/pjmedia/resample_port.c b/pjmedia/src/pjmedia/resample_port.c
index 913f150c..8898d6c8 100644
--- a/pjmedia/src/pjmedia/resample_port.c
+++ b/pjmedia/src/pjmedia/resample_port.c
@@ -69,7 +69,7 @@ PJ_DEF(pj_status_t) pjmedia_resample_port_create( pj_pool_t *pool,
 	    dn_port->info.clock_rate;
     
     /* Create and initialize port. */
-    rport = pj_pool_zalloc(pool, sizeof(struct resample_port));
+    rport = PJ_POOL_ZALLOC_T(pool, struct resample_port);
     PJ_ASSERT_RETURN(rport != NULL, PJ_ENOMEM);
 
     pjmedia_port_info_init(&rport->base.info, &name, SIGNATURE, clock_rate,
@@ -84,10 +84,12 @@ PJ_DEF(pj_status_t) pjmedia_resample_port_create( pj_pool_t *pool,
      * We need separate buffer for get_frame() and put_frame() since
      * both functions may run simultaneously.
      */
-    rport->get_buf = pj_pool_alloc(pool, dn_port->info.bytes_per_frame);
+    rport->get_buf = (pj_int16_t*)
+		     pj_pool_alloc(pool, dn_port->info.bytes_per_frame);
     PJ_ASSERT_RETURN(rport->get_buf != NULL, PJ_ENOMEM);
 
-    rport->put_buf = pj_pool_alloc(pool, dn_port->info.bytes_per_frame);
+    rport->put_buf = (pj_int16_t*)
+		     pj_pool_alloc(pool, dn_port->info.bytes_per_frame);
     PJ_ASSERT_RETURN(rport->put_buf != NULL, PJ_ENOMEM);
 
 
@@ -139,7 +141,8 @@ static pj_status_t resample_put_frame(pjmedia_port *this_port,
     }
 
     if (frame->type == PJMEDIA_FRAME_TYPE_AUDIO) {
-	pjmedia_resample_run( rport->resample_put, frame->buf, 
+	pjmedia_resample_run( rport->resample_put, 
+			      (const pj_int16_t*) frame->buf, 
 			      rport->put_buf);
 
 	downstream_frame.buf = rport->put_buf;
@@ -188,7 +191,9 @@ static pj_status_t resample_get_frame(pjmedia_port *this_port,
 	return PJ_SUCCESS;
     }
 
-    pjmedia_resample_run( rport->resample_get, tmp_frame.buf, frame->buf);
+    pjmedia_resample_run( rport->resample_get, 
+			  (const pj_int16_t*) tmp_frame.buf, 
+			  (pj_int16_t*) frame->buf);
 
     frame->size = rport->base.info.bytes_per_frame;
     frame->type = PJMEDIA_FRAME_TYPE_AUDIO;
diff --git a/pjmedia/src/pjmedia/resample_resample.c b/pjmedia/src/pjmedia/resample_resample.c
index 9caaa31b..e013748f 100644
--- a/pjmedia/src/pjmedia/resample_resample.c
+++ b/pjmedia/src/pjmedia/resample_resample.c
@@ -58,7 +58,7 @@ PJ_DEF(pj_status_t) pjmedia_resample_create( pj_pool_t *pool,
     PJ_ASSERT_RETURN(pool && p_resample && rate_in &&
 		     rate_out && samples_per_frame, PJ_EINVAL);
 
-    resample = pj_pool_alloc(pool, sizeof(pjmedia_resample));
+    resample = PJ_POOL_ALLOC_T(pool, pjmedia_resample);
     PJ_ASSERT_RETURN(resample, PJ_ENOMEM);
 
     PJ_UNUSED_ARG(channel_count);
@@ -88,7 +88,7 @@ PJ_DEF(pj_status_t) pjmedia_resample_create( pj_pool_t *pool,
 	resample->xoff = res_GetXOFF(resample->factor, (char)large_filter);
 
 	size = (samples_per_frame + 2*resample->xoff) * sizeof(pj_int16_t);
-	resample->buffer = pj_pool_alloc(pool, size);
+	resample->buffer = (pj_int16_t*) pj_pool_alloc(pool, size);
 	PJ_ASSERT_RETURN(resample->buffer, PJ_ENOMEM);
 
 	pjmedia_zero_samples(resample->buffer, resample->xoff*2);
diff --git a/pjmedia/src/pjmedia/rtcp.c b/pjmedia/src/pjmedia/rtcp.c
index 0223e347..0c48b3f6 100644
--- a/pjmedia/src/pjmedia/rtcp.c
+++ b/pjmedia/src/pjmedia/rtcp.c
@@ -140,7 +140,7 @@ PJ_DEF(void) pjmedia_rtcp_init(pjmedia_rtcp_session *sess,
     sess->rtp_last_ts = (unsigned)-1;
 
     /* Name */
-    sess->name = name ? name : THIS_FILE,
+    sess->name = name ? name : (char*)THIS_FILE,
 
     /* Set clock rate */
     sess->clock_rate = clock_rate;
@@ -332,7 +332,7 @@ PJ_DEF(void) pjmedia_rtcp_rx_rtcp( pjmedia_rtcp_session *sess,
 				   const void *pkt,
 				   pj_size_t size)
 {
-    const pjmedia_rtcp_common *common = pkt;
+    pjmedia_rtcp_common *common = (pjmedia_rtcp_common*) pkt;
     const pjmedia_rtcp_rr *rr = NULL;
     const pjmedia_rtcp_sr *sr = NULL;
     pj_uint32_t last_loss, jitter_samp, jitter;
diff --git a/pjmedia/src/pjmedia/sdp.c b/pjmedia/src/pjmedia/sdp.c
index e0a66fc3..25d86835 100644
--- a/pjmedia/src/pjmedia/sdp.c
+++ b/pjmedia/src/pjmedia/sdp.c
@@ -460,7 +460,7 @@ PJ_DEF(pj_status_t) pjmedia_sdp_rtpmap_to_attr(pj_pool_t *pool,
 			   (int)rtpmap->param.slen,
 			   rtpmap->param.ptr);
 
-    if (len < 1 || len > sizeof(tempbuf))
+    if (len < 1 || len > (int)sizeof(tempbuf))
 	return PJMEDIA_SDP_ERTPMAPTOOLONG;
 
     attr->value.slen = len;
diff --git a/pjmedia/src/pjmedia/sdp_neg.c b/pjmedia/src/pjmedia/sdp_neg.c
index 5975eca4..ecbba9eb 100644
--- a/pjmedia/src/pjmedia/sdp_neg.c
+++ b/pjmedia/src/pjmedia/sdp_neg.c
@@ -56,7 +56,7 @@ static const char *state_str[] =
  */
 PJ_DEF(const char*) pjmedia_sdp_neg_state_str(pjmedia_sdp_neg_state state)
 {
-    if (state >=0 && state < PJ_ARRAY_SIZE(state_str))
+    if (state >=0 && state < (pjmedia_sdp_neg_state)PJ_ARRAY_SIZE(state_str))
 	return state_str[state];
 
     return "<?UNKNOWN?>";
diff --git a/pjmedia/src/pjmedia/session.c b/pjmedia/src/pjmedia/session.c
index 6e29e257..72e55a99 100644
--- a/pjmedia/src/pjmedia/session.c
+++ b/pjmedia/src/pjmedia/session.c
@@ -421,7 +421,7 @@ PJ_DEF(pj_status_t) pjmedia_stream_info_from_sdp(
 
   
     /* Now that we have codec info, get the codec param. */
-    si->param = pj_pool_alloc(pool, sizeof(*si->param));
+    si->param = PJ_POOL_ALLOC_T(pool, pjmedia_codec_param);
     status = pjmedia_codec_mgr_get_default_param(mgr, &si->fmt, si->param);
     if (status != PJ_SUCCESS)
 	return status;
@@ -532,7 +532,7 @@ PJ_DEF(pj_status_t) pjmedia_session_create( pjmedia_endpt *endpt,
 				      PJMEDIA_SESSION_INC);
     PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
 
-    session = pj_pool_zalloc(pool, sizeof(pjmedia_session));
+    session = PJ_POOL_ZALLOC_T(pool, pjmedia_session);
     session->pool = pool;
     session->endpt = endpt;
     session->stream_cnt = si->stream_cnt;
diff --git a/pjmedia/src/pjmedia/silencedet.c b/pjmedia/src/pjmedia/silencedet.c
index 6cc5e53e..2fabf4ff 100644
--- a/pjmedia/src/pjmedia/silencedet.c
+++ b/pjmedia/src/pjmedia/silencedet.c
@@ -68,7 +68,7 @@ PJ_DEF(pj_status_t) pjmedia_silence_det_create( pj_pool_t *pool,
 
     PJ_ASSERT_RETURN(pool && p_sd, PJ_EINVAL);
 
-    sd = pj_pool_zalloc(pool, sizeof(struct pjmedia_silence_det));
+    sd = PJ_POOL_ZALLOC_T(pool, pjmedia_silence_det);
 
     pj_ansi_strncpy(sd->objname, THIS_FILE, PJ_MAX_OBJ_NAME);
     sd->objname[PJ_MAX_OBJ_NAME-1] = '\0';
diff --git a/pjmedia/src/pjmedia/sound_port.c b/pjmedia/src/pjmedia/sound_port.c
index 1f64344b..459e5490 100644
--- a/pjmedia/src/pjmedia/sound_port.c
+++ b/pjmedia/src/pjmedia/sound_port.c
@@ -73,7 +73,7 @@ static pj_status_t play_cb(/* in */   void *user_data,
 			   /* out */  void *output,
 			   /* out */  unsigned size)
 {
-    pjmedia_snd_port *snd_port = user_data;
+    pjmedia_snd_port *snd_port = (pjmedia_snd_port*) user_data;
     pjmedia_port *port;
     pjmedia_frame frame;
     pj_status_t status;
@@ -111,7 +111,7 @@ static pj_status_t play_cb(/* in */   void *user_data,
 #endif
 
     if (snd_port->plc)
-	pjmedia_plc_save(snd_port->plc, output);
+	pjmedia_plc_save(snd_port->plc, (pj_int16_t*) output);
 
     if (snd_port->ec_state) {
 	if (snd_port->ec_suspended) {
@@ -120,7 +120,7 @@ static pj_status_t play_cb(/* in */   void *user_data,
 	    PJ_LOG(4,(THIS_FILE, "EC activated"));
 	}
 	snd_port->ec_suspend_count = 0;
-	pjmedia_echo_playback(snd_port->ec_state, output);
+	pjmedia_echo_playback(snd_port->ec_state, (pj_int16_t*)output);
     }
 
 
@@ -136,14 +136,14 @@ no_frame:
 	}
 	if (snd_port->ec_state) {
 	    /* To maintain correct delay in EC */
-	    pjmedia_echo_playback(snd_port->ec_state, output);
+	    pjmedia_echo_playback(snd_port->ec_state, (pj_int16_t*)output);
 	}
     }
 
     /* Apply PLC */
     if (snd_port->plc) {
 
-	pjmedia_plc_generate(snd_port->plc, output);
+	pjmedia_plc_generate(snd_port->plc, (pj_int16_t*) output);
 #ifdef SIMULATE_LOST_PCT
 	PJ_LOG(4,(THIS_FILE, "Lost frame generated"));
 #endif
@@ -165,7 +165,7 @@ static pj_status_t rec_cb(/* in */   void *user_data,
 			  /* in */   void *input,
 			  /* in*/    unsigned size)
 {
-    pjmedia_snd_port *snd_port = user_data;
+    pjmedia_snd_port *snd_port = (pjmedia_snd_port*) user_data;
     pjmedia_port *port;
     pjmedia_frame frame;
 
@@ -181,7 +181,7 @@ static pj_status_t rec_cb(/* in */   void *user_data,
 
     /* Cancel echo */
     if (snd_port->ec_state && !snd_port->ec_suspended) {
-	pjmedia_echo_capture(snd_port->ec_state, input, 0);
+	pjmedia_echo_capture(snd_port->ec_state, (pj_int16_t*) input, 0);
     }
 
     frame.buf = (void*)input;
@@ -326,7 +326,7 @@ PJ_DEF(pj_status_t) pjmedia_snd_port_create( pj_pool_t *pool,
 
     PJ_ASSERT_RETURN(pool && p_port, PJ_EINVAL);
 
-    snd_port = pj_pool_zalloc(pool, sizeof(pjmedia_snd_port));
+    snd_port = PJ_POOL_ZALLOC_T(pool, pjmedia_snd_port);
     PJ_ASSERT_RETURN(snd_port, PJ_ENOMEM);
 
     snd_port->rec_id = rec_id;
@@ -365,7 +365,7 @@ PJ_DEF(pj_status_t) pjmedia_snd_port_create_rec( pj_pool_t *pool,
 
     PJ_ASSERT_RETURN(pool && p_port, PJ_EINVAL);
 
-    snd_port = pj_pool_zalloc(pool, sizeof(pjmedia_snd_port));
+    snd_port = PJ_POOL_ZALLOC_T(pool, pjmedia_snd_port);
     PJ_ASSERT_RETURN(snd_port, PJ_ENOMEM);
 
     snd_port->rec_id = dev_id;
@@ -402,7 +402,7 @@ PJ_DEF(pj_status_t) pjmedia_snd_port_create_player( pj_pool_t *pool,
 
     PJ_ASSERT_RETURN(pool && p_port, PJ_EINVAL);
 
-    snd_port = pj_pool_zalloc(pool, sizeof(pjmedia_snd_port));
+    snd_port = PJ_POOL_ZALLOC_T(pool, pjmedia_snd_port);
     PJ_ASSERT_RETURN(snd_port, PJ_ENOMEM);
 
     snd_port->play_id = dev_id;
diff --git a/pjmedia/src/pjmedia/splitcomb.c b/pjmedia/src/pjmedia/splitcomb.c
index 53ec1759..a3d8e05f 100644
--- a/pjmedia/src/pjmedia/splitcomb.c
+++ b/pjmedia/src/pjmedia/splitcomb.c
@@ -58,7 +58,7 @@ struct splitcomb
     struct {
 	pjmedia_port *port;
 	pj_bool_t     reversed;
-    } *port_desc;
+    } port_desc[64];
 
     /* Temporary buffers needed to extract mono frame from
      * multichannel frame. We could use stack for this, but this
@@ -143,16 +143,18 @@ PJ_DEF(pj_status_t) pjmedia_splitcomb_create( pj_pool_t *pool,
     *p_splitcomb = NULL;
 
     /* Create the splitter/combiner structure */
-    sc = pj_pool_zalloc(pool, sizeof(struct splitcomb));
+    sc = PJ_POOL_ZALLOC_T(pool, struct splitcomb);
     PJ_ASSERT_RETURN(sc != NULL, PJ_ENOMEM);
 
     /* Create temporary buffers */
-    sc->get_buf = pj_pool_alloc(pool, samples_per_frame * 
+    sc->get_buf = (TMP_SAMP_TYPE*)
+		  pj_pool_alloc(pool, samples_per_frame * 
 				      sizeof(TMP_SAMP_TYPE) /
 				      channel_count);
     PJ_ASSERT_RETURN(sc->get_buf, PJ_ENOMEM);
 
-    sc->put_buf = pj_pool_alloc(pool, samples_per_frame * 
+    sc->put_buf = (TMP_SAMP_TYPE*)
+		  pj_pool_alloc(pool, samples_per_frame * 
 				      sizeof(TMP_SAMP_TYPE) /
 				      channel_count);
     PJ_ASSERT_RETURN(sc->put_buf, PJ_ENOMEM);
@@ -170,7 +172,10 @@ PJ_DEF(pj_status_t) pjmedia_splitcomb_create( pj_pool_t *pool,
     sc->base.on_destroy = &on_destroy;
 
     /* Init ports array */
+    /*
     sc->port_desc = pj_pool_zalloc(pool, channel_count*sizeof(*sc->port_desc));
+    */
+    pj_bzero(sc->port_desc, sizeof(sc->port_desc));
 
     /* Done for now */
     *p_splitcomb = &sc->base;
@@ -237,7 +242,7 @@ pjmedia_splitcomb_create_rev_channel( pj_pool_t *pool,
     PJ_UNUSED_ARG(options);
 
     /* Create the port */
-    rport = pj_pool_zalloc(pool, sizeof(struct reverse_port));
+    rport = PJ_POOL_ZALLOC_T(pool, struct reverse_port);
     rport->parent = sc;
     rport->ch_num = ch_num;
 
@@ -261,14 +266,16 @@ pjmedia_splitcomb_create_rev_channel( pj_pool_t *pool,
 
     /* Create put buffers */
     for (i=0; i<rport->buf_cnt; ++i) {
-	rport->dnstream_buf[i] = pj_pool_zalloc(pool, port->info.bytes_per_frame);
+	rport->dnstream_buf[i]=(pj_int16_t*)
+                               pj_pool_zalloc(pool, port->info.bytes_per_frame);
 	PJ_ASSERT_RETURN(rport->dnstream_buf[i], PJ_ENOMEM);
     }
     rport->dn_write_pos = rport->buf_cnt/2;
 
     /* Create get buffers */
     for (i=0; i<rport->buf_cnt; ++i) {
-	rport->upstream_buf[i] = pj_pool_zalloc(pool, 
+	rport->upstream_buf[i] = (pj_int16_t*)
+				 pj_pool_zalloc(pool, 
 						port->info.bytes_per_frame);
 	PJ_ASSERT_RETURN(rport->upstream_buf[i], PJ_ENOMEM);
     }
@@ -366,7 +373,7 @@ static pj_status_t put_frame(pjmedia_port *this_port,
 	    pjmedia_frame mono_frame;
 
 	    /* Extract the mono frame */
-	    extract_mono_frame(frame->buf, sc->put_buf, ch, 
+	    extract_mono_frame((const pj_int16_t*)frame->buf, sc->put_buf, ch, 
 			       this_port->info.channel_count, 
 			       frame->size * 8 / 
 				 this_port->info.bits_per_sample /
@@ -404,7 +411,7 @@ static pj_status_t put_frame(pjmedia_port *this_port,
 	    }
 
 	    /* Extract mono-frame and put it in downstream buffer */
-	    extract_mono_frame(frame->buf, 
+	    extract_mono_frame((const pj_int16_t*)frame->buf, 
 			       rport->dnstream_buf[rport->dn_write_pos],
 			       ch, this_port->info.channel_count, 
 			       frame->size * 8 / 
@@ -433,7 +440,8 @@ static pj_status_t get_frame(pjmedia_port *this_port,
     pj_bool_t has_frame = PJ_FALSE;
 
     /* Clear output frame */
-    pjmedia_zero_samples(frame->buf, this_port->info.samples_per_frame);
+    pjmedia_zero_samples((pj_int16_t*)frame->buf, 
+			 this_port->info.samples_per_frame);
 
     /* Read frame from each port */
     for (ch=0; ch < this_port->info.channel_count; ++ch) {
@@ -459,7 +467,8 @@ static pj_status_t get_frame(pjmedia_port *this_port,
 	    }
 
 	    /* Combine the mono frame into multichannel frame */
-	    store_mono_frame(mono_frame.buf, frame->buf, ch,
+	    store_mono_frame((const pj_int16_t*)mono_frame.buf, 
+			     (pj_int16_t*)frame->buf, ch,
 			     this_port->info.channel_count,
 			     mono_frame.size * 8 /
 				this_port->info.bits_per_sample);
@@ -494,8 +503,8 @@ static pj_status_t get_frame(pjmedia_port *this_port,
 		       rport->up_read_pos));
 
 	    /* Combine the mono frame into multichannel frame */
-	    store_mono_frame(rport->upstream_buf[rport->up_read_pos], 
-			     frame->buf, ch,
+	    store_mono_frame((const pj_int16_t*)rport->upstream_buf[rport->up_read_pos], 
+			     (pj_int16_t*)frame->buf, ch,
 			     this_port->info.channel_count,
 			     port->info.samples_per_frame);
 
@@ -579,7 +588,7 @@ static pj_status_t rport_put_frame(pjmedia_port *this_port,
 
 
     pjmedia_copy_samples(rport->upstream_buf[rport->up_write_pos],
-			 frame->buf, count);
+			 (const pj_int16_t*) frame->buf, count);
     rport->up_write_pos = (rport->up_write_pos+1) % rport->buf_cnt;
 
     return PJ_SUCCESS;
@@ -621,7 +630,7 @@ static pj_status_t rport_get_frame(pjmedia_port *this_port,
     }
 
     /* Get the samples from the circular buffer */
-    pjmedia_copy_samples(frame->buf, 
+    pjmedia_copy_samples((pj_int16_t*)frame->buf, 
 			 rport->dnstream_buf[rport->dn_read_pos],
 			 count);
     rport->dn_read_pos = (rport->dn_read_pos+1) % rport->buf_cnt;
diff --git a/pjmedia/src/pjmedia/stream.c b/pjmedia/src/pjmedia/stream.c
index acc79b9d..fec74e9a 100644
--- a/pjmedia/src/pjmedia/stream.c
+++ b/pjmedia/src/pjmedia/stream.c
@@ -166,7 +166,7 @@ static void stream_perror(const char *sender, const char *title,
  */
 static pj_status_t get_frame( pjmedia_port *port, pjmedia_frame *frame)
 {
-    pjmedia_stream *stream = port->port_data.pdata;
+    pjmedia_stream *stream = (pjmedia_stream*) port->port_data.pdata;
     pjmedia_channel *channel = stream->dec;
     unsigned samples_count, samples_per_frame, samples_required;
     pj_int16_t *p_out_samp;
@@ -191,7 +191,7 @@ static pj_status_t get_frame( pjmedia_port *port, pjmedia_frame *frame)
 			stream->codec_param.info.clock_rate *
 			stream->codec_param.info.channel_cnt / 
 			1000;
-    p_out_samp = frame->buf;
+    p_out_samp = (pj_int16_t*) frame->buf;
 
     for (samples_count=0; samples_count < samples_required; 
 	 samples_count += samples_per_frame) 
@@ -382,7 +382,7 @@ static void create_dtmf_payload(pjmedia_stream *stream,
 
     pj_assert(sizeof(pjmedia_rtp_dtmf_event) == 4);
 
-    event = frame_out->buf;
+    event = (pjmedia_rtp_dtmf_event*) frame_out->buf;
     cur_ts = pj_ntohl(stream->enc->rtp.out_hdr.ts);
     duration = cur_ts - digit->start_ts;
 
@@ -514,7 +514,7 @@ static void rebuffer(pjmedia_stream *stream,
 static pj_status_t put_frame_imp( pjmedia_port *port, 
 				  const pjmedia_frame *frame )
 {
-    pjmedia_stream *stream = port->port_data.pdata;
+    pjmedia_stream *stream = (pjmedia_stream*) port->port_data.pdata;
     pjmedia_channel *channel = stream->enc;
     pj_status_t status = 0;
     pjmedia_frame frame_out;
@@ -665,7 +665,7 @@ static pj_status_t put_frame_imp( pjmedia_port *port,
 
     /* Set RTP marker bit if currently not streaming */
     if (stream->is_streaming == PJ_FALSE) {
-	pjmedia_rtp_hdr *rtp = channel->out_pkt;
+	pjmedia_rtp_hdr *rtp = (pjmedia_rtp_hdr*) channel->out_pkt;
 
 	rtp->m = 1;
 	PJ_LOG(5,(stream->port.info.name.ptr,"Start talksprut.."));
@@ -697,7 +697,7 @@ static pj_status_t put_frame_imp( pjmedia_port *port,
 static pj_status_t put_frame( pjmedia_port *port, 
 			      const pjmedia_frame *frame )
 {
-    pjmedia_stream *stream = port->port_data.pdata;
+    pjmedia_stream *stream = (pjmedia_stream*) port->port_data.pdata;
     pjmedia_frame tmp_zero_frame;
     unsigned samples_per_frame;
 
@@ -830,7 +830,7 @@ static void dump_bin(const char *buf, unsigned len)
 static void handle_incoming_dtmf( pjmedia_stream *stream, 
 				  const void *payload, unsigned payloadlen)
 {
-    const pjmedia_rtp_dtmf_event *event = payload;
+    pjmedia_rtp_dtmf_event *event = (pjmedia_rtp_dtmf_event*) payload;
 
     /* Check compiler packing. */
     pj_assert(sizeof(pjmedia_rtp_dtmf_event)==4);
@@ -902,7 +902,7 @@ static void on_rx_rtp( void *data,
                        pj_ssize_t bytes_read)
 
 {
-    pjmedia_stream *stream = data;
+    pjmedia_stream *stream = (pjmedia_stream*) data;
     pjmedia_channel *channel = stream->dec;
     const pjmedia_rtp_hdr *hdr;
     const void *payload;
@@ -918,7 +918,7 @@ static void on_rx_rtp( void *data,
     }
 
     /* Ignore keep-alive packets */
-    if (bytes_read < sizeof(pjmedia_rtp_hdr))
+    if (bytes_read < (pj_ssize_t) sizeof(pjmedia_rtp_hdr))
 	return;
 
     /* Update RTP and RTCP session. */
@@ -1052,7 +1052,7 @@ static void on_rx_rtcp( void *data,
                         const void *pkt, 
                         pj_ssize_t bytes_read)
 {
-    pjmedia_stream *stream = data;
+    pjmedia_stream *stream = (pjmedia_stream*) data;
 
     /* Check for errors */
     if (bytes_read < 0) {
@@ -1080,7 +1080,7 @@ static pj_status_t create_channel( pj_pool_t *pool,
     
     /* Allocate memory for channel descriptor */
 
-    channel = pj_pool_zalloc(pool, sizeof(pjmedia_channel));
+    channel = PJ_POOL_ZALLOC_T(pool, pjmedia_channel);
     PJ_ASSERT_RETURN(channel != NULL, PJ_ENOMEM);
 
     /* Init channel info. */
@@ -1146,11 +1146,11 @@ PJ_DEF(pj_status_t) pjmedia_stream_create( pjmedia_endpt *endpt,
 
     /* Allocate the media stream: */
 
-    stream = pj_pool_zalloc(pool, sizeof(pjmedia_stream));
+    stream = PJ_POOL_ZALLOC_T(pool, pjmedia_stream);
     PJ_ASSERT_RETURN(stream != NULL, PJ_ENOMEM);
 
     /* Init stream/port name */
-    name.ptr = pj_pool_alloc(pool, M);
+    name.ptr = (char*) pj_pool_alloc(pool, M);
     name.slen = pj_ansi_snprintf(name.ptr, M, "strm%p", stream);
 
 
@@ -1262,7 +1262,8 @@ PJ_DEF(pj_status_t) pjmedia_stream_create( pjmedia_endpt *endpt,
 
 	/* Allocate buffer */
 	stream->enc_buf_size = stream->port.info.clock_rate * ptime / 1000;
-	stream->enc_buf = pj_pool_alloc(pool, stream->enc_buf_size * 2);
+	stream->enc_buf = (pj_int16_t*)
+			  pj_pool_alloc(pool, stream->enc_buf_size * 2);
 
     } else {
 	stream->enc_samples_per_frame = stream->port.info.samples_per_frame;
@@ -1535,7 +1536,7 @@ PJ_DEF(pj_status_t) pjmedia_stream_dial_dtmf( pjmedia_stream *stream,
     pj_mutex_lock(stream->jb_mutex);
     
     if (stream->tx_dtmf_count+digit_char->slen >=
-	PJ_ARRAY_SIZE(stream->tx_dtmf_buf))
+	(long)PJ_ARRAY_SIZE(stream->tx_dtmf_buf))
     {
 	status = PJ_ETOOMANY;
     } else {
diff --git a/pjmedia/src/pjmedia/tonegen.c b/pjmedia/src/pjmedia/tonegen.c
index 195fb6c8..945a47cb 100644
--- a/pjmedia/src/pjmedia/tonegen.c
+++ b/pjmedia/src/pjmedia/tonegen.c
@@ -305,7 +305,7 @@ PJ_DEF(pj_status_t) pjmedia_tonegen_create2(pj_pool_t *pool,
     PJ_ASSERT_RETURN(channel_count==1 || channel_count==2, PJ_EINVAL);
 
     /* Create and initialize port */
-    tonegen = pj_pool_zalloc(pool, sizeof(struct tonegen));
+    tonegen = PJ_POOL_ZALLOC_T(pool, struct tonegen);
     if (name == NULL || name->slen == 0) name = &STR_TONE_GEN;
     status = pjmedia_port_info_init(&tonegen->base.info, name, 
 				    SIGNATURE, clock_rate, channel_count, 
@@ -421,7 +421,7 @@ static pj_status_t tonegen_get_frame(pjmedia_port *port,
 	}
     }
     
-    dst = frame->buf;
+    dst = (short*) frame->buf;
     end = dst + port->info.samples_per_frame;
 
     while (dst < end) {
diff --git a/pjmedia/src/pjmedia/transport_ice.c b/pjmedia/src/pjmedia/transport_ice.c
index 7fce08a2..019ba04c 100644
--- a/pjmedia/src/pjmedia/transport_ice.c
+++ b/pjmedia/src/pjmedia/transport_ice.c
@@ -249,7 +249,7 @@ PJ_DEF(pj_status_t) pjmedia_ice_modify_sdp(pjmedia_transport *tp,
     pjmedia_sdp_attr *attr;
     unsigned i, cand_cnt;
 
-    buffer = pj_pool_alloc(pool, MAXLEN);
+    buffer = (char*) pj_pool_alloc(pool, MAXLEN);
 
     /* Create ice-ufrag attribute */
     attr = pjmedia_sdp_attr_create(pool, "ice-ufrag", 
diff --git a/pjmedia/src/pjmedia/transport_udp.c b/pjmedia/src/pjmedia/transport_udp.c
index a8576a7b..f1ef7f64 100644
--- a/pjmedia/src/pjmedia/transport_udp.c
+++ b/pjmedia/src/pjmedia/transport_udp.c
@@ -234,7 +234,7 @@ PJ_DEF(pj_status_t) pjmedia_transport_udp_attach( pjmedia_endpt *endpt,
     if (!pool)
 	return PJ_ENOMEM;
 
-    tp = pj_pool_zalloc(pool, sizeof(struct transport_udp));
+    tp = PJ_POOL_ZALLOC_T(pool, struct transport_udp);
     tp->pool = pool;
     tp->options = options;
     pj_ansi_strcpy(tp->base.name, name);
@@ -378,7 +378,7 @@ static void on_rx_rtp( pj_ioqueue_key_t *key,
 
     PJ_UNUSED_ARG(op_key);
 
-    udp = pj_ioqueue_get_user_data(key);
+    udp = (struct transport_udp*) pj_ioqueue_get_user_data(key);
 
     do {
 	void (*cb)(void*,const void*,pj_ssize_t);
@@ -479,7 +479,7 @@ static void on_rx_rtcp(pj_ioqueue_key_t *key,
 
     PJ_UNUSED_ARG(op_key);
 
-    udp = pj_ioqueue_get_user_data(key);
+    udp = (struct transport_udp*) pj_ioqueue_get_user_data(key);
 
     do {
 	void (*cb)(void*,const void*,pj_ssize_t);
@@ -567,7 +567,7 @@ static pj_status_t transport_attach(   pjmedia_transport *tp,
     pj_memcpy(&udp->rem_rtp_addr, rem_addr, sizeof(pj_sockaddr_in));
 
     /* Copy remote RTP address, if one is specified. */
-    rtcp_addr = rem_rtcp;
+    rtcp_addr = (const pj_sockaddr_in*) rem_rtcp;
     if (rtcp_addr && rtcp_addr->sin_addr.s_addr != 0) {
 	pj_memcpy(&udp->rem_rtcp_addr, rem_rtcp, sizeof(pj_sockaddr_in));
 
diff --git a/pjmedia/src/pjmedia/wav_player.c b/pjmedia/src/pjmedia/wav_player.c
index 08fc2d17..471a76bb 100644
--- a/pjmedia/src/pjmedia/wav_player.c
+++ b/pjmedia/src/pjmedia/wav_player.c
@@ -79,7 +79,7 @@ static struct file_port *create_file_port(pj_pool_t *pool)
     const pj_str_t name = pj_str("file");
     struct file_port *port;
 
-    port = pj_pool_zalloc(pool, sizeof(struct file_port));
+    port = PJ_POOL_ZALLOC_T(pool, struct file_port);
     if (!port)
 	return NULL;
 
@@ -349,7 +349,7 @@ PJ_DEF(pj_status_t) pjmedia_wav_player_port_create( pj_pool_t *pool,
 
 
     /* Create buffer. */
-    fport->buf = pj_pool_alloc(pool, fport->bufsize);
+    fport->buf = (char*) pj_pool_alloc(pool, fport->bufsize);
     if (!fport->buf) {
 	pj_file_close(fport->fd);
 	return PJ_ENOMEM;
diff --git a/pjmedia/src/pjmedia/wav_playlist.c b/pjmedia/src/pjmedia/wav_playlist.c
index 24af1127..dbd8dbea 100644
--- a/pjmedia/src/pjmedia/wav_playlist.c
+++ b/pjmedia/src/pjmedia/wav_playlist.c
@@ -84,7 +84,7 @@ static struct playlist_port *create_file_list_port(pj_pool_t *pool,
 {
     struct playlist_port *port;
 
-    port = pj_pool_zalloc(pool, sizeof(struct playlist_port));
+    port = PJ_POOL_ZALLOC_T(pool, struct playlist_port);
     if (!port)
 	return NULL;
 
@@ -275,25 +275,29 @@ PJ_DEF(pj_status_t) pjmedia_wav_playlist_create(pj_pool_t *pool,
     fport->max_file = file_count;
 
     /* Create file descriptor list */
-    fport->fd_list = pj_pool_zalloc(pool, sizeof(pj_oshandle_t)*file_count);
+    fport->fd_list = (pj_oshandle_t*)
+		     pj_pool_zalloc(pool, sizeof(pj_oshandle_t)*file_count);
     if (!fport->fd_list) {
 	return PJ_ENOMEM;
     }
 
     /* Create file size list */
-    fport->fsize_list = pj_pool_alloc(pool, sizeof(pj_off_t)*file_count);
+    fport->fsize_list = (pj_off_t*)
+			pj_pool_alloc(pool, sizeof(pj_off_t)*file_count);
     if (!fport->fsize_list) {
 	return PJ_ENOMEM;
     }
 
     /* Create start of WAVE data list */
-    fport->start_data_list = pj_pool_alloc(pool, sizeof(unsigned)*file_count);
+    fport->start_data_list = (unsigned*)
+			     pj_pool_alloc(pool, sizeof(unsigned)*file_count);
     if (!fport->start_data_list) {
 	return PJ_ENOMEM;
     }
 
     /* Create file position list */
-    fport->fpos_list = pj_pool_alloc(pool, sizeof(pj_off_t)*file_count);
+    fport->fpos_list = (pj_off_t*)
+		       pj_pool_alloc(pool, sizeof(pj_off_t)*file_count);
     if (!fport->fpos_list) {
 	return PJ_ENOMEM;
     }
@@ -305,7 +309,7 @@ PJ_DEF(pj_status_t) pjmedia_wav_playlist_create(pj_pool_t *pool,
 
 
     /* Create buffer. */
-    fport->buf = pj_pool_alloc(pool, fport->bufsize);
+    fport->buf = (char*) pj_pool_alloc(pool, fport->bufsize);
     if (!fport->buf) {
 	return PJ_ENOMEM;
     }
diff --git a/pjmedia/src/pjmedia/wav_writer.c b/pjmedia/src/pjmedia/wav_writer.c
index 2933f6ba..89eb3471 100644
--- a/pjmedia/src/pjmedia/wav_writer.c
+++ b/pjmedia/src/pjmedia/wav_writer.c
@@ -83,7 +83,7 @@ PJ_DEF(pj_status_t) pjmedia_wav_writer_port_create( pj_pool_t *pool,
     PJ_ASSERT_RETURN(bits_per_sample == 16, PJ_EINVAL);
 
     /* Create file port instance. */
-    fport = pj_pool_zalloc(pool, sizeof(struct file_port));
+    fport = PJ_POOL_ZALLOC_T(pool, struct file_port);
     PJ_ASSERT_RETURN(fport != NULL, PJ_ENOMEM);
 
     /* Initialize port info. */
@@ -149,7 +149,7 @@ PJ_DEF(pj_status_t) pjmedia_wav_writer_port_create( pj_pool_t *pool,
 
 
     /* Allocate buffer and set initial write position */
-    fport->buf = pj_pool_alloc(pool, fport->bufsize);
+    fport->buf = (char*) pj_pool_alloc(pool, fport->bufsize);
     if (fport->buf == NULL) {
 	pj_file_close(fport->fd);
 	return PJ_ENOMEM;