add a few more gcc warning flags and fix quite a few problems found by doing so

98 files changed, 809 insertions, 775 deletions

diff --git a/src/daemon/cpulimit.c b/src/daemon/cpulimit.c
index b5ed71e0..c6e13d83 100644
--- a/src/daemon/cpulimit.c
+++ b/src/daemon/cpulimit.c
@@ -100,7 +100,7 @@ static void reset_cpu_time(int t) {
     n = ru.ru_utime.tv_sec + ru.ru_stime.tv_sec + t;
     pa_assert_se(getrlimit(RLIMIT_CPU, &rl) >= 0);
 
-    rl.rlim_cur = n;
+    rl.rlim_cur = (rlim_t) n;
     pa_assert_se(setrlimit(RLIMIT_CPU, &rl) >= 0);
 }
 
@@ -130,7 +130,7 @@ static void signal_handler(int sig) {
         write_err(t);
 #endif
 
-        if (CPUTIME_INTERVAL_SOFT >= ((now-last_time)*(double)CPUTIME_PERCENT/100)) {
+        if ((double) CPUTIME_INTERVAL_SOFT >= ((double) (now-last_time)*(double)CPUTIME_PERCENT/100)) {
             static const char c = 'X';
 
             write_err("Soft CPU time limit exhausted, terminating.\n");
diff --git a/src/daemon/daemon-conf.c b/src/daemon/daemon-conf.c
index 4f7470ba..40e0a170 100644
--- a/src/daemon/daemon-conf.c
+++ b/src/daemon/daemon-conf.c
@@ -288,14 +288,14 @@ static int parse_sample_format(const char *filename, unsigned line, const char *
 
 static int parse_sample_rate(const char *filename, unsigned line, const char *lvalue, const char *rvalue, void *data, void *userdata) {
     pa_daemon_conf *c = data;
-    int32_t r;
+    uint32_t r;
 
     pa_assert(filename);
     pa_assert(lvalue);
     pa_assert(rvalue);
     pa_assert(data);
 
-    if (pa_atoi(rvalue, &r) < 0 || r > (int32_t) PA_RATE_MAX || r <= 0) {
+    if (pa_atou(rvalue, &r) < 0 || r > (uint32_t) PA_RATE_MAX || r <= 0) {
         pa_log(_("[%s:%u] Invalid sample rate '%s'."), filename, line, rvalue);
         return -1;
     }
diff --git a/src/daemon/ltdl-bind-now.c b/src/daemon/ltdl-bind-now.c
index 42c3b231..92e5d40d 100644
--- a/src/daemon/ltdl-bind-now.c
+++ b/src/daemon/ltdl-bind-now.c
@@ -24,11 +24,11 @@
 #include <config.h>
 #endif
 
-#if HAVE_DLFCN_H
+#ifdef HAVE_DLFCN_H
 #include <dlfcn.h>
 #endif
 
-#if HAVE_SYS_DL_H
+#ifdef HAVE_SYS_DL_H
 #include <sys/dl.h>
 #endif
 
diff --git a/src/modules/alsa-util.c b/src/modules/alsa-util.c
index e3e8c85c..e8c7e146 100644
--- a/src/modules/alsa-util.c
+++ b/src/modules/alsa-util.c
@@ -39,7 +39,7 @@
 #include "alsa-util.h"
 
 struct pa_alsa_fdlist {
-    int num_fds;
+    unsigned num_fds;
     struct pollfd *fds;
     /* This is a temporary buffer used to avoid lots of mallocs */
     struct pollfd *work_fds;
@@ -50,7 +50,7 @@ struct pa_alsa_fdlist {
     pa_defer_event *defer;
     pa_io_event **ios;
 
-    int polled;
+    pa_bool_t polled;
 
     void (*cb)(void *userdata);
     void *userdata;
@@ -59,7 +59,8 @@ struct pa_alsa_fdlist {
 static void io_cb(pa_mainloop_api*a, pa_io_event* e, int fd, pa_io_event_flags_t events, void *userdata) {
 
     struct pa_alsa_fdlist *fdl = userdata;
-    int err, i;
+    int err;
+    unsigned i;
     unsigned short revents;
 
     pa_assert(a);
@@ -71,11 +72,11 @@ static void io_cb(pa_mainloop_api*a, pa_io_event* e, int fd, pa_io_event_flags_t
     if (fdl->polled)
         return;
 
-    fdl->polled = 1;
+    fdl->polled = TRUE;
 
     memcpy(fdl->work_fds, fdl->fds, sizeof(struct pollfd) * fdl->num_fds);
 
-    for (i = 0;i < fdl->num_fds; i++) {
+    for (i = 0; i < fdl->num_fds; i++) {
         if (e == fdl->ios[i]) {
             if (events & PA_IO_EVENT_INPUT)
                 fdl->work_fds[i].revents |= POLLIN;
@@ -104,7 +105,8 @@ static void io_cb(pa_mainloop_api*a, pa_io_event* e, int fd, pa_io_event_flags_t
 
 static void defer_cb(pa_mainloop_api*a, pa_defer_event* e, void *userdata) {
     struct pa_alsa_fdlist *fdl = userdata;
-    int num_fds, i, err;
+    unsigned num_fds, i;
+    int err;
     struct pollfd *temp;
 
     pa_assert(a);
@@ -113,8 +115,7 @@ static void defer_cb(pa_mainloop_api*a, pa_defer_event* e, void *userdata) {
 
     a->defer_enable(fdl->defer, 0);
 
-    num_fds = snd_mixer_poll_descriptors_count(fdl->mixer);
-    pa_assert(num_fds > 0);
+    num_fds = (unsigned) snd_mixer_poll_descriptors_count(fdl->mixer);
 
     if (num_fds != fdl->num_fds) {
         if (fdl->fds)
@@ -132,7 +133,7 @@ static void defer_cb(pa_mainloop_api*a, pa_defer_event* e, void *userdata) {
         return;
     }
 
-    fdl->polled = 0;
+    fdl->polled = FALSE;
 
     if (memcmp(fdl->fds, fdl->work_fds, sizeof(struct pollfd) * num_fds) == 0)
         return;
@@ -176,7 +177,7 @@ struct pa_alsa_fdlist *pa_alsa_fdlist_new(void) {
     fdl->m = NULL;
     fdl->defer = NULL;
     fdl->ios = NULL;
-    fdl->polled = 0;
+    fdl->polled = FALSE;
 
     return fdl;
 }
@@ -190,9 +191,9 @@ void pa_alsa_fdlist_free(struct pa_alsa_fdlist *fdl) {
     }
 
     if (fdl->ios) {
-        int i;
+        unsigned i;
         pa_assert(fdl->m);
-        for (i = 0;i < fdl->num_fds;i++)
+        for (i = 0; i < fdl->num_fds; i++)
             fdl->m->io_free(fdl->ios[i]);
         pa_xfree(fdl->ios);
     }
@@ -403,7 +404,7 @@ int pa_alsa_set_hw_params(
     /* If the sample rate deviates too much, we need to resample */
     if (r < ss->rate*.95 || r > ss->rate*1.05)
         ss->rate = r;
-    ss->channels = c;
+    ss->channels = (uint8_t) c;
     ss->format = f;
 
     pa_assert(_periods > 0);
@@ -1056,10 +1057,10 @@ pa_rtpoll_item* pa_alsa_build_pollfd(snd_pcm_t *pcm, pa_rtpoll *rtpoll) {
         return NULL;
     }
 
-    item = pa_rtpoll_item_new(rtpoll, PA_RTPOLL_NEVER, n);
+    item = pa_rtpoll_item_new(rtpoll, PA_RTPOLL_NEVER, (unsigned) n);
     pollfd = pa_rtpoll_item_get_pollfd(item, NULL);
 
-    if ((err = snd_pcm_poll_descriptors(pcm, pollfd, n)) < 0) {
+    if ((err = snd_pcm_poll_descriptors(pcm, pollfd, (unsigned) n)) < 0) {
         pa_log("snd_pcm_poll_descriptors() failed: %s", snd_strerror(err));
         pa_rtpoll_item_free(item);
         return NULL;
diff --git a/src/modules/dbus-util.c b/src/modules/dbus-util.c
index c9c32a15..d2abf087 100644
--- a/src/modules/dbus-util.c
+++ b/src/modules/dbus-util.c
@@ -126,7 +126,7 @@ static void handle_time_event(pa_mainloop_api *ea, pa_time_event* e, const struc
         dbus_timeout_handle(timeout);
 
         /* restart it for the next scheduled time */
-        pa_timeval_add(&next, dbus_timeout_get_interval(timeout) * 1000);
+        pa_timeval_add(&next, (pa_usec_t) dbus_timeout_get_interval(timeout) * 1000);
         ea->time_restart(e, &next);
     }
 }
@@ -192,7 +192,7 @@ static dbus_bool_t add_timeout(DBusTimeout *timeout, void *data) {
         return FALSE;
 
     pa_gettimeofday(&tv);
-    pa_timeval_add(&tv, dbus_timeout_get_interval(timeout) * 1000);
+    pa_timeval_add(&tv, (pa_usec_t) dbus_timeout_get_interval(timeout) * 1000);
 
     ev = c->mainloop->time_new(c->mainloop, &tv, handle_time_event, timeout);
 
@@ -227,7 +227,7 @@ static void toggle_timeout(DBusTimeout *timeout, void *data) {
         struct timeval tv;
 
         pa_gettimeofday(&tv);
-        pa_timeval_add(&tv, dbus_timeout_get_interval(timeout) * 1000);
+        pa_timeval_add(&tv, (pa_usec_t) dbus_timeout_get_interval(timeout) * 1000);
 
         c->mainloop->time_restart(ev, &tv);
     } else
diff --git a/src/modules/gconf/module-gconf.c b/src/modules/gconf/module-gconf.c
index e2b0f7c0..6e8ab6ea 100644
--- a/src/modules/gconf/module-gconf.c
+++ b/src/modules/gconf/module-gconf.c
@@ -96,7 +96,7 @@ static int fill_buf(struct userdata *u) {
     if ((r = pa_read(u->fd, u->buf + u->buf_fill, BUF_MAX - u->buf_fill, &u->fd_type)) <= 0)
         return -1;
 
-    u->buf_fill += r;
+    u->buf_fill += (size_t) r;
     return 0;
 }
 
@@ -123,7 +123,7 @@ static char *read_string(struct userdata *u) {
 
         if ((e = memchr(u->buf, 0, u->buf_fill))) {
             char *ret = pa_xstrdup(u->buf);
-            u->buf_fill -= e - u->buf +1;
+            u->buf_fill -= (size_t) (e - u->buf +1);
             memmove(u->buf, e+1, u->buf_fill);
             return ret;
         }
@@ -164,10 +164,10 @@ static void unload_all_modules(struct userdata *u, struct module_info*m) {
 static void load_module(
         struct userdata *u,
         struct module_info *m,
-        int i,
+        unsigned i,
         const char *name,
         const char *args,
-        int is_new) {
+        pa_bool_t is_new) {
 
     pa_module *mod;
 
diff --git a/src/modules/module-alsa-sink.c b/src/modules/module-alsa-sink.c
index 8980ba24..e3f9a5ff 100644
--- a/src/modules/module-alsa-sink.c
+++ b/src/modules/module-alsa-sink.c
@@ -143,7 +143,7 @@ static void fix_tsched_watermark(struct userdata *u) {
     size_t min_sleep, min_wakeup;
     pa_assert(u);
 
-    max_use = u->hwbuf_size - u->hwbuf_unused_frames * u->frame_size;
+    max_use = u->hwbuf_size - (size_t) u->hwbuf_unused_frames * u->frame_size;
 
     min_sleep = pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC, &u->sink->sample_spec);
     min_wakeup = pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC, &u->sink->sample_spec);
@@ -216,8 +216,8 @@ static int try_recover(struct userdata *u, const char *call, int err) {
 static size_t check_left_to_play(struct userdata *u, snd_pcm_sframes_t n) {
     size_t left_to_play;
 
-    if (n*u->frame_size < u->hwbuf_size)
-        left_to_play = u->hwbuf_size - (n*u->frame_size);
+    if ((size_t) n*u->frame_size < u->hwbuf_size)
+        left_to_play = u->hwbuf_size - ((size_t) n*u->frame_size);
     else
         left_to_play = 0;
 
@@ -263,7 +263,7 @@ static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec) {
 
         if (PA_UNLIKELY((n = snd_pcm_avail_update(u->pcm_handle)) < 0)) {
 
-            if ((r = try_recover(u, "snd_pcm_avail_update", n)) == 0)
+            if ((r = try_recover(u, "snd_pcm_avail_update", (int) n)) == 0)
                 continue;
 
             return r;
@@ -295,6 +295,7 @@ static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec) {
             int err;
             const snd_pcm_channel_area_t *areas;
             snd_pcm_uframes_t offset, frames = (snd_pcm_uframes_t) n;
+            snd_pcm_sframes_t sframes;
 
 /*             pa_log_debug("%lu frames to write", (unsigned long) frames); */
 
@@ -330,9 +331,9 @@ static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec) {
              * a little bit longer around? */
             pa_memblock_unref_fixed(chunk.memblock);
 
-            if (PA_UNLIKELY((err = snd_pcm_mmap_commit(u->pcm_handle, offset, frames)) < 0)) {
+            if (PA_UNLIKELY((sframes = snd_pcm_mmap_commit(u->pcm_handle, offset, frames)) < 0)) {
 
-                if ((r = try_recover(u, "snd_pcm_mmap_commit", err)) == 0)
+                if ((r = try_recover(u, "snd_pcm_mmap_commit", (int) sframes)) == 0)
                     continue;
 
                 return r;
@@ -340,7 +341,7 @@ static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec) {
 
             work_done = 1;
 
-            u->frame_index += frames;
+            u->frame_index += (int64_t) frames;
             u->since_start += frames * u->frame_size;
 
 /*             pa_log_debug("wrote %lu frames", (unsigned long) frames); */
@@ -348,7 +349,7 @@ static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec) {
             if (frames >= (snd_pcm_uframes_t) n)
                 break;
 
-            n -= frames;
+            n -= (snd_pcm_sframes_t) frames;
         }
     }
 
@@ -375,7 +376,7 @@ static int unix_write(struct userdata *u, pa_usec_t *sleep_usec) {
 
         if (PA_UNLIKELY((n = snd_pcm_avail_update(u->pcm_handle)) < 0)) {
 
-            if ((r = try_recover(u, "snd_pcm_avail_update", n)) == 0)
+            if ((r = try_recover(u, "snd_pcm_avail_update", (int) n)) == 0)
                 continue;
 
             return r;
@@ -406,31 +407,31 @@ static int unix_write(struct userdata *u, pa_usec_t *sleep_usec) {
 /*         pa_log_debug("%lu frames to write", (unsigned long) frames); */
 
             if (u->memchunk.length <= 0)
-                pa_sink_render(u->sink, n * u->frame_size, &u->memchunk);
+                pa_sink_render(u->sink, (size_t) n * u->frame_size, &u->memchunk);
 
             pa_assert(u->memchunk.length > 0);
 
-            frames = u->memchunk.length / u->frame_size;
+            frames = (snd_pcm_sframes_t) (u->memchunk.length / u->frame_size);
 
             if (frames > n)
                 frames = n;
 
             p = pa_memblock_acquire(u->memchunk.memblock);
-            frames = snd_pcm_writei(u->pcm_handle, (const uint8_t*) p + u->memchunk.index, frames);
+            frames = snd_pcm_writei(u->pcm_handle, (const uint8_t*) p + u->memchunk.index, (snd_pcm_uframes_t) frames);
             pa_memblock_release(u->memchunk.memblock);
 
             pa_assert(frames != 0);
 
             if (PA_UNLIKELY(frames < 0)) {
 
-                if ((r = try_recover(u, "snd_pcm_writei", n)) == 0)
+                if ((r = try_recover(u, "snd_pcm_writei", (int) frames)) == 0)
                     continue;
 
                 return r;
             }
 
-            u->memchunk.index += frames * u->frame_size;
-            u->memchunk.length -= frames * u->frame_size;
+            u->memchunk.index += (size_t) frames * u->frame_size;
+            u->memchunk.length -= (size_t) frames * u->frame_size;
 
             if (u->memchunk.length <= 0) {
                 pa_memblock_unref(u->memchunk.memblock);
@@ -440,7 +441,7 @@ static int unix_write(struct userdata *u, pa_usec_t *sleep_usec) {
             work_done = 1;
 
             u->frame_index += frames;
-            u->since_start += frames * u->frame_size;
+            u->since_start += (size_t) frames * u->frame_size;
 
 /*         pa_log_debug("wrote %lu frames", (unsigned long) frames); */
 
@@ -494,7 +495,7 @@ static void update_smoother(struct userdata *u) {
 /*     now1 = pa_timeval_load(&timestamp); */
 
     now1 = pa_rtclock_usec();
-    now2 = pa_bytes_to_usec(frames * u->frame_size, &u->sink->sample_spec);
+    now2 = pa_bytes_to_usec((uint64_t) frames * u->frame_size, &u->sink->sample_spec);
     pa_smoother_put(u->smoother, now1, now2);
 }
 
@@ -508,7 +509,7 @@ static pa_usec_t sink_get_latency(struct userdata *u) {
     now1 = pa_rtclock_usec();
     now2 = pa_smoother_get(u->smoother, now1);
 
-    delay = (int64_t) pa_bytes_to_usec(u->frame_index * u->frame_size, &u->sink->sample_spec) - (int64_t) now2;
+    delay = (int64_t) pa_bytes_to_usec((uint64_t) u->frame_index * u->frame_size, &u->sink->sample_spec) - (int64_t) now2;
 
     if (delay > 0)
         r = (pa_usec_t) delay;
@@ -577,9 +578,9 @@ static int update_sw_params(struct userdata *u) {
             if (PA_UNLIKELY(b < u->frame_size))
                 b = u->frame_size;
 
-            u->hwbuf_unused_frames =
-                PA_LIKELY(b < u->hwbuf_size) ?
-                ((u->hwbuf_size - b) / u->frame_size) : 0;
+            u->hwbuf_unused_frames = (snd_pcm_sframes_t)
+                (PA_LIKELY(b < u->hwbuf_size) ?
+                 ((u->hwbuf_size - b) / u->frame_size) : 0);
 
             fix_tsched_watermark(u);
         }
@@ -588,7 +589,7 @@ static int update_sw_params(struct userdata *u) {
     pa_log_debug("hwbuf_unused_frames=%lu", (unsigned long) u->hwbuf_unused_frames);
 
     /* We need at last one frame in the used part of the buffer */
-    avail_min = u->hwbuf_unused_frames + 1;
+    avail_min = (snd_pcm_uframes_t) u->hwbuf_unused_frames + 1;
 
     if (u->use_tsched) {
         pa_usec_t sleep_usec, process_usec;
@@ -604,7 +605,7 @@ static int update_sw_params(struct userdata *u) {
         return err;
     }
 
-    pa_sink_set_max_request(u->sink, u->hwbuf_size - u->hwbuf_unused_frames * u->frame_size);
+    pa_sink_set_max_request(u->sink, u->hwbuf_size - (size_t) u->hwbuf_unused_frames * u->frame_size);
 
     return 0;
 }
@@ -780,7 +781,7 @@ static int sink_get_volume_cb(pa_sink *s) {
                 if ((err = snd_mixer_selem_get_playback_volume(u->mixer_elem, u->mixer_map[i], &alsa_vol)) < 0)
                     goto fail;
 
-                r.values[i] = (pa_volume_t) round(((double) (alsa_vol - u->hw_volume_min) * PA_VOLUME_NORM) / (u->hw_volume_max - u->hw_volume_min));
+                r.values[i] = (pa_volume_t) round(((double) (alsa_vol - u->hw_volume_min) * PA_VOLUME_NORM) / (double) (u->hw_volume_max - u->hw_volume_min));
             }
         }
 
@@ -856,7 +857,7 @@ static int sink_set_volume_cb(pa_sink *s) {
                 r.values[i] = pa_sw_volume_from_dB((double) alsa_vol / 100.0);
             } else {
 
-                alsa_vol = (long) round(((double) vol * (u->hw_volume_max - u->hw_volume_min)) / PA_VOLUME_NORM) + u->hw_volume_min;
+                alsa_vol = (long) round(((double) vol * (double) (u->hw_volume_max - u->hw_volume_min)) / PA_VOLUME_NORM) + u->hw_volume_min;
                 alsa_vol = PA_CLAMP_UNLIKELY(alsa_vol, u->hw_volume_min, u->hw_volume_max);
 
                 if ((err = snd_mixer_selem_set_playback_volume(u->mixer_elem, u->mixer_map[i], alsa_vol)) < 0)
@@ -865,7 +866,7 @@ static int sink_set_volume_cb(pa_sink *s) {
                 if ((err = snd_mixer_selem_get_playback_volume(u->mixer_elem, u->mixer_map[i], &alsa_vol)) < 0)
                     goto fail;
 
-                r.values[i] = (pa_volume_t) round(((double) (alsa_vol - u->hw_volume_min) * PA_VOLUME_NORM) / (u->hw_volume_max - u->hw_volume_min));
+                r.values[i] = (pa_volume_t) round(((double) (alsa_vol - u->hw_volume_min) * PA_VOLUME_NORM) / (double) (u->hw_volume_max - u->hw_volume_min));
             }
         }
 
@@ -990,7 +991,7 @@ static int process_rewind(struct userdata *u) {
 
     snd_pcm_hwsync(u->pcm_handle);
     if ((unused = snd_pcm_avail_update(u->pcm_handle)) < 0) {
-        pa_log("snd_pcm_avail_update() failed: %s", snd_strerror(unused));
+        pa_log("snd_pcm_avail_update() failed: %s", snd_strerror((int) unused));
         return -1;
     }
 
@@ -1009,15 +1010,15 @@ static int process_rewind(struct userdata *u) {
 
         pa_log_debug("Limited to %lu bytes.", (unsigned long) rewind_nbytes);
 
-        in_frames = (snd_pcm_sframes_t) rewind_nbytes / u->frame_size;
+        in_frames = (snd_pcm_sframes_t) (rewind_nbytes / u->frame_size);
         pa_log_debug("before: %lu", (unsigned long) in_frames);
-        if ((out_frames = snd_pcm_rewind(u->pcm_handle, in_frames)) < 0) {
-            pa_log("snd_pcm_rewind() failed: %s", snd_strerror(out_frames));
+        if ((out_frames = snd_pcm_rewind(u->pcm_handle, (snd_pcm_uframes_t) in_frames)) < 0) {
+            pa_log("snd_pcm_rewind() failed: %s", snd_strerror((int) out_frames));
             return -1;
         }
         pa_log_debug("after: %lu", (unsigned long) out_frames);
 
-        rewind_nbytes = out_frames * u->frame_size;
+        rewind_nbytes = (size_t) out_frames * u->frame_size;
 
         if (rewind_nbytes <= 0)
             pa_log_info("Tried rewind, but was apparently not possible.");
@@ -1211,11 +1212,11 @@ int pa__init(pa_module*m) {
     frame_size = pa_frame_size(&ss);
 
     nfrags = m->core->default_n_fragments;
-    frag_size = pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
+    frag_size = (uint32_t) pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
     if (frag_size <= 0)
-        frag_size = frame_size;
-    tsched_size = pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
-    tsched_watermark = pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);
+        frag_size = (uint32_t) frame_size;
+    tsched_size = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
+    tsched_watermark = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);
 
     if (pa_modargs_get_value_u32(ma, "fragments", &nfrags) < 0 ||
         pa_modargs_get_value_u32(ma, "fragment_size", &frag_size) < 0 ||
@@ -1395,7 +1396,7 @@ int pa__init(pa_module*m) {
     pa_sink_set_rtpoll(u->sink, u->rtpoll);
 
     u->frame_size = frame_size;
-    u->fragment_size = frag_size = period_frames * frame_size;
+    u->fragment_size = frag_size = (uint32_t) (period_frames * frame_size);
     u->nfragments = nfrags;
     u->hwbuf_size = u->fragment_size * nfrags;
     u->hwbuf_unused_frames = 0;
@@ -1452,7 +1453,7 @@ int pa__init(pa_module*m) {
                 VALGRIND_MAKE_MEM_DEFINED(&u->hw_dB_max, sizeof(u->hw_dB_max));
 #endif
 
-                pa_log_info("Volume ranges from %0.2f dB to %0.2f dB.", u->hw_dB_min/100.0, u->hw_dB_max/100.0);
+                pa_log_info("Volume ranges from %0.2f dB to %0.2f dB.", (double) u->hw_dB_min/100.0, (double) u->hw_dB_max/100.0);
                 pa_assert(u->hw_dB_min < u->hw_dB_max);
                 u->hw_dB_supported = TRUE;
             }
diff --git a/src/modules/module-alsa-source.c b/src/modules/module-alsa-source.c
index 9cf5aaf6..54ffde57 100644
--- a/src/modules/module-alsa-source.c
+++ b/src/modules/module-alsa-source.c
@@ -141,7 +141,7 @@ static void fix_tsched_watermark(struct userdata *u) {
     size_t min_sleep, min_wakeup;
     pa_assert(u);
 
-    max_use = u->hwbuf_size - u->hwbuf_unused_frames * u->frame_size;
+    max_use = u->hwbuf_size - (size_t) u->hwbuf_unused_frames * u->frame_size;
 
     min_sleep = pa_usec_to_bytes(TSCHED_MIN_SLEEP_USEC, &u->source->sample_spec);
     min_wakeup = pa_usec_to_bytes(TSCHED_MIN_WAKEUP_USEC, &u->source->sample_spec);
@@ -212,8 +212,8 @@ static int try_recover(struct userdata *u, const char *call, int err) {
 static size_t check_left_to_record(struct userdata *u, snd_pcm_sframes_t n) {
     size_t left_to_record;
 
-    if (n*u->frame_size < u->hwbuf_size)
-        left_to_record = u->hwbuf_size - (n*u->frame_size);
+    if ((size_t) n*u->frame_size < u->hwbuf_size)
+        left_to_record = u->hwbuf_size - ((size_t) n*u->frame_size);
     else
         left_to_record = 0;
 
@@ -256,7 +256,7 @@ static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec) {
 
         if (PA_UNLIKELY((n = snd_pcm_avail_update(u->pcm_handle)) < 0)) {
 
-            if ((r = try_recover(u, "snd_pcm_avail_update", n)) == 0)
+            if ((r = try_recover(u, "snd_pcm_avail_update", (int) n)) == 0)
                 continue;
 
             return r;
@@ -277,6 +277,7 @@ static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec) {
             snd_pcm_uframes_t offset, frames = (snd_pcm_uframes_t) n;
             pa_memchunk chunk;
             void *p;
+            snd_pcm_sframes_t sframes;
 
 /*             pa_log_debug("%lu frames to read", (unsigned long) frames); */
 
@@ -309,9 +310,9 @@ static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec) {
             pa_source_post(u->source, &chunk);
             pa_memblock_unref_fixed(chunk.memblock);
 
-            if (PA_UNLIKELY((err = snd_pcm_mmap_commit(u->pcm_handle, offset, frames)) < 0)) {
+            if (PA_UNLIKELY((sframes = snd_pcm_mmap_commit(u->pcm_handle, offset, frames)) < 0)) {
 
-                if ((r = try_recover(u, "snd_pcm_mmap_commit", err)) == 0)
+                if ((r = try_recover(u, "snd_pcm_mmap_commit", (int) sframes)) == 0)
                     continue;
 
                 return r;
@@ -319,14 +320,14 @@ static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec) {
 
             work_done = 1;
 
-            u->frame_index += frames;
+            u->frame_index += (int64_t) frames;
 
 /*             pa_log_debug("read %lu frames", (unsigned long) frames); */
 
             if (frames >= (snd_pcm_uframes_t) n)
                 break;
 
-            n -= frames;
+            n -= (snd_pcm_sframes_t) frames;
         }
     }
 
@@ -353,7 +354,7 @@ static int unix_read(struct userdata *u, pa_usec_t *sleep_usec) {
 
         if (PA_UNLIKELY((n = snd_pcm_avail_update(u->pcm_handle)) < 0)) {
 
-            if ((r = try_recover(u, "snd_pcm_avail_update", n)) == 0)
+            if ((r = try_recover(u, "snd_pcm_avail_update", (int) n)) == 0)
                 continue;
 
             return r;
@@ -375,7 +376,7 @@ static int unix_read(struct userdata *u, pa_usec_t *sleep_usec) {
 
             chunk.memblock = pa_memblock_new(u->core->mempool, (size_t) -1);
 
-            frames = pa_memblock_get_length(chunk.memblock) / u->frame_size;
+            frames = (snd_pcm_sframes_t) (pa_memblock_get_length(chunk.memblock) / u->frame_size);
 
             if (frames > n)
                 frames = n;
@@ -383,7 +384,7 @@ static int unix_read(struct userdata *u, pa_usec_t *sleep_usec) {
 /*             pa_log_debug("%lu frames to read", (unsigned long) n); */
 
             p = pa_memblock_acquire(chunk.memblock);
-            frames = snd_pcm_readi(u->pcm_handle, (uint8_t*) p, frames);
+            frames = snd_pcm_readi(u->pcm_handle, (uint8_t*) p, (snd_pcm_uframes_t) frames);
             pa_memblock_release(chunk.memblock);
 
             pa_assert(frames != 0);
@@ -391,14 +392,14 @@ static int unix_read(struct userdata *u, pa_usec_t *sleep_usec) {
             if (PA_UNLIKELY(frames < 0)) {
                 pa_memblock_unref(chunk.memblock);
 
-                if ((r = try_recover(u, "snd_pcm_readi", n)) == 0)
+                if ((r = try_recover(u, "snd_pcm_readi", (int) (frames))) == 0)
                     continue;
 
                 return r;
             }
 
             chunk.index = 0;
-            chunk.length = frames * u->frame_size;
+            chunk.length = (size_t) frames * u->frame_size;
 
             pa_source_post(u->source, &chunk);
             pa_memblock_unref(chunk.memblock);
@@ -442,7 +443,7 @@ static void update_smoother(struct userdata *u) {
     frames = u->frame_index + delay;
 
     now1 = pa_rtclock_usec();
-    now2 = pa_bytes_to_usec(frames * u->frame_size, &u->source->sample_spec);
+    now2 = pa_bytes_to_usec((uint64_t) frames * u->frame_size, &u->source->sample_spec);
 
     pa_smoother_put(u->smoother, now1, now2);
 }
@@ -457,7 +458,7 @@ static pa_usec_t source_get_latency(struct userdata *u) {
     now1 = pa_rtclock_usec();
     now2 = pa_smoother_get(u->smoother, now1);
 
-    delay = (int64_t) now2 - pa_bytes_to_usec(u->frame_index * u->frame_size, &u->source->sample_spec);
+    delay = (int64_t) now2 - (int64_t) pa_bytes_to_usec((uint64_t) u->frame_index * u->frame_size, &u->source->sample_spec);
 
     if (delay > 0)
         r = (pa_usec_t) delay;
@@ -522,9 +523,9 @@ static int update_sw_params(struct userdata *u) {
             if (PA_UNLIKELY(b < u->frame_size))
                 b = u->frame_size;
 
-            u->hwbuf_unused_frames =
-                PA_LIKELY(b < u->hwbuf_size) ?
-                ((u->hwbuf_size - b) / u->frame_size) : 0;
+            u->hwbuf_unused_frames = (snd_pcm_sframes_t)
+                (PA_LIKELY(b < u->hwbuf_size) ?
+                 ((u->hwbuf_size - b) / u->frame_size) : 0);
 
             fix_tsched_watermark(u);
         }
@@ -724,7 +725,7 @@ static int source_get_volume_cb(pa_source *s) {
                 if ((err = snd_mixer_selem_get_capture_volume(u->mixer_elem, u->mixer_map[i], &alsa_vol)) < 0)
                     goto fail;
 
-                r.values[i] = (pa_volume_t) round(((double) (alsa_vol - u->hw_volume_min) * PA_VOLUME_NORM) / (u->hw_volume_max - u->hw_volume_min));
+                r.values[i] = (pa_volume_t) round(((double) (alsa_vol - u->hw_volume_min) * PA_VOLUME_NORM) / (double) (u->hw_volume_max - u->hw_volume_min));
             }
         }
 
@@ -800,7 +801,7 @@ static int source_set_volume_cb(pa_source *s) {
                 r.values[i] = pa_sw_volume_from_dB((double) alsa_vol / 100.0);
             } else {
 
-                alsa_vol = (long) round(((double) vol * (u->hw_volume_max - u->hw_volume_min)) / PA_VOLUME_NORM) + u->hw_volume_min;
+                alsa_vol = (long) round(((double) vol * (double) (u->hw_volume_max - u->hw_volume_min)) / PA_VOLUME_NORM) + u->hw_volume_min;
                 alsa_vol = PA_CLAMP_UNLIKELY(alsa_vol, u->hw_volume_min, u->hw_volume_max);
 
                 if ((err = snd_mixer_selem_set_capture_volume(u->mixer_elem, u->mixer_map[i], alsa_vol)) < 0)
@@ -809,7 +810,7 @@ static int source_set_volume_cb(pa_source *s) {
                 if ((err = snd_mixer_selem_get_capture_volume(u->mixer_elem, u->mixer_map[i], &alsa_vol)) < 0)
                     goto fail;
 
-                r.values[i] = (pa_volume_t) round(((double) (alsa_vol - u->hw_volume_min) * PA_VOLUME_NORM) / (u->hw_volume_max - u->hw_volume_min));
+                r.values[i] = (pa_volume_t) round(((double) (alsa_vol - u->hw_volume_min) * PA_VOLUME_NORM) / (double) (u->hw_volume_max - u->hw_volume_min));
             }
         }
 
@@ -1043,11 +1044,11 @@ int pa__init(pa_module*m) {
     frame_size = pa_frame_size(&ss);
 
     nfrags = m->core->default_n_fragments;
-    frag_size = pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
+    frag_size = (uint32_t) pa_usec_to_bytes(m->core->default_fragment_size_msec*PA_USEC_PER_MSEC, &ss);
     if (frag_size <= 0)
-        frag_size = frame_size;
-    tsched_size = pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
-    tsched_watermark = pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);
+        frag_size = (uint32_t) frame_size;
+    tsched_size = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_BUFFER_USEC, &ss);
+    tsched_watermark = (uint32_t) pa_usec_to_bytes(DEFAULT_TSCHED_WATERMARK_USEC, &ss);
 
     if (pa_modargs_get_value_u32(ma, "fragments", &nfrags) < 0 ||
         pa_modargs_get_value_u32(ma, "fragment_size", &frag_size) < 0 ||
@@ -1220,7 +1221,7 @@ int pa__init(pa_module*m) {
     pa_source_set_rtpoll(u->source, u->rtpoll);
 
     u->frame_size = frame_size;
-    u->fragment_size = frag_size = period_frames * frame_size;
+    u->fragment_size = frag_size = (uint32_t) (period_frames * frame_size);
     u->nfragments = nfrags;
     u->hwbuf_size = u->fragment_size * nfrags;
     u->hwbuf_unused_frames = 0;
@@ -1272,7 +1273,7 @@ int pa__init(pa_module*m) {
                 VALGRIND_MAKE_MEM_DEFINED(&u->hw_dB_max, sizeof(u->hw_dB_max));
 #endif
 
-                pa_log_info("Volume ranges from %0.2f dB to %0.2f dB.", u->hw_dB_min/100.0, u->hw_dB_max/100.0);
+                pa_log_info("Volume ranges from %0.2f dB to %0.2f dB.", (double) u->hw_dB_min/100.0, (double) u->hw_dB_max/100.0);
                 pa_assert(u->hw_dB_min < u->hw_dB_max);
                 u->hw_dB_supported = TRUE;
             }
diff --git a/src/modules/module-combine.c b/src/modules/module-combine.c
index 1bfe4b4c..9fd12e30 100644
--- a/src/modules/module-combine.c
+++ b/src/modules/module-combine.c
@@ -206,9 +206,9 @@ static void adjust_rates(struct userdata *u) {
             continue;
 
         if (o->total_latency < target_latency)
-            r -= (uint32_t) (((((double) target_latency - o->total_latency))/u->adjust_time)*r/PA_USEC_PER_SEC);
+            r -= (uint32_t) ((((double) (target_latency - o->total_latency))/(double)u->adjust_time)*(double)r/PA_USEC_PER_SEC);
         else if (o->total_latency > target_latency)
-            r += (uint32_t) (((((double) o->total_latency - target_latency))/u->adjust_time)*r/PA_USEC_PER_SEC);
+            r += (uint32_t) ((((double) (o->total_latency - target_latency))/(double)u->adjust_time)*(double)r/PA_USEC_PER_SEC);
 
         if (r < (uint32_t) (base_rate*0.9) || r > (uint32_t) (base_rate*1.1)) {
             pa_log_warn("[%s] sample rates too different, not adjusting (%u vs. %u).", pa_proplist_gets(o->sink_input->proplist, PA_PROP_MEDIA_NAME), base_rate, r);
@@ -389,7 +389,7 @@ static void request_memblock(struct output *o, size_t length) {
 
     /* OK, we need to prepare new data, but only if the sink is actually running */
     if (pa_atomic_load(&o->userdata->thread_info.running))
-        pa_asyncmsgq_send(o->outq, PA_MSGOBJECT(o->userdata->sink), SINK_MESSAGE_NEED, o, length, NULL);
+        pa_asyncmsgq_send(o->outq, PA_MSGOBJECT(o->userdata->sink), SINK_MESSAGE_NEED, o, (int64_t) length, NULL);
 }
 
 /* Called from I/O thread context */
diff --git a/src/modules/module-detect.c b/src/modules/module-detect.c
index 09b720df..1616d47c 100644
--- a/src/modules/module-detect.c
+++ b/src/modules/module-detect.c
@@ -236,16 +236,16 @@ int pa__init(pa_module*m) {
         goto fail;
     }
 
-#if HAVE_ALSA
+#ifdef HAVE_ALSA
     if ((n = detect_alsa(m->core, just_one)) <= 0)
 #endif
 #if HAVE_OSS
     if ((n = detect_oss(m->core, just_one)) <= 0)
 #endif
-#if HAVE_SOLARIS
+#ifdef HAVE_SOLARIS
     if ((n = detect_solaris(m->core, just_one)) <= 0)
 #endif
-#if OS_IS_WIN32
+#ifdef OS_IS_WIN32
     if ((n = detect_waveout(m->core, just_one)) <= 0)
 #endif
     {
diff --git a/src/modules/module-device-restore.c b/src/modules/module-device-restore.c
index f7d82e4d..920b4517 100644
--- a/src/modules/module-device-restore.c
+++ b/src/modules/module-device-restore.c
@@ -106,7 +106,7 @@ static struct entry* read_entry(struct userdata *u, char *name) {
     pa_assert(name);
 
     key.dptr = name;
-    key.dsize = strlen(name);
+    key.dsize = (int) strlen(name);
 
     data = gdbm_fetch(u->gdbm_file, key);
 
@@ -210,7 +210,7 @@ static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint3
     }
 
     key.dptr = name;
-    key.dsize = strlen(name);
+    key.dsize = (int) strlen(name);
 
     data.dptr = (void*) &entry;
     data.dsize = sizeof(entry);
diff --git a/src/modules/module-esound-compat-spawnpid.c b/src/modules/module-esound-compat-spawnpid.c
index f75335d5..882dba8c 100644
--- a/src/modules/module-esound-compat-spawnpid.c
+++ b/src/modules/module-esound-compat-spawnpid.c
@@ -62,7 +62,7 @@ int pa__init(pa_module*m) {
         goto finish;
     }
 
-    if (kill(pid, SIGUSR1) < 0)
+    if (kill((pid_t) pid, SIGUSR1) < 0)
         pa_log_warn("kill(%u) failed: %s", pid, pa_cstrerror(errno));
 
     pa_module_unload_request(m, TRUE);
diff --git a/src/modules/module-esound-sink.c b/src/modules/module-esound-sink.c
index e0c07d56..14f1810a 100644
--- a/src/modules/module-esound-sink.c
+++ b/src/modules/module-esound-sink.c
@@ -165,7 +165,7 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
             pa_usec_t w, r;
 
             r = pa_smoother_get(u->smoother, pa_rtclock_usec());
-            w = pa_bytes_to_usec(u->offset + u->memchunk.length, &u->sink->sample_spec);
+            w = pa_bytes_to_usec((uint64_t) u->offset + u->memchunk.length, &u->sink->sample_spec);
 
             *((pa_usec_t*) data) = w > r ? w - r : 0;
             break;
@@ -250,8 +250,8 @@ static void thread_func(void *userdata) {
                     } else {
                         u->offset += l;
 
-                        u->memchunk.index += l;
-                        u->memchunk.length -= l;
+                        u->memchunk.index += (size_t) l;
+                        u->memchunk.length -= (size_t) l;
 
                         if (u->memchunk.length <= 0) {
                             pa_memblock_unref(u->memchunk.memblock);
@@ -285,7 +285,7 @@ static void thread_func(void *userdata) {
                 }
 #endif
 
-                usec = pa_bytes_to_usec(n, &u->sink->sample_spec);
+                usec = pa_bytes_to_usec((uint64_t) n, &u->sink->sample_spec);
 
                 if (usec > u->latency)
                     usec -= u->latency;
@@ -296,7 +296,7 @@ static void thread_func(void *userdata) {
             }
 
             /* Hmm, nothing to do. Let's sleep */
-            pollfd->events = PA_SINK_IS_OPENED(u->sink->thread_info.state) ? POLLOUT : 0;
+            pollfd->events = (short) (PA_SINK_IS_OPENED(u->sink->thread_info.state) ? POLLOUT : 0);
         }
 
         if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
@@ -342,7 +342,7 @@ static int do_write(struct userdata *u) {
             return -1;
         }
 
-        u->write_index += r;
+        u->write_index += (size_t) r;
         pa_assert(u->write_index <= u->write_length);
 
         if (u->write_index == u->write_length) {
@@ -458,7 +458,7 @@ static int do_read(struct userdata *u) {
             return -1;
         }
 
-        u->read_index += r;
+        u->read_index += (size_t) r;
         pa_assert(u->read_index <= u->read_length);
 
         if (u->read_index == u->read_length)
@@ -545,7 +545,7 @@ int pa__init(pa_module*m) {
     u->format =
         (ss.format == PA_SAMPLE_U8 ? ESD_BITS8 : ESD_BITS16) |
         (ss.channels == 2 ? ESD_STEREO : ESD_MONO);
-    u->rate = ss.rate;
+    u->rate = (int32_t) ss.rate;
     u->block_size = pa_usec_to_bytes(PA_USEC_PER_SEC/20, &ss);
 
     u->read_data = u->write_data = NULL;
diff --git a/src/modules/module-hal-detect.c b/src/modules/module-hal-detect.c
index ce766258..c76a366c 100644
--- a/src/modules/module-hal-detect.c
+++ b/src/modules/module-hal-detect.c
@@ -405,7 +405,7 @@ static void device_added_time_cb(pa_mainloop_api *ea, pa_time_event *ev, const s
     dbus_error_init(&error);
 
     if (!pa_hashmap_get(td->u->devices, td->udi)) {
-        int b;
+        dbus_bool_t b;
         struct device *d;
 
         b = libhal_device_exists(td->u->context, td->udi, &error);
@@ -433,7 +433,7 @@ static void device_added_cb(LibHalContext *context, const char *udi) {
     struct timeval tv;
     struct timerdata *t;
     struct userdata *u;
-    int good = 0;
+    pa_bool_t good = FALSE;
 
     pa_assert_se(u = libhal_ctx_get_user_data(context));
 
@@ -749,17 +749,17 @@ int pa__init(pa_module*m) {
     }
 
     if ((api = pa_modargs_get_value(ma, "api", NULL))) {
-        int good = 0;
+        pa_bool_t good = FALSE;
 
 #ifdef HAVE_ALSA
         if (strcmp(api, CAPABILITY_ALSA) == 0) {
-            good = 1;
+            good = TRUE;
             api = CAPABILITY_ALSA;
         }
 #endif
 #ifdef HAVE_OSS
         if (strcmp(api, CAPABILITY_OSS) == 0) {
-            good = 1;
+            good = TRUE;
             api = CAPABILITY_OSS;
         }
 #endif
diff --git a/src/modules/module-jack-sink.c b/src/modules/module-jack-sink.c
index edc543a8..555cb825 100644
--- a/src/modules/module-jack-sink.c
+++ b/src/modules/module-jack-sink.c
@@ -130,12 +130,12 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
                 void *p;
 
                 pa_assert(offset > 0);
-                nbytes = offset * pa_frame_size(&u->sink->sample_spec);
+                nbytes = (size_t) offset * pa_frame_size(&u->sink->sample_spec);
 
                 pa_sink_render_full(u->sink, nbytes, &chunk);
 
                 p = (uint8_t*) pa_memblock_acquire(chunk.memblock) + chunk.index;
-                pa_deinterleave(p, u->buffer, u->channels, sizeof(float), offset);
+                pa_deinterleave(p, u->buffer, u->channels, sizeof(float), (unsigned) offset);
                 pa_memblock_release(chunk.memblock);
 
                 pa_memblock_unref(chunk.memblock);
@@ -149,10 +149,10 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
                 ss.channels = 1;
 
                 for (c = 0; c < u->channels; c++)
-                    pa_silence_memory(u->buffer[c], offset * pa_sample_size(&ss), &ss);
+                    pa_silence_memory(u->buffer[c], (size_t) offset * pa_sample_size(&ss), &ss);
             }
 
-            u->frames_in_buffer = offset;
+            u->frames_in_buffer = (jack_nframes_t) offset;
             u->saved_frame_time = * (jack_nframes_t*) data;
             u->saved_frame_time_valid = TRUE;
 
@@ -342,7 +342,7 @@ int pa__init(pa_module*m) {
 
     pa_log_info("Successfully connected as '%s'", jack_get_client_name(u->client));
 
-    ss.channels = u->channels = channels;
+    u->channels = ss.channels = (uint8_t) channels;
     ss.rate = jack_get_sample_rate(u->client);
     ss.format = PA_SAMPLE_FLOAT32NE;
 
diff --git a/src/modules/module-jack-source.c b/src/modules/module-jack-source.c
index 03f9d15c..9eccbbfa 100644
--- a/src/modules/module-jack-source.c
+++ b/src/modules/module-jack-source.c
@@ -116,7 +116,7 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
             if (u->source->thread_info.state == PA_SOURCE_RUNNING)
                 pa_source_post(u->source, chunk);
 
-            u->saved_frame_time = offset;
+            u->saved_frame_time = (jack_nframes_t) offset;
             u->saved_frame_time_valid = TRUE;
 
             return 0;
@@ -309,7 +309,7 @@ int pa__init(pa_module*m) {
 
     pa_log_info("Successfully connected as '%s'", jack_get_client_name(u->client));
 
-    ss.channels = u->channels = channels;
+    u->channels = ss.channels = (uint8_t) channels;
     ss.rate = jack_get_sample_rate(u->client);
     ss.format = PA_SAMPLE_FLOAT32NE;
 
diff --git a/src/modules/module-ladspa-sink.c b/src/modules/module-ladspa-sink.c
index 23eeb340..9127af01 100644
--- a/src/modules/module-ladspa-sink.c
+++ b/src/modules/module-ladspa-sink.c
@@ -187,7 +187,7 @@ static int sink_input_pop_cb(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk
     pa_assert(tchunk.length > 0);
 
     fs = pa_frame_size(&i->sample_spec);
-    n = PA_MIN(tchunk.length, u->block_size) / fs;
+    n = (unsigned) (PA_MIN(tchunk.length, u->block_size) / fs);
 
     pa_assert(n > 0);
 
@@ -502,9 +502,9 @@ int pa__init(pa_module*m) {
 
     u->block_size = pa_frame_align(pa_mempool_block_size_max(m->core->mempool), &ss);
 
-    u->input = (LADSPA_Data*) pa_xnew(uint8_t, u->block_size);
+    u->input = (LADSPA_Data*) pa_xnew(uint8_t, (unsigned) u->block_size);
     if (LADSPA_IS_INPLACE_BROKEN(d->Properties))
-        u->output = (LADSPA_Data*) pa_xnew(uint8_t, u->block_size);
+        u->output = (LADSPA_Data*) pa_xnew(uint8_t, (unsigned) u->block_size);
     else
         u->output = u->input;
 
@@ -530,8 +530,8 @@ int pa__init(pa_module*m) {
         char *k;
         unsigned long h;
 
-        u->control = pa_xnew(LADSPA_Data, n_control);
-        use_default = pa_xnew(pa_bool_t, n_control);
+        u->control = pa_xnew(LADSPA_Data, (unsigned) n_control);
+        use_default = pa_xnew(pa_bool_t, (unsigned) n_control);
         p = 0;
 
         while ((k = pa_split(cdata, ",", &state)) && p < n_control) {
@@ -552,7 +552,7 @@ int pa__init(pa_module*m) {
             pa_xfree(k);
 
             use_default[p] = FALSE;
-            u->control[p++] = f;
+            u->control[p++] = (LADSPA_Data) f;
         }
 
         /* The previous loop doesn't take the last control value into account
@@ -601,8 +601,8 @@ int pa__init(pa_module*m) {
                 upper = d->PortRangeHints[p].UpperBound;
 
                 if (LADSPA_IS_HINT_SAMPLE_RATE(hint)) {
-                    lower *= ss.rate;
-                    upper *= ss.rate;
+                    lower *= (LADSPA_Data) ss.rate;
+                    upper *= (LADSPA_Data) ss.rate;
                 }
 
                 switch (hint & LADSPA_HINT_DEFAULT_MASK) {
@@ -617,23 +617,23 @@ int pa__init(pa_module*m) {
 
                     case LADSPA_HINT_DEFAULT_LOW:
                         if (LADSPA_IS_HINT_LOGARITHMIC(hint))
-                            u->control[h] = exp(log(lower) * 0.75 + log(upper) * 0.25);
+                            u->control[h] = (LADSPA_Data) exp(log(lower) * 0.75 + log(upper) * 0.25);
                         else
-                            u->control[h] = lower * 0.75 + upper * 0.25;
+                            u->control[h] = (LADSPA_Data) (lower * 0.75 + upper * 0.25);
                         break;
 
                     case LADSPA_HINT_DEFAULT_MIDDLE:
                         if (LADSPA_IS_HINT_LOGARITHMIC(hint))
-                            u->control[h] = exp(log(lower) * 0.5 + log(upper) * 0.5);
+                            u->control[h] = (LADSPA_Data) exp(log(lower) * 0.5 + log(upper) * 0.5);
                         else
-                            u->control[h] = lower * 0.5 + upper * 0.5;
+                            u->control[h] = (LADSPA_Data) (lower * 0.5 + upper * 0.5);
                         break;
 
                     case LADSPA_HINT_DEFAULT_HIGH:
                         if (LADSPA_IS_HINT_LOGARITHMIC(hint))
-                            u->control[h] = exp(log(lower) * 0.25 + log(upper) * 0.75);
+                            u->control[h] = (LADSPA_Data) exp(log(lower) * 0.25 + log(upper) * 0.75);
                         else
-                            u->control[h] = lower * 0.25 + upper * 0.75;
+                            u->control[h] = (LADSPA_Data) (lower * 0.25 + upper * 0.75);
                         break;
 
                     case LADSPA_HINT_DEFAULT_0:
diff --git a/src/modules/module-oss.c b/src/modules/module-oss.c
index 15b1e956..3333eb83 100644
--- a/src/modules/module-oss.c
+++ b/src/modules/module-oss.c
@@ -258,7 +258,7 @@ static int mmap_write(struct userdata *u) {
     u->out_mmap_saved_nfrags = 0;
 
     if (info.blocks > 0)
-        mmap_fill_memblocks(u, info.blocks);
+        mmap_fill_memblocks(u, (unsigned) info.blocks);
 
     return info.blocks;
 }
@@ -336,7 +336,7 @@ static int mmap_read(struct userdata *u) {
     u->in_mmap_saved_nfrags = 0;
 
     if (info.blocks > 0) {
-        mmap_post_memblocks(u, info.blocks);
+        mmap_post_memblocks(u, (unsigned) info.blocks);
         mmap_clear_memblocks(u, u->in_nfrags/2);
     }
 
@@ -356,12 +356,12 @@ static pa_usec_t mmap_sink_get_latency(struct userdata *u) {
 
     u->out_mmap_saved_nfrags += info.blocks;
 
-    bpos = ((u->out_mmap_current + u->out_mmap_saved_nfrags) * u->out_fragment_size) % u->out_hwbuf_size;
+    bpos = ((u->out_mmap_current + (unsigned) u->out_mmap_saved_nfrags) * u->out_fragment_size) % u->out_hwbuf_size;
 
     if (bpos <= (size_t) info.ptr)
-        n = u->out_hwbuf_size - (info.ptr - bpos);
+        n = u->out_hwbuf_size - ((size_t) info.ptr - bpos);
     else
-        n = bpos - info.ptr;
+        n = bpos - (size_t) info.ptr;
 
 /*     pa_log("n = %u, bpos = %u, ptr = %u, total=%u, fragsize = %u, n_frags = %u\n", n, bpos, (unsigned) info.ptr, total, u->out_fragment_size, u->out_fragments); */
 
@@ -380,12 +380,12 @@ static pa_usec_t mmap_source_get_latency(struct userdata *u) {
     }
 
     u->in_mmap_saved_nfrags += info.blocks;
-    bpos = ((u->in_mmap_current + u->in_mmap_saved_nfrags) * u->in_fragment_size) % u->in_hwbuf_size;
+    bpos = ((u->in_mmap_current + (unsigned) u->in_mmap_saved_nfrags) * u->in_fragment_size) % u->in_hwbuf_size;
 
     if (bpos <= (size_t) info.ptr)
-        n = info.ptr - bpos;
+        n = (size_t) info.ptr - bpos;
     else
-        n = u->in_hwbuf_size - bpos + info.ptr;
+        n = u->in_hwbuf_size - bpos + (size_t) info.ptr;
 
 /*     pa_log("n = %u, bpos = %u, ptr = %u, total=%u, fragsize = %u, n_frags = %u\n", n, bpos, (unsigned) info.ptr, total, u->in_fragment_size, u->in_fragments);  */
 
@@ -404,7 +404,7 @@ static pa_usec_t io_sink_get_latency(struct userdata *u) {
             pa_log_info("Device doesn't support SNDCTL_DSP_GETODELAY: %s", pa_cstrerror(errno));
             u->use_getodelay = 0;
         } else
-            r = pa_bytes_to_usec(arg, &u->sink->sample_spec);
+            r = pa_bytes_to_usec((size_t) arg, &u->sink->sample_spec);
 
     }
 
@@ -415,7 +415,7 @@ static pa_usec_t io_sink_get_latency(struct userdata *u) {
             pa_log_info("Device doesn't support SNDCTL_DSP_GETOSPACE: %s", pa_cstrerror(errno));
             u->use_getospace = 0;
         } else
-            r = pa_bytes_to_usec(info.bytes, &u->sink->sample_spec);
+            r = pa_bytes_to_usec((size_t) info.bytes, &u->sink->sample_spec);
     }
 
     if (u->memchunk.memblock)
@@ -437,7 +437,7 @@ static pa_usec_t io_source_get_latency(struct userdata *u) {
             pa_log_info("Device doesn't support SNDCTL_DSP_GETISPACE: %s", pa_cstrerror(errno));
             u->use_getispace = 0;
         } else
-            r = pa_bytes_to_usec(info.bytes, &u->source->sample_spec);
+            r = pa_bytes_to_usec((size_t) info.bytes, &u->source->sample_spec);
     }
 
     return r;
@@ -528,8 +528,9 @@ static int unsuspend(struct userdata *u) {
     if ((u->fd = pa_oss_open(u->device_name, &m, NULL)) < 0) {
         pa_log_warn("Resume failed, device busy (%s)", pa_cstrerror(errno));
         return -1;
+    }
 
-    if (m != u->mode)
+    if (m != u->mode) {
         pa_log_warn("Resume failed, couldn't open device with original access mode.");
         goto fail;
     }
@@ -859,7 +860,7 @@ static int source_set_volume(pa_source *s) {
 static void thread_func(void *userdata) {
     struct userdata *u = userdata;
     int write_type = 0, read_type = 0;
-    unsigned short revents = 0;
+    short revents = 0;
 
     pa_assert(u);
 
@@ -935,7 +936,7 @@ static void thread_func(void *userdata) {
                     ssize_t t;
 
                     if (u->memchunk.length <= 0)
-                        pa_sink_render(u->sink, l, &u->memchunk);
+                        pa_sink_render(u->sink, (size_t) l, &u->memchunk);
 
                     pa_assert(u->memchunk.length > 0);
 
@@ -965,8 +966,8 @@ static void thread_func(void *userdata) {
 
                     } else {
 
-                        u->memchunk.index += t;
-                        u->memchunk.length -= t;
+                        u->memchunk.index += (size_t) t;
+                        u->memchunk.length -= (size_t) t;
 
                         if (u->memchunk.length <= 0) {
                             pa_memblock_unref(u->memchunk.memblock);
@@ -1031,7 +1032,8 @@ static void thread_func(void *userdata) {
                 }
 
                 while (l > 0) {
-                    ssize_t t, k;
+                    ssize_t t;
+                    size_t k;
 
                     pa_assert(l > 0);
 
@@ -1039,8 +1041,8 @@ static void thread_func(void *userdata) {
 
                     k = pa_memblock_get_length(memchunk.memblock);
 
-                    if (k > l)
-                        k = l;
+                    if (k > (size_t) l)
+                        k = (size_t) l;
 
                     k = (k/u->frame_size)*u->frame_size;
 
@@ -1071,7 +1073,7 @@ static void thread_func(void *userdata) {
 
                     } else {
                         memchunk.index = 0;
-                        memchunk.length = t;
+                        memchunk.length = (size_t) t;
 
                         pa_source_post(u->source, &memchunk);
                         pa_memblock_unref(memchunk.memblock);
@@ -1099,9 +1101,9 @@ static void thread_func(void *userdata) {
             pa_assert(u->fd >= 0);
 
             pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
-            pollfd->events =
-                ((u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state)) ? POLLIN : 0) |
-                ((u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state)) ? POLLOUT : 0);
+            pollfd->events = (short)
+                (((u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state)) ? POLLIN : 0) |
+                 ((u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state)) ? POLLOUT : 0));
         }
 
         /* Hmm, nothing to do. Let's sleep */
@@ -1179,10 +1181,10 @@ int pa__init(pa_module*m) {
         goto fail;
     }
 
-    nfrags = m->core->default_n_fragments;
-    frag_size = pa_usec_to_bytes(m->core->default_fragment_size_msec*1000, &ss);
+    nfrags = (int) m->core->default_n_fragments;
+    frag_size = (int) pa_usec_to_bytes(m->core->default_fragment_size_msec*1000, &ss);
     if (frag_size <= 0)
-        frag_size = pa_frame_size(&ss);
+        frag_size = (int) pa_frame_size(&ss);
 
     if (pa_modargs_get_value_s32(ma, "fragments", &nfrags) < 0 || pa_modargs_get_value_s32(ma, "fragment_size", &frag_size) < 0) {
         pa_log("Failed to parse fragments arguments");
@@ -1238,8 +1240,8 @@ int pa__init(pa_module*m) {
     u->mode = mode;
     u->frame_size = pa_frame_size(&ss);
     u->device_name = pa_xstrdup(dev);
-    u->in_nfrags = u->out_nfrags = u->nfrags = nfrags;
-    u->out_fragment_size = u->in_fragment_size = u->frag_size = frag_size;
+    u->in_nfrags = u->out_nfrags = (uint32_t) (u->nfrags = nfrags);
+    u->out_fragment_size = u->in_fragment_size = (uint32_t) (u->frag_size = frag_size);
     u->use_mmap = use_mmap;
     u->rtpoll = pa_rtpoll_new();
     pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
@@ -1248,15 +1250,15 @@ int pa__init(pa_module*m) {
 
     if (ioctl(fd, SNDCTL_DSP_GETISPACE, &info) >= 0) {
         pa_log_info("Input -- %u fragments of size %u.", info.fragstotal, info.fragsize);
-        u->in_fragment_size = info.fragsize;
-        u->in_nfrags = info.fragstotal;
+        u->in_fragment_size = (uint32_t) info.fragsize;
+        u->in_nfrags = (uint32_t) info.fragstotal;
         u->use_getispace = TRUE;
     }
 
     if (ioctl(fd, SNDCTL_DSP_GETOSPACE, &info) >= 0) {
         pa_log_info("Output -- %u fragments of size %u.", info.fragstotal, info.fragsize);
-        u->out_fragment_size = info.fragsize;
-        u->out_nfrags = info.fragstotal;
+        u->out_fragment_size = (uint32_t) info.fragsize;
+        u->out_nfrags = (uint32_t) info.fragstotal;
         u->use_getospace = TRUE;
     }
 
diff --git a/src/modules/module-pipe-sink.c b/src/modules/module-pipe-sink.c
index f389cd06..ae230b2c 100644
--- a/src/modules/module-pipe-sink.c
+++ b/src/modules/module-pipe-sink.c
@@ -145,8 +145,8 @@ static int process_render(struct userdata *u) {
 
         } else {
 
-            u->memchunk.index += l;
-            u->memchunk.length -= l;
+            u->memchunk.index += (size_t) l;
+            u->memchunk.length -= (size_t) l;
 
             if (u->memchunk.length <= 0) {
                 pa_memblock_unref(u->memchunk.memblock);
@@ -189,7 +189,7 @@ static void thread_func(void *userdata) {
         }
 
         /* Hmm, nothing to do. Let's sleep */
-        pollfd->events = u->sink->thread_info.state == PA_SINK_RUNNING ? POLLOUT : 0;
+        pollfd->events = (short) (u->sink->thread_info.state == PA_SINK_RUNNING ? POLLOUT : 0);
 
         if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
             goto fail;
diff --git a/src/modules/module-pipe-source.c b/src/modules/module-pipe-source.c
index b0de34ca..25151d95 100644
--- a/src/modules/module-pipe-source.c
+++ b/src/modules/module-pipe-source.c
@@ -135,9 +135,9 @@ static void thread_func(void *userdata) {
 
             } else {
 
-                u->memchunk.length = l;
+                u->memchunk.length = (size_t) l;
                 pa_source_post(u->source, &u->memchunk);
-                u->memchunk.index += l;
+                u->memchunk.index += (size_t) l;
 
                 if (u->memchunk.index >= pa_memblock_get_length(u->memchunk.memblock)) {
                     pa_memblock_unref(u->memchunk.memblock);
@@ -149,7 +149,7 @@ static void thread_func(void *userdata) {
         }
 
         /* Hmm, nothing to do. Let's sleep */
-        pollfd->events = u->source->thread_info.state == PA_SOURCE_RUNNING ? POLLIN : 0;
+        pollfd->events = (short) (u->source->thread_info.state == PA_SOURCE_RUNNING ? POLLIN : 0);
 
         if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
             goto fail;
diff --git a/src/modules/module-protocol-stub.c b/src/modules/module-protocol-stub.c
index 4fe439f9..0e98b1c3 100644
--- a/src/modules/module-protocol-stub.c
+++ b/src/modules/module-protocol-stub.c
@@ -299,11 +299,11 @@ int pa__init(pa_module*m) {
     listen_on = pa_modargs_get_value(ma, "listen", NULL);
 
     if (listen_on) {
-        u->socket_server_ipv6 = pa_socket_server_new_ipv6_string(m->core->mainloop, listen_on, port, TCPWRAP_SERVICE);
-        u->socket_server_ipv4 = pa_socket_server_new_ipv4_string(m->core->mainloop, listen_on, port, TCPWRAP_SERVICE);
+        u->socket_server_ipv6 = pa_socket_server_new_ipv6_string(m->core->mainloop, listen_on, (uint16_t) port, TCPWRAP_SERVICE);
+        u->socket_server_ipv4 = pa_socket_server_new_ipv4_string(m->core->mainloop, listen_on, (uint16_t) port, TCPWRAP_SERVICE);
     } else {
-        u->socket_server_ipv6 = pa_socket_server_new_ipv6_any(m->core->mainloop, port, TCPWRAP_SERVICE);
-        u->socket_server_ipv4 = pa_socket_server_new_ipv4_any(m->core->mainloop, port, TCPWRAP_SERVICE);
+        u->socket_server_ipv6 = pa_socket_server_new_ipv6_any(m->core->mainloop, (uint16_t) port, TCPWRAP_SERVICE);
+        u->socket_server_ipv4 = pa_socket_server_new_ipv4_any(m->core->mainloop, (uint16_t) port, TCPWRAP_SERVICE);
     }
 
     if (!u->socket_server_ipv4 && !u->socket_server_ipv6)
@@ -327,7 +327,7 @@ int pa__init(pa_module*m) {
     /* This socket doesn't reside in our own runtime dir but in
      * /tmp/.esd/, hence we have to create the dir first */
 
-    if (pa_make_secure_parent_dir(u->socket_path, pa_in_system_mode() ? 0755 : 0700, (uid_t)-1, (gid_t)-1) < 0) {
+    if (pa_make_secure_parent_dir(u->socket_path, pa_in_system_mode() ? 0755U : 0700U, (uid_t)-1, (gid_t)-1) < 0) {
         pa_log("Failed to create socket directory '%s': %s\n", u->socket_path, pa_cstrerror(errno));
         goto fail;
     }
diff --git a/src/modules/module-sine.c b/src/modules/module-sine.c
index a6324526..21565cc4 100644
--- a/src/modules/module-sine.c
+++ b/src/modules/module-sine.c
@@ -116,13 +116,13 @@ static void sink_input_state_change_cb(pa_sink_input *i, pa_sink_input_state_t s
         pa_sink_input_request_rewind(i, 0, FALSE, TRUE);
 }
 
-static void calc_sine(float *f, size_t l, float freq) {
+static void calc_sine(float *f, size_t l, double freq) {
     size_t i;
 
     l /= sizeof(float);
 
     for (i = 0; i < l; i++)
-        f[i] = (float) sin((double) i/l*M_PI*2*freq)/2;
+        f[i] = (float) sin((double) i/(double)l*M_PI*2*freq)/2;
 }
 
 int pa__init(pa_module*m) {
@@ -163,7 +163,7 @@ int pa__init(pa_module*m) {
 
     u->memblock = pa_memblock_new(m->core->mempool, pa_bytes_per_second(&ss));
     p = pa_memblock_acquire(u->memblock);
-    calc_sine(p, pa_memblock_get_length(u->memblock), frequency);
+    calc_sine(p, pa_memblock_get_length(u->memblock), (double) frequency);
     pa_memblock_release(u->memblock);
 
     pa_sink_input_new_data_init(&data);
diff --git a/src/modules/module-stream-restore.c b/src/modules/module-stream-restore.c
index 7bbb47d5..37e8b067 100644
--- a/src/modules/module-stream-restore.c
+++ b/src/modules/module-stream-restore.c
@@ -145,7 +145,7 @@ static struct entry* read_entry(struct userdata *u, char *name) {
     pa_assert(name);
 
     key.dptr = name;
-    key.dsize = strlen(name);
+    key.dsize = (int) strlen(name);
 
     data = gdbm_fetch(u->gdbm_file, key);
 
@@ -277,7 +277,7 @@ static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint3
     }
 
     key.dptr = name;
-    key.dsize = strlen(name);
+    key.dsize = (int) strlen(name);
 
     data.dptr = (void*) &entry;
     data.dsize = sizeof(entry);
@@ -544,7 +544,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio
 
                 next_key = gdbm_nextkey(u->gdbm_file, key);
 
-                name = pa_xstrndup(key.dptr, key.dsize);
+                name = pa_xstrndup(key.dptr, (size_t) key.dsize);
                 pa_xfree(key.dptr);
 
                 if ((e = read_entry(u, name))) {
@@ -604,7 +604,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio
                 pa_strlcpy(entry.device, device, sizeof(entry.device));
 
                 key.dptr = (void*) name;
-                key.dsize = strlen(name);
+                key.dsize = (int) strlen(name);
 
                 data.dptr = (void*) &entry;
                 data.dsize = sizeof(entry);
@@ -629,7 +629,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio
                     goto fail;
 
                 key.dptr = (void*) name;
-                key.dsize = strlen(name);
+                key.dsize = (int) strlen(name);
 
                 gdbm_delete(u->gdbm_file, key);
             }
diff --git a/src/modules/module-tunnel.c b/src/modules/module-tunnel.c
index 79ce1dd2..de3c7274 100644
--- a/src/modules/module-tunnel.c
+++ b/src/modules/module-tunnel.c
@@ -178,7 +178,7 @@ struct userdata {
 #ifdef TUNNEL_SINK
     char *sink_name;
     pa_sink *sink;
-    int32_t requested_bytes;
+    size_t requested_bytes;
 #else
     char *source_name;
     pa_source *source;
@@ -389,7 +389,7 @@ static void send_data(struct userdata *u) {
 
         u->requested_bytes -= memchunk.length;
 
-        u->counter += memchunk.length;
+        u->counter += (int64_t) memchunk.length;
     }
 }
 
@@ -417,7 +417,7 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
         case PA_SINK_MESSAGE_GET_LATENCY: {
             pa_usec_t yl, yr, *usec = data;
 
-            yl = pa_bytes_to_usec(u->counter, &u->sink->sample_spec);
+            yl = pa_bytes_to_usec((uint64_t) u->counter, &u->sink->sample_spec);
             yr = pa_smoother_get(u->smoother, pa_rtclock_usec());
 
             *usec = yl > yr ? yl - yr : 0;
@@ -444,10 +444,10 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
         case SINK_MESSAGE_UPDATE_LATENCY: {
             pa_usec_t y;
 
-            y = pa_bytes_to_usec(u->counter, &u->sink->sample_spec);
+            y = pa_bytes_to_usec((uint64_t) u->counter, &u->sink->sample_spec);
 
             if (y > (pa_usec_t) offset || offset < 0)
-                y -= offset;
+                y -= (pa_usec_t) offset;
             else
                 y = 0;
 
@@ -465,7 +465,7 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
 
             pa_pstream_send_memblock(u->pstream, u->channel, 0, PA_SEEK_RELATIVE, chunk);
 
-            u->counter_delta += chunk->length;
+            u->counter_delta += (int64_t) chunk->length;
 
             return 0;
     }
@@ -520,7 +520,7 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
         case PA_SOURCE_MESSAGE_GET_LATENCY: {
             pa_usec_t yr, yl, *usec = data;
 
-            yl = pa_bytes_to_usec(u->counter, &PA_SINK(o)->sample_spec);
+            yl = pa_bytes_to_usec((uint64_t) u->counter, &PA_SINK(o)->sample_spec);
             yr = pa_smoother_get(u->smoother, pa_rtclock_usec());
 
             *usec = yr > yl ? yr - yl : 0;
@@ -532,7 +532,7 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
             if (PA_SOURCE_IS_OPENED(u->source->thread_info.state))
                 pa_source_post(u->source, chunk);
 
-            u->counter += chunk->length;
+            u->counter += (int64_t) chunk->length;
 
             return 0;
 
@@ -544,10 +544,10 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
         case SOURCE_MESSAGE_UPDATE_LATENCY: {
             pa_usec_t y;
 
-            y = pa_bytes_to_usec(u->counter, &u->source->sample_spec);
+            y = pa_bytes_to_usec((uint64_t) u->counter, &u->source->sample_spec);
 
             if (offset >= 0 || y > (pa_usec_t) -offset)
-                y += offset;
+                y += (pa_usec_t) offset;
             else
                 y = 0;
 
@@ -736,9 +736,9 @@ static void stream_get_latency_callback(pa_pdispatch *pd, uint32_t command, uint
 
     /* Add the length of our server-side buffer */
     if (write_index >= read_index)
-        delay += (int64_t) pa_bytes_to_usec(write_index-read_index, ss);
+        delay += (int64_t) pa_bytes_to_usec((uint64_t) (write_index-read_index), ss);
     else
-        delay -= (int64_t) pa_bytes_to_usec(read_index-write_index, ss);
+        delay -= (int64_t) pa_bytes_to_usec((uint64_t) (read_index-write_index), ss);
 
     /* Our measurements are already out of date, hence correct by the     *
      * transport latency */
@@ -750,9 +750,9 @@ static void stream_get_latency_callback(pa_pdispatch *pd, uint32_t command, uint
 
     /* Now correct by what we have have read/written since we requested the update */
 #ifdef TUNNEL_SINK
-    delay += (int64_t) pa_bytes_to_usec(u->counter_delta, ss);
+    delay += (int64_t) pa_bytes_to_usec((uint64_t) u->counter_delta, ss);
 #else
-    delay -= (int64_t) pa_bytes_to_usec(u->counter_delta, ss);
+    delay -= (int64_t) pa_bytes_to_usec((uint64_t) u->counter_delta, ss);
 #endif
 
 #ifdef TUNNEL_SINK
@@ -1425,11 +1425,11 @@ static void setup_complete_callback(pa_pdispatch *pd, uint32_t command, uint32_t
         u->maxlength = 4*1024*1024;
 
 #ifdef TUNNEL_SINK
-    u->tlength = pa_usec_to_bytes(PA_USEC_PER_MSEC * DEFAULT_TLENGTH_MSEC, &u->sink->sample_spec);
-    u->minreq = pa_usec_to_bytes(PA_USEC_PER_MSEC * DEFAULT_MINREQ_MSEC, &u->sink->sample_spec);
+    u->tlength = (uint32_t) pa_usec_to_bytes(PA_USEC_PER_MSEC * DEFAULT_TLENGTH_MSEC, &u->sink->sample_spec);
+    u->minreq = (uint32_t) pa_usec_to_bytes(PA_USEC_PER_MSEC * DEFAULT_MINREQ_MSEC, &u->sink->sample_spec);
     u->prebuf = u->tlength;
 #else
-    u->fragsize = pa_usec_to_bytes(PA_USEC_PER_MSEC * DEFAULT_FRAGSIZE_MSEC, &u->source->sample_spec);
+    u->fragsize = (uint32_t) pa_usec_to_bytes(PA_USEC_PER_MSEC * DEFAULT_FRAGSIZE_MSEC, &u->source->sample_spec);
 #endif
 
 #ifdef TUNNEL_SINK
@@ -1548,7 +1548,7 @@ static void pstream_memblock_callback(pa_pstream *p, uint32_t channel, int64_t o
 
     pa_asyncmsgq_send(u->source->asyncmsgq, PA_MSGOBJECT(u->source), SOURCE_MESSAGE_POST, PA_UINT_TO_PTR(seek), offset, chunk);
 
-    u->counter_delta += chunk->length;
+    u->counter_delta += (int64_t) chunk->length;
 }
 
 #endif
diff --git a/src/modules/module-volume-restore.c b/src/modules/module-volume-restore.c
index 0fb17a0d..aac0d046 100644
--- a/src/modules/module-volume-restore.c
+++ b/src/modules/module-volume-restore.c
@@ -103,7 +103,7 @@ static pa_cvolume* parse_volume(const char *s, pa_cvolume *v) {
     if (k <= 0 || k > (long) PA_CHANNELS_MAX)
         return NULL;
 
-    v->channels = (unsigned) k;
+    v->channels = (uint8_t) k;
 
     for (i = 0; i < v->channels; i++) {
         p += strspn(p, WHITESPACE);
diff --git a/src/modules/module-x11-bell.c b/src/modules/module-x11-bell.c
index ae16b9ae..e93721c1 100644
--- a/src/modules/module-x11-bell.c
+++ b/src/modules/module-x11-bell.c
@@ -82,7 +82,7 @@ static int x11_event_cb(pa_x11_wrapper *w, XEvent *e, void *userdata) {
 
     bne = (XkbBellNotifyEvent*) e;
 
-    if (pa_scache_play_item_by_name(u->core, u->scache_item, u->sink_name, TRUE, (bne->percent*PA_VOLUME_NORM)/100, NULL, NULL) < 0) {
+    if (pa_scache_play_item_by_name(u->core, u->scache_item, u->sink_name, TRUE, ((pa_volume_t) bne->percent*PA_VOLUME_NORM)/100U, NULL, NULL) < 0) {
         pa_log_info("Ringing bell failed, reverting to X11 device bell.");
         XkbForceDeviceBell(pa_x11_wrapper_get_display(w), bne->device, bne->bell_class, bne->bell_id, bne->percent);
     }
diff --git a/src/modules/module-x11-xsmp.c b/src/modules/module-x11-xsmp.c
index 12e100b7..57d182fd 100644
--- a/src/modules/module-x11-xsmp.c
+++ b/src/modules/module-x11-xsmp.c
@@ -181,7 +181,7 @@ int pa__init(pa_module*m) {
     prop_program.name = (char*) SmProgram;
     prop_program.type = (char*) SmARRAY8;
     val_program.value = (char*) PACKAGE_NAME;
-    val_program.length = strlen(val_program.value);
+    val_program.length = (int) strlen(val_program.value);
     prop_program.num_vals = 1;
     prop_program.vals = &val_program;
     prop_list[0] = &prop_program;
@@ -190,7 +190,7 @@ int pa__init(pa_module*m) {
     prop_user.type = (char*) SmARRAY8;
     pa_get_user_name(t, sizeof(t));
     val_user.value = t;
-    val_user.length = strlen(val_user.value);
+    val_user.length = (int) strlen(val_user.value);
     prop_user.num_vals = 1;
     prop_user.vals = &val_user;
     prop_list[1] = &prop_user;
diff --git a/src/modules/module-zeroconf-discover.c b/src/modules/module-zeroconf-discover.c
index a4fbf020..c8087abb 100644
--- a/src/modules/module-zeroconf-discover.c
+++ b/src/modules/module-zeroconf-discover.c
@@ -173,9 +173,9 @@ static void resolver_cb(
                 device = value;
                 value = NULL;
             } else if (strcmp(key, "rate") == 0)
-                ss.rate = atoi(value);
+                ss.rate = (uint32_t) atoi(value);
             else if (strcmp(key, "channels") == 0)
-                ss.channels = atoi(value);
+                ss.channels = (uint8_t) atoi(value);
             else if (strcmp(key, "format") == 0)
                 ss.format = pa_parse_sample_format(value);
             else if (strcmp(key, "channel_map") == 0) {
diff --git a/src/modules/oss-util.c b/src/modules/oss-util.c
index 2791e165..f766030d 100644
--- a/src/modules/oss-util.c
+++ b/src/modules/oss-util.c
@@ -204,10 +204,10 @@ int pa_oss_auto_format(int fd, pa_sample_spec *ss) {
 
     if (ss->channels != channels) {
         pa_log_warn("device doesn't support %i channels, using %i channels.", ss->channels, channels);
-        ss->channels = channels;
+        ss->channels = (uint8_t) channels;
     }
 
-    speed = ss->rate;
+    speed = (int) ss->rate;
     if (ioctl(fd, SNDCTL_DSP_SPEED, &speed) < 0) {
         pa_log("SNDCTL_DSP_SPEED: %s", pa_cstrerror(errno));
         return -1;
@@ -219,7 +219,7 @@ int pa_oss_auto_format(int fd, pa_sample_spec *ss) {
 
         /* If the sample rate deviates too much, we need to resample */
         if (speed < ss->rate*.95 || speed > ss->rate*1.05)
-            ss->rate = speed;
+            ss->rate = (uint32_t) speed;
     }
 
     return 0;
diff --git a/src/modules/rtp/module-rtp-recv.c b/src/modules/rtp/module-rtp-recv.c
index e04e4611..01637892 100644
--- a/src/modules/rtp/module-rtp-recv.c
+++ b/src/modules/rtp/module-rtp-recv.c
@@ -238,15 +238,15 @@ static int rtpoll_work_cb(pa_rtpoll_item *i) {
     else
         delta = j;
 
-    pa_memblockq_seek(s->memblockq, delta * s->rtp_context.frame_size, PA_SEEK_RELATIVE);
+    pa_memblockq_seek(s->memblockq, delta * (int64_t) s->rtp_context.frame_size, PA_SEEK_RELATIVE);
 
     pa_rtclock_get(&now);
 
-    pa_smoother_put(s->smoother, pa_timeval_load(&now), pa_bytes_to_usec(pa_memblockq_get_write_index(s->memblockq), &s->sink_input->sample_spec));
+    pa_smoother_put(s->smoother, pa_timeval_load(&now), pa_bytes_to_usec((uint64_t) pa_memblockq_get_write_index(s->memblockq), &s->sink_input->sample_spec));
 
     if (pa_memblockq_push(s->memblockq, &chunk) < 0) {
         pa_log_warn("Queue overrun");
-        pa_memblockq_seek(s->memblockq, chunk.length, PA_SEEK_RELATIVE);
+        pa_memblockq_seek(s->memblockq, (int64_t) chunk.length, PA_SEEK_RELATIVE);
     }
 
     pa_log("blocks in q: %u", pa_memblockq_get_nblocks(s->memblockq));
@@ -254,9 +254,9 @@ static int rtpoll_work_cb(pa_rtpoll_item *i) {
     pa_memblock_unref(chunk.memblock);
 
     /* The next timestamp we expect */
-    s->offset = s->rtp_context.timestamp + (chunk.length / s->rtp_context.frame_size);
+    s->offset = s->rtp_context.timestamp + (uint32_t) (chunk.length / s->rtp_context.frame_size);
 
-    pa_atomic_store(&s->timestamp, now.tv_sec);
+    pa_atomic_store(&s->timestamp, (int) now.tv_sec);
 
     if (s->last_rate_update + RATE_UPDATE_INTERVAL < pa_timeval_load(&now)) {
         pa_usec_t wi, ri, render_delay, sink_delay = 0, latency, fix;
@@ -265,7 +265,7 @@ static int rtpoll_work_cb(pa_rtpoll_item *i) {
         pa_log("Updating sample rate");
 
         wi = pa_smoother_get(s->smoother, pa_timeval_load(&now));
-        ri = pa_bytes_to_usec(pa_memblockq_get_read_index(s->memblockq), &s->sink_input->sample_spec);
+        ri = pa_bytes_to_usec((uint64_t) pa_memblockq_get_read_index(s->memblockq), &s->sink_input->sample_spec);
 
         if (PA_MSGOBJECT(s->sink_input->sink)->process_msg(PA_MSGOBJECT(s->sink_input->sink), PA_SINK_MESSAGE_GET_LATENCY, &sink_delay, 0, NULL) < 0)
             sink_delay = 0;
@@ -291,7 +291,7 @@ static int rtpoll_work_cb(pa_rtpoll_item *i) {
             fix = latency - s->intended_latency;
 
         /* How many samples is this per second? */
-        fix_samples = fix * s->sink_input->thread_info.sample_spec.rate / RATE_UPDATE_INTERVAL;
+        fix_samples = (unsigned) (fix * (pa_usec_t) s->sink_input->thread_info.sample_spec.rate / (pa_usec_t) RATE_UPDATE_INTERVAL);
 
         /* Check if deviation is in bounds */
         if (fix_samples > s->sink_input->sample_spec.rate*.20)
@@ -431,7 +431,7 @@ static struct session *session_new(struct userdata *u, const pa_sdp_info *sdp_in
     s->smoother = pa_smoother_new(PA_USEC_PER_SEC*5, PA_USEC_PER_SEC*2, TRUE, 10);
     pa_smoother_set_time_offset(s->smoother, pa_timeval_load(&now));
     s->last_rate_update = pa_timeval_load(&now);
-    pa_atomic_store(&s->timestamp, now.tv_sec);
+    pa_atomic_store(&s->timestamp, (int) now.tv_sec);
 
     if ((fd = mcast_socket((const struct sockaddr*) &sdp_info->sa, sdp_info->salen)) < 0)
         goto fail;
@@ -566,7 +566,7 @@ static void sap_event_cb(pa_mainloop_api *m, pa_io_event *e, int fd, pa_io_event
         } else {
             struct timeval now;
             pa_rtclock_get(&now);
-            pa_atomic_store(&s->timestamp, now.tv_sec);
+            pa_atomic_store(&s->timestamp, (int) now.tv_sec);
 
             pa_sdp_info_destroy(&info);
         }
diff --git a/src/modules/rtp/module-rtp-send.c b/src/modules/rtp/module-rtp-send.c
index 1423cbc1..280067a5 100644
--- a/src/modules/rtp/module-rtp-send.c
+++ b/src/modules/rtp/module-rtp-send.c
@@ -171,7 +171,8 @@ int pa__init(pa_module*m) {
     const char *dest;
     uint32_t port = DEFAULT_PORT, mtu;
     uint32_t ttl = DEFAULT_TTL;
-    int af, fd = -1, sap_fd = -1;
+    sa_family_t af;
+    int fd = -1, sap_fd = -1;
     pa_source *s;
     pa_sample_spec ss;
     pa_channel_map cm;
@@ -223,14 +224,14 @@ int pa__init(pa_module*m) {
 
     payload = pa_rtp_payload_from_sample_spec(&ss);
 
-    mtu = pa_frame_align(DEFAULT_MTU, &ss);
+    mtu = (uint32_t) pa_frame_align(DEFAULT_MTU, &ss);
 
     if (pa_modargs_get_value_u32(ma, "mtu", &mtu) < 0 || mtu < 1 || mtu % pa_frame_size(&ss) != 0) {
         pa_log("Invalid MTU.");
         goto fail;
     }
 
-    port = DEFAULT_PORT + ((rand() % 512) << 1);
+    port = DEFAULT_PORT + ((uint32_t) (rand() % 512) << 1);
     if (pa_modargs_get_value_u32(ma, "port", &port) < 0 || port < 1 || port > 0xFFFF) {
         pa_log("port= expects a numerical argument between 1 and 65535.");
         goto fail;
@@ -248,12 +249,12 @@ int pa__init(pa_module*m) {
 
     if (inet_pton(AF_INET6, dest, &sa6.sin6_addr) > 0) {
         sa6.sin6_family = af = AF_INET6;
-        sa6.sin6_port = htons(port);
+        sa6.sin6_port = htons((uint16_t) port);
         sap_sa6 = sa6;
         sap_sa6.sin6_port = htons(SAP_PORT);
     } else if (inet_pton(AF_INET, dest, &sa4.sin_addr) > 0) {
         sa4.sin_family = af = AF_INET;
-        sa4.sin_port = htons(port);
+        sa4.sin_port = htons((uint16_t) port);
         sap_sa4 = sa4;
         sap_sa4.sin_port = htons(SAP_PORT);
     } else {
@@ -266,7 +267,7 @@ int pa__init(pa_module*m) {
         goto fail;
     }
 
-    if (connect(fd, af == AF_INET ? (struct sockaddr*) &sa4 : (struct sockaddr*) &sa6, af == AF_INET ? sizeof(sa4) : sizeof(sa6)) < 0) {
+    if (connect(fd, af == AF_INET ? (struct sockaddr*) &sa4 : (struct sockaddr*) &sa6, (socklen_t) (af == AF_INET ? sizeof(sa4) : sizeof(sa6))) < 0) {
         pa_log("connect() failed: %s", pa_cstrerror(errno));
         goto fail;
     }
@@ -276,7 +277,7 @@ int pa__init(pa_module*m) {
         goto fail;
     }
 
-    if (connect(sap_fd, af == AF_INET ? (struct sockaddr*) &sap_sa4 : (struct sockaddr*) &sap_sa6, af == AF_INET ? sizeof(sap_sa4) : sizeof(sap_sa6)) < 0) {
+    if (connect(sap_fd, af == AF_INET ? (struct sockaddr*) &sap_sa4 : (struct sockaddr*) &sap_sa6, (socklen_t) (af == AF_INET ? sizeof(sap_sa4) : sizeof(sap_sa6))) < 0) {
         pa_log("connect() failed: %s", pa_cstrerror(errno));
         goto fail;
     }
@@ -354,7 +355,7 @@ int pa__init(pa_module*m) {
     p = pa_sdp_build(af,
                      af == AF_INET ? (void*) &((struct sockaddr_in*) &sa_dst)->sin_addr : (void*) &((struct sockaddr_in6*) &sa_dst)->sin6_addr,
                      af == AF_INET ? (void*) &sa4.sin_addr : (void*) &sa6.sin6_addr,
-                     n, port, payload, &ss);
+                     n, (uint16_t) port, payload, &ss);
 
     pa_xfree(n);
 
diff --git a/src/modules/rtp/rtp.c b/src/modules/rtp/rtp.c
index 5a33ebc2..88351010 100644
--- a/src/modules/rtp/rtp.c
+++ b/src/modules/rtp/rtp.c
@@ -50,7 +50,7 @@ pa_rtp_context* pa_rtp_context_init_send(pa_rtp_context *c, int fd, uint32_t ssr
     c->sequence = (uint16_t) (rand()*rand());
     c->timestamp = 0;
     c->ssrc = ssrc ? ssrc : (uint32_t) (rand()*rand());
-    c->payload = payload & 127;
+    c->payload = (uint8_t) (payload & 127U);
     c->frame_size = frame_size;
 
     pa_memchunk_reset(&c->memchunk);
@@ -99,7 +99,8 @@ int pa_rtp_send(pa_rtp_context *c, size_t size, pa_memblockq *q) {
         if (r < 0 || n >= size || iov_idx >= MAX_IOVECS) {
             uint32_t header[3];
             struct msghdr m;
-            int k, i;
+            ssize_t k;
+            int i;
 
             if (n > 0) {
                 header[0] = htonl(((uint32_t) 2 << 30) | ((uint32_t) c->payload << 16) | ((uint32_t) c->sequence));
@@ -112,7 +113,7 @@ int pa_rtp_send(pa_rtp_context *c, size_t size, pa_memblockq *q) {
                 m.msg_name = NULL;
                 m.msg_namelen = 0;
                 m.msg_iov = iov;
-                m.msg_iovlen = iov_idx;
+                m.msg_iovlen = (size_t) iov_idx;
                 m.msg_control = NULL;
                 m.msg_controllen = 0;
                 m.msg_flags = 0;
@@ -128,7 +129,7 @@ int pa_rtp_send(pa_rtp_context *c, size_t size, pa_memblockq *q) {
             } else
                 k = 0;
 
-            c->timestamp += n/c->frame_size;
+            c->timestamp += (unsigned) (n/c->frame_size);
 
             if (k < 0) {
                 if (errno != EAGAIN && errno != EINTR) /* If the queue is full, just ignore it */
@@ -162,7 +163,7 @@ int pa_rtp_recv(pa_rtp_context *c, pa_memchunk *chunk, pa_mempool *pool) {
     struct msghdr m;
     struct iovec iov;
     uint32_t header;
-    int cc;
+    unsigned cc;
     ssize_t r;
 
     pa_assert(c);
@@ -197,7 +198,7 @@ int pa_rtp_recv(pa_rtp_context *c, pa_memchunk *chunk, pa_mempool *pool) {
     chunk->index = c->memchunk.index;
 
     iov.iov_base = (uint8_t*) pa_memblock_acquire(chunk->memblock) + chunk->index;
-    iov.iov_len = size;
+    iov.iov_len = (size_t) size;
 
     m.msg_name = NULL;
     m.msg_namelen = 0;
@@ -246,16 +247,16 @@ int pa_rtp_recv(pa_rtp_context *c, pa_memchunk *chunk, pa_mempool *pool) {
     }
 
     cc = (header >> 24) & 0xF;
-    c->payload = (header >> 16) & 127;
-    c->sequence = header & 0xFFFF;
+    c->payload = (uint8_t) ((header >> 16) & 127U);
+    c->sequence = (uint16_t) (header & 0xFFFFU);
 
-    if (12 + cc*4 > size) {
+    if (12 + cc*4 > (unsigned) size) {
         pa_log_warn("RTP packet too short. (CSRC)");
         goto fail;
     }
 
     chunk->index += 12 + cc*4;
-    chunk->length = size - 12 + cc*4;
+    chunk->length = (size_t) size - 12 + cc*4;
 
     if (chunk->length % c->frame_size != 0) {
         pa_log_warn("Bad RTP packet size.");
diff --git a/src/modules/rtp/sap.c b/src/modules/rtp/sap.c
index 5d9b58fa..b0c95aa5 100644
--- a/src/modules/rtp/sap.c
+++ b/src/modules/rtp/sap.c
@@ -76,7 +76,7 @@ int pa_sap_send(pa_sap_context *c, pa_bool_t goodbye) {
     socklen_t salen = sizeof(sa_buf);
     struct iovec iov[4];
     struct msghdr m;
-    int k;
+    ssize_t k;
 
     if (getsockname(c->fd, sa, &salen) < 0) {
         pa_log("getsockname() failed: %s\n", pa_cstrerror(errno));
@@ -94,7 +94,7 @@ int pa_sap_send(pa_sap_context *c, pa_bool_t goodbye) {
     iov[0].iov_len = sizeof(header);
 
     iov[1].iov_base = sa->sa_family == AF_INET ? (void*) &((struct sockaddr_in*) sa)->sin_addr : (void*) &((struct sockaddr_in6*) sa)->sin6_addr;
-    iov[1].iov_len = sa->sa_family == AF_INET ? 4 : 16;
+    iov[1].iov_len = sa->sa_family == AF_INET ? 4U : 16U;
 
     iov[2].iov_base = (char*) MIME_TYPE;
     iov[2].iov_len = sizeof(MIME_TYPE);
@@ -113,7 +113,7 @@ int pa_sap_send(pa_sap_context *c, pa_bool_t goodbye) {
     if ((k = sendmsg(c->fd, &m, MSG_DONTWAIT)) < 0)
         pa_log_warn("sendmsg() failed: %s\n", pa_cstrerror(errno));
 
-    return k;
+    return (int) k;
 }
 
 pa_sap_context* pa_sap_context_init_recv(pa_sap_context *c, int fd) {
@@ -128,10 +128,10 @@ pa_sap_context* pa_sap_context_init_recv(pa_sap_context *c, int fd) {
 int pa_sap_recv(pa_sap_context *c, pa_bool_t *goodbye) {
     struct msghdr m;
     struct iovec iov;
-    int size, k;
+    int size;
     char *buf = NULL, *e;
     uint32_t header;
-    int six, ac;
+    unsigned six, ac, k;
     ssize_t r;
 
     pa_assert(c);
@@ -142,11 +142,11 @@ int pa_sap_recv(pa_sap_context *c, pa_bool_t *goodbye) {
         goto fail;
     }
 
-    buf = pa_xnew(char, size+1);
+    buf = pa_xnew(char, (unsigned) size+1);
     buf[size] = 0;
 
     iov.iov_base = buf;
-    iov.iov_len = size;
+    iov.iov_len = (size_t) size;
 
     m.msg_name = NULL;
     m.msg_namelen = 0;
@@ -184,21 +184,21 @@ int pa_sap_recv(pa_sap_context *c, pa_bool_t *goodbye) {
         goto fail;
     }
 
-    six = (header >> 28) & 1;
-    ac = (header >> 16) & 0xFF;
+    six = (header >> 28) & 1U;
+    ac = (header >> 16) & 0xFFU;
 
-    k = 4 + (six ? 16 : 4) + ac*4;
-    if (size < k) {
+    k = 4 + (six ? 16U : 4U) + ac*4U;
+    if ((unsigned) size < k) {
         pa_log_warn("SAP packet too short (AD).");
         goto fail;
     }
 
     e = buf + k;
-    size -= k;
+    size -= (int) k;
 
     if ((unsigned) size >= sizeof(MIME_TYPE) && !strcmp(e, MIME_TYPE)) {
         e += sizeof(MIME_TYPE);
-        size -= sizeof(MIME_TYPE);
+        size -= (int) sizeof(MIME_TYPE);
     } else if ((unsigned) size < sizeof(PA_SDP_HEADER)-1 || strncmp(e, PA_SDP_HEADER, sizeof(PA_SDP_HEADER)-1)) {
         pa_log_warn("Invalid SDP header.");
         goto fail;
@@ -207,7 +207,7 @@ int pa_sap_recv(pa_sap_context *c, pa_bool_t *goodbye) {
     if (c->sdp_data)
         pa_xfree(c->sdp_data);
 
-    c->sdp_data = pa_xstrndup(e, size);
+    c->sdp_data = pa_xstrndup(e, (unsigned) size);
     pa_xfree(buf);
 
     *goodbye = !!((header >> 26) & 1);
diff --git a/src/modules/rtp/sdp.c b/src/modules/rtp/sdp.c
index cef90433..59989e1a 100644
--- a/src/modules/rtp/sdp.c
+++ b/src/modules/rtp/sdp.c
@@ -55,7 +55,7 @@ char *pa_sdp_build(int af, const void *src, const void *dst, const char *name, u
     if (!(u = pa_get_user_name(un, sizeof(un))))
         u = "-";
 
-    ntp = time(NULL) + 2208988800U;
+    ntp = (uint32_t) time(NULL) + 2208988800U;
 
     pa_assert_se(a = inet_ntop(af, src, buf_src, sizeof(buf_src)));
     pa_assert_se(a = inet_ntop(af, dst, buf_dst, sizeof(buf_dst)));
@@ -99,10 +99,10 @@ static pa_sample_spec *parse_sdp_sample_spec(pa_sample_spec *ss, char *c) {
         return NULL;
 
     if (sscanf(c, "%u/%u", &rate, &channels) == 2) {
-        ss->rate = rate;
-        ss->channels = channels;
+        ss->rate = (uint32_t) rate;
+        ss->channels = (uint8_t) channels;
     } else if (sscanf(c, "%u", &rate) == 2) {
-        ss->rate = rate;
+        ss->rate = (uint32_t) rate;
         ss->channels = 1;
     } else
         return NULL;
diff --git a/src/pulse/channelmap.c b/src/pulse/channelmap.c
index db0c4b3f..1766e729 100644
--- a/src/pulse/channelmap.c
+++ b/src/pulse/channelmap.c
@@ -201,7 +201,7 @@ pa_channel_map* pa_channel_map_init_auto(pa_channel_map *m, unsigned channels, p
 
     pa_channel_map_init(m);
 
-    m->channels = channels;
+    m->channels = (uint8_t) channels;
 
     switch (def) {
         case PA_CHANNEL_MAP_AIFF:
@@ -415,7 +415,7 @@ pa_channel_map* pa_channel_map_init_extend(pa_channel_map *m, unsigned channels,
                 i++;
             }
 
-            m->channels = channels;
+            m->channels = (uint8_t) channels;
 
             return m;
         }
@@ -460,7 +460,7 @@ int pa_channel_map_equal(const pa_channel_map *a, const pa_channel_map *b) {
 
 char* pa_channel_map_snprint(char *s, size_t l, const pa_channel_map *map) {
     unsigned channel;
-    int first = 1;
+    pa_bool_t first = TRUE;
     char *e;
 
     pa_assert(s);
@@ -475,7 +475,7 @@ char* pa_channel_map_snprint(char *s, size_t l, const pa_channel_map *map) {
                       pa_channel_position_to_string(map->map[channel]));
 
         e = strchr(e, 0);
-        first = 0;
+        first = FALSE;
     }
 
     return s;
diff --git a/src/pulse/context.c b/src/pulse/context.c
index ed6415b0..99a47a18 100644
--- a/src/pulse/context.c
+++ b/src/pulse/context.c
@@ -413,11 +413,11 @@ int pa_context_handle_error(pa_context *c, uint32_t command, pa_tagstruct *t, pa
         err = PA_ERR_UNKNOWN;
 
     if (fail) {
-        pa_context_fail(c, err);
+        pa_context_fail(c, (int) err);
         return -1;
     }
 
-    pa_context_set_error(c, err);
+    pa_context_set_error(c, (int) err);
 
     return 0;
 }
@@ -788,7 +788,7 @@ static void autospawn_cb(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_
     pa_assert(a);
     pa_assert(e);
     pa_assert(fd >= 0);
-    pa_assert(events = PA_IO_EVENT_INPUT);
+    pa_assert(events == PA_IO_EVENT_INPUT);
     pa_assert(c);
     pa_assert(e == c->autospawn_event);
     pa_assert(fd == c->autospawn_fd);
diff --git a/src/pulse/glib-mainloop.c b/src/pulse/glib-mainloop.c
index 392133f0..5f5dc494 100644
--- a/src/pulse/glib-mainloop.c
+++ b/src/pulse/glib-mainloop.c
@@ -195,11 +195,11 @@ static void cleanup_defer_events(pa_glib_mainloop *g, int force) {
 }
 
 static gushort map_flags_to_glib(pa_io_event_flags_t flags) {
-    return
-        (flags & PA_IO_EVENT_INPUT ? G_IO_IN : 0) |
-        (flags & PA_IO_EVENT_OUTPUT ? G_IO_OUT : 0) |
-        (flags & PA_IO_EVENT_ERROR ? G_IO_ERR : 0) |
-        (flags & PA_IO_EVENT_HANGUP ? G_IO_HUP : 0);
+    return (gushort)
+        ((flags & PA_IO_EVENT_INPUT ? G_IO_IN : 0) |
+         (flags & PA_IO_EVENT_OUTPUT ? G_IO_OUT : 0) |
+         (flags & PA_IO_EVENT_ERROR ? G_IO_ERR : 0) |
+         (flags & PA_IO_EVENT_HANGUP ? G_IO_HUP : 0));
 }
 
 static pa_io_event_flags_t map_flags_from_glib(gushort flags) {
diff --git a/src/pulse/internal.h b/src/pulse/internal.h
index 26fb04d4..9167bf1b 100644
--- a/src/pulse/internal.h
+++ b/src/pulse/internal.h
@@ -64,7 +64,7 @@ struct pa_context {
     uint32_t version;
     uint32_t ctag;
     uint32_t csyncid;
-    uint32_t error;
+    int error;
     pa_context_state_t state;
 
     pa_context_notify_cb_t state_callback;
diff --git a/src/pulse/mainloop.c b/src/pulse/mainloop.c
index 5823e280..60e5d1ff 100644
--- a/src/pulse/mainloop.c
+++ b/src/pulse/mainloop.c
@@ -57,7 +57,7 @@
 
 struct pa_io_event {
     pa_mainloop *mainloop;
-    int dead;
+    pa_bool_t dead:1;
 
     int fd;
     pa_io_event_flags_t events;
@@ -72,9 +72,9 @@ struct pa_io_event {
 
 struct pa_time_event {
     pa_mainloop *mainloop;
-    int dead;
+    pa_bool_t dead:1;
 
-    int enabled;
+    pa_bool_t enabled:1;
     struct timeval timeval;
 
     pa_time_event_cb_t callback;
@@ -86,9 +86,9 @@ struct pa_time_event {
 
 struct pa_defer_event {
     pa_mainloop *mainloop;
-    int dead;
+    pa_bool_t dead:1;
 
-    int enabled;
+    pa_bool_t enabled:1;
 
     pa_defer_event_cb_t callback;
     void *userdata;
@@ -102,22 +102,24 @@ struct pa_mainloop {
     PA_LLIST_HEAD(pa_time_event, time_events);
     PA_LLIST_HEAD(pa_defer_event, defer_events);
 
-    int n_enabled_defer_events, n_enabled_time_events, n_io_events;
-    int io_events_please_scan, time_events_please_scan, defer_events_please_scan;
+    unsigned n_enabled_defer_events, n_enabled_time_events, n_io_events;
+    unsigned io_events_please_scan, time_events_please_scan, defer_events_please_scan;
 
+    pa_bool_t rebuild_pollfds:1;
     struct pollfd *pollfds;
     unsigned max_pollfds, n_pollfds;
-    int rebuild_pollfds;
 
     int prepared_timeout;
     pa_time_event *cached_next_time_event;
 
-    int quit, retval;
     pa_mainloop_api api;
 
+    int retval;
+    pa_bool_t quit:1;
+
+    pa_bool_t wakeup_requested:1;
     int wakeup_pipe[2];
     int wakeup_pipe_type;
-    int wakeup_requested;
 
     enum {
         STATE_PASSIVE,
@@ -133,11 +135,11 @@ struct pa_mainloop {
 };
 
 static short map_flags_to_libc(pa_io_event_flags_t flags) {
-    return
-        (flags & PA_IO_EVENT_INPUT ? POLLIN : 0) |
-        (flags & PA_IO_EVENT_OUTPUT ? POLLOUT : 0) |
-        (flags & PA_IO_EVENT_ERROR ? POLLERR : 0) |
-        (flags & PA_IO_EVENT_HANGUP ? POLLHUP : 0);
+    return (short)
+        ((flags & PA_IO_EVENT_INPUT ? POLLIN : 0) |
+         (flags & PA_IO_EVENT_OUTPUT ? POLLOUT : 0) |
+         (flags & PA_IO_EVENT_ERROR ? POLLERR : 0) |
+         (flags & PA_IO_EVENT_HANGUP ? POLLHUP : 0));
 }
 
 static pa_io_event_flags_t map_flags_from_libc(short flags) {
@@ -169,7 +171,7 @@ static pa_io_event* mainloop_io_new(
 
     e = pa_xnew(pa_io_event, 1);
     e->mainloop = m;
-    e->dead = 0;
+    e->dead = FALSE;
 
     e->fd = fd;
     e->events = events;
@@ -194,13 +196,13 @@ static pa_io_event* mainloop_io_new(
                     SELECT_TYPE_ARG5 &tv) == -1) &&
              (WSAGetLastError() == WSAENOTSOCK)) {
             pa_log_warn("Cannot monitor non-socket file descriptors.");
-            e->dead = 1;
+            e->dead = TRUE;
         }
     }
 #endif
 
     PA_LLIST_PREPEND(pa_io_event, m->io_events, e);
-    m->rebuild_pollfds = 1;
+    m->rebuild_pollfds = TRUE;
     m->n_io_events ++;
 
     pa_mainloop_wakeup(m);
@@ -220,7 +222,7 @@ static void mainloop_io_enable(pa_io_event *e, pa_io_event_flags_t events) {
     if (e->pollfd)
         e->pollfd->events = map_flags_to_libc(events);
     else
-        e->mainloop->rebuild_pollfds = 1;
+        e->mainloop->rebuild_pollfds = TRUE;
 
     pa_mainloop_wakeup(e->mainloop);
 }
@@ -229,11 +231,11 @@ static void mainloop_io_free(pa_io_event *e) {
     pa_assert(e);
     pa_assert(!e->dead);
 
-    e->dead = 1;
+    e->dead = TRUE;
     e->mainloop->io_events_please_scan ++;
 
     e->mainloop->n_io_events --;
-    e->mainloop->rebuild_pollfds = 1;
+    e->mainloop->rebuild_pollfds = TRUE;
 
     pa_mainloop_wakeup(e->mainloop);
 }
@@ -262,9 +264,9 @@ static pa_defer_event* mainloop_defer_new(
 
     e = pa_xnew(pa_defer_event, 1);
     e->mainloop = m;
-    e->dead = 0;
+    e->dead = FALSE;
 
-    e->enabled = 1;
+    e->enabled = TRUE;
     m->n_enabled_defer_events++;
 
     e->callback = callback;
@@ -297,13 +299,13 @@ static void mainloop_defer_free(pa_defer_event *e) {
     pa_assert(e);
     pa_assert(!e->dead);
 
-    e->dead = 1;
+    e->dead = TRUE;
     e->mainloop->defer_events_please_scan ++;
 
     if (e->enabled) {
         pa_assert(e->mainloop->n_enabled_defer_events > 0);
         e->mainloop->n_enabled_defer_events--;
-        e->enabled = 0;
+        e->enabled = FALSE;
     }
 }
 
@@ -333,7 +335,7 @@ static pa_time_event* mainloop_time_new(
 
     e = pa_xnew(pa_time_event, 1);
     e->mainloop = m;
-    e->dead = 0;
+    e->dead = FALSE;
 
     if ((e->enabled = !!tv)) {
         e->timeval = *tv;
@@ -388,13 +390,13 @@ static void mainloop_time_free(pa_time_event *e) {
     pa_assert(e);
     pa_assert(!e->dead);
 
-    e->dead = 1;
+    e->dead = TRUE;
     e->mainloop->time_events_please_scan ++;
 
     if (e->enabled) {
         pa_assert(e->mainloop->n_enabled_time_events > 0);
         e->mainloop->n_enabled_time_events--;
-        e->enabled = 0;
+        e->enabled = FALSE;
     }
 
     if (e->mainloop->cached_next_time_event == e)
@@ -462,7 +464,7 @@ pa_mainloop *pa_mainloop_new(void) {
     pa_make_fd_nonblock(m->wakeup_pipe[1]);
     pa_make_fd_cloexec(m->wakeup_pipe[0]);
     pa_make_fd_cloexec(m->wakeup_pipe[1]);
-    m->wakeup_requested = 0;
+    m->wakeup_requested = FALSE;
 
     PA_LLIST_HEAD_INIT(pa_io_event, m->io_events);
     PA_LLIST_HEAD_INIT(pa_time_event, m->time_events);
@@ -476,9 +478,10 @@ pa_mainloop *pa_mainloop_new(void) {
 
     m->pollfds = NULL;
     m->max_pollfds = m->n_pollfds = 0;
-    m->rebuild_pollfds = 1;
+    m->rebuild_pollfds = TRUE;
 
-    m->quit = m->retval = 0;
+    m->quit = FALSE;
+    m->retval = 0;
 
     m->api = vtable;
     m->api.userdata = m;
@@ -492,7 +495,7 @@ pa_mainloop *pa_mainloop_new(void) {
     return m;
 }
 
-static void cleanup_io_events(pa_mainloop *m, int force) {
+static void cleanup_io_events(pa_mainloop *m, pa_bool_t force) {
     pa_io_event *e;
 
     e = m->io_events;
@@ -515,7 +518,7 @@ static void cleanup_io_events(pa_mainloop *m, int force) {
 
             pa_xfree(e);
 
-            m->rebuild_pollfds = 1;
+            m->rebuild_pollfds = TRUE;
         }
 
         e = n;
@@ -524,7 +527,7 @@ static void cleanup_io_events(pa_mainloop *m, int force) {
     pa_assert(m->io_events_please_scan == 0);
 }
 
-static void cleanup_time_events(pa_mainloop *m, int force) {
+static void cleanup_time_events(pa_mainloop *m, pa_bool_t force) {
     pa_time_event *e;
 
     e = m->time_events;
@@ -545,7 +548,7 @@ static void cleanup_time_events(pa_mainloop *m, int force) {
             if (!e->dead && e->enabled) {
                 pa_assert(m->n_enabled_time_events > 0);
                 m->n_enabled_time_events--;
-                e->enabled = 0;
+                e->enabled = FALSE;
             }
 
             if (e->destroy_callback)
@@ -560,7 +563,7 @@ static void cleanup_time_events(pa_mainloop *m, int force) {
     pa_assert(m->time_events_please_scan == 0);
 }
 
-static void cleanup_defer_events(pa_mainloop *m, int force) {
+static void cleanup_defer_events(pa_mainloop *m, pa_bool_t force) {
     pa_defer_event *e;
 
     e = m->defer_events;
@@ -581,7 +584,7 @@ static void cleanup_defer_events(pa_mainloop *m, int force) {
             if (!e->dead && e->enabled) {
                 pa_assert(m->n_enabled_defer_events > 0);
                 m->n_enabled_defer_events--;
-                e->enabled = 0;
+                e->enabled = FALSE;
             }
 
             if (e->destroy_callback)
@@ -600,9 +603,9 @@ static void cleanup_defer_events(pa_mainloop *m, int force) {
 void pa_mainloop_free(pa_mainloop* m) {
     pa_assert(m);
 
-    cleanup_io_events(m, 1);
-    cleanup_defer_events(m, 1);
-    cleanup_time_events(m, 1);
+    cleanup_io_events(m, TRUE);
+    cleanup_defer_events(m, TRUE);
+    cleanup_time_events(m, TRUE);
 
     pa_xfree(m->pollfds);
 
@@ -615,13 +618,13 @@ static void scan_dead(pa_mainloop *m) {
     pa_assert(m);
 
     if (m->io_events_please_scan)
-        cleanup_io_events(m, 0);
+        cleanup_io_events(m, FALSE);
 
     if (m->time_events_please_scan)
-        cleanup_time_events(m, 0);
+        cleanup_time_events(m, FALSE);
 
     if (m->defer_events_please_scan)
-        cleanup_defer_events(m, 0);
+        cleanup_defer_events(m, FALSE);
 }
 
 static void rebuild_pollfds(pa_mainloop *m) {
@@ -662,7 +665,7 @@ static void rebuild_pollfds(pa_mainloop *m) {
         m->n_pollfds++;
     }
 
-    m->rebuild_pollfds = 0;
+    m->rebuild_pollfds = FALSE;
 }
 
 static int dispatch_pollfds(pa_mainloop *m) {
@@ -948,7 +951,7 @@ int pa_mainloop_run(pa_mainloop *m, int *retval) {
 void pa_mainloop_quit(pa_mainloop *m, int retval) {
     pa_assert(m);
 
-    m->quit = 1;
+    m->quit = TRUE;
     m->retval = retval;
     pa_mainloop_wakeup(m);
 }
diff --git a/src/pulse/proplist.c b/src/pulse/proplist.c
index 9e0549ea..93bc0034 100644
--- a/src/pulse/proplist.c
+++ b/src/pulse/proplist.c
@@ -280,7 +280,7 @@ char *pa_proplist_to_string(pa_proplist *p) {
             char *c;
 
             pa_assert_se(pa_proplist_get(p, key, &value, &nbytes) == 0);
-            c = pa_xnew(char, nbytes*2+1);
+            c = pa_xmalloc(nbytes*2+1);
             pa_hexstr((const uint8_t*) value, nbytes, c, nbytes*2+1);
 
             pa_strbuf_printf(buf, "%s = hex:%s\n", key, c);
diff --git a/src/pulse/scache.c b/src/pulse/scache.c
index 5e31e7af..fd3b9876 100644
--- a/src/pulse/scache.c
+++ b/src/pulse/scache.c
@@ -47,6 +47,7 @@ int pa_stream_connect_upload(pa_stream *s, size_t length) {
 
     PA_CHECK_VALIDITY(s->context, s->state == PA_STREAM_UNCONNECTED, PA_ERR_BADSTATE);
     PA_CHECK_VALIDITY(s->context, length > 0, PA_ERR_INVALID);
+    PA_CHECK_VALIDITY(s->context, length == (size_t) (uint32_t) length, PA_ERR_INVALID);
 
     if (!(name = pa_proplist_gets(s->proplist, PA_PROP_EVENT_ID)))
         name = pa_proplist_gets(s->proplist, PA_PROP_MEDIA_NAME);
@@ -63,7 +64,7 @@ int pa_stream_connect_upload(pa_stream *s, size_t length) {
     pa_tagstruct_puts(t, name);
     pa_tagstruct_put_sample_spec(t, &s->sample_spec);
     pa_tagstruct_put_channel_map(t, &s->channel_map);
-    pa_tagstruct_putu32(t, length);
+    pa_tagstruct_putu32(t, (uint32_t) length);
 
     if (s->context->version >= 13) {
         pa_init_proplist(s->proplist);
diff --git a/src/pulse/stream.c b/src/pulse/stream.c
index 6769fc09..536a82ce 100644
--- a/src/pulse/stream.c
+++ b/src/pulse/stream.c
@@ -124,7 +124,7 @@ pa_stream *pa_stream_new_with_proplist(
      * what older PA versions provided. */
 
     s->buffer_attr.maxlength = (uint32_t) -1;
-    s->buffer_attr.tlength = pa_usec_to_bytes(250*PA_USEC_PER_MSEC, ss); /* 250ms of buffering */
+    s->buffer_attr.tlength = (uint32_t) pa_usec_to_bytes(250*PA_USEC_PER_MSEC, ss); /* 250ms of buffering */
     s->buffer_attr.minreq = (uint32_t) -1;
     s->buffer_attr.prebuf = (uint32_t) -1;
     s->buffer_attr.fragsize = (uint32_t) -1;
@@ -694,7 +694,7 @@ static void create_stream_complete(pa_stream *s) {
     if (s->flags & PA_STREAM_AUTO_TIMING_UPDATE) {
         struct timeval tv;
         pa_gettimeofday(&tv);
-        tv.tv_usec += LATENCY_IPOL_INTERVAL_USEC; /* every 100 ms */
+        tv.tv_usec += (suseconds_t) LATENCY_IPOL_INTERVAL_USEC; /* every 100 ms */
         pa_assert(!s->auto_timing_update_event);
         s->auto_timing_update_event = s->mainloop->time_new(s->mainloop, &tv, &auto_timing_update_callback, s);
 
@@ -722,7 +722,7 @@ static void automatic_buffer_attr(pa_stream *s, pa_buffer_attr *attr, const pa_s
         attr->maxlength = 4*1024*1024; /* 4MB is the maximum queue length PulseAudio <= 0.9.9 supported. */
 
     if (attr->tlength == (uint32_t) -1)
-        attr->tlength = pa_usec_to_bytes(250*PA_USEC_PER_MSEC, ss); /* 250ms of buffering */
+        attr->tlength = (uint32_t) pa_usec_to_bytes(250*PA_USEC_PER_MSEC, ss); /* 250ms of buffering */
 
     if (attr->minreq == (uint32_t) -1)
         attr->minreq = (attr->tlength)/5; /* Ask for more data when there are only 200ms left in the playback buffer */
@@ -931,7 +931,7 @@ static int create_stream(
 
     t = pa_tagstruct_command(
             s->context,
-            s->direction == PA_STREAM_PLAYBACK ? PA_COMMAND_CREATE_PLAYBACK_STREAM : PA_COMMAND_CREATE_RECORD_STREAM,
+            (uint32_t) (s->direction == PA_STREAM_PLAYBACK ? PA_COMMAND_CREATE_PLAYBACK_STREAM : PA_COMMAND_CREATE_RECORD_STREAM),
             &tag);
 
     if (s->context->version < 13)
@@ -1105,7 +1105,7 @@ int pa_stream_write(
         free_cb((void*) data);
 
     if (length < s->requested_bytes)
-        s->requested_bytes -= length;
+        s->requested_bytes -= (uint32_t) length;
     else
         s->requested_bytes = 0;
 
@@ -1119,10 +1119,10 @@ int pa_stream_write(
             if (seek == PA_SEEK_ABSOLUTE) {
                 s->write_index_corrections[s->current_write_index_correction].corrupt = FALSE;
                 s->write_index_corrections[s->current_write_index_correction].absolute = TRUE;
-                s->write_index_corrections[s->current_write_index_correction].value = offset + length;
+                s->write_index_corrections[s->current_write_index_correction].value = offset + (int64_t) length;
             } else if (seek == PA_SEEK_RELATIVE) {
                 if (!s->write_index_corrections[s->current_write_index_correction].corrupt)
-                    s->write_index_corrections[s->current_write_index_correction].value += offset + length;
+                    s->write_index_corrections[s->current_write_index_correction].value += offset + (int64_t) length;
             } else
                 s->write_index_corrections[s->current_write_index_correction].corrupt = TRUE;
         }
@@ -1132,10 +1132,10 @@ int pa_stream_write(
 
             if (seek == PA_SEEK_ABSOLUTE) {
                 s->timing_info.write_index_corrupt = FALSE;
-                s->timing_info.write_index = offset + length;
+                s->timing_info.write_index = offset + (int64_t) length;
             } else if (seek == PA_SEEK_RELATIVE) {
                 if (!s->timing_info.write_index_corrupt)
-                    s->timing_info.write_index += offset + length;
+                    s->timing_info.write_index += offset + (int64_t) length;
             } else
                 s->timing_info.write_index_corrupt = TRUE;
         }
@@ -1185,7 +1185,7 @@ int pa_stream_drop(pa_stream *s) {
 
     /* Fix the simulated local read index */
     if (s->timing_info_valid && !s->timing_info.read_index_corrupt)
-        s->timing_info.read_index += s->peek_memchunk.length;
+        s->timing_info.read_index += (int64_t) s->peek_memchunk.length;
 
     pa_assert(s->peek_data);
     pa_memblock_release(s->peek_memchunk.memblock);
@@ -1354,7 +1354,7 @@ static void stream_get_timing_info_callback(pa_pdispatch *pd, uint32_t command,
         i->read_index_corrupt = FALSE;
 
         i->playing = (int) playing;
-        i->since_underrun = playing ? playing_for : underrun_for;
+        i->since_underrun = (int64_t) (playing ? playing_for : underrun_for);
 
         pa_gettimeofday(&now);
 
@@ -1432,7 +1432,7 @@ static void stream_get_timing_info_callback(pa_pdispatch *pd, uint32_t command,
             /* Read index correction */
 
             if (!i->read_index_corrupt)
-                i->read_index -= pa_memblockq_get_length(o->stream->record_memblockq);
+                i->read_index -= (int64_t) pa_memblockq_get_length(o->stream->record_memblockq);
         }
 
         /* Update smoother */
@@ -1449,7 +1449,7 @@ static void stream_get_timing_info_callback(pa_pdispatch *pd, uint32_t command,
                  * speakers. Since we follow that timing here, we need
                  * to try to fix this up */
 
-                su = pa_bytes_to_usec(i->since_underrun, &o->stream->sample_spec);
+                su = pa_bytes_to_usec((uint64_t) i->since_underrun, &o->stream->sample_spec);
 
                 if (su < i->sink_usec)
                     x += i->sink_usec - su;
@@ -1508,7 +1508,7 @@ pa_operation* pa_stream_update_timing_info(pa_stream *s, pa_stream_success_cb_t
 
     t = pa_tagstruct_command(
             s->context,
-            s->direction == PA_STREAM_PLAYBACK ? PA_COMMAND_GET_PLAYBACK_LATENCY : PA_COMMAND_GET_RECORD_LATENCY,
+            (uint32_t) (s->direction == PA_STREAM_PLAYBACK ? PA_COMMAND_GET_PLAYBACK_LATENCY : PA_COMMAND_GET_RECORD_LATENCY),
             &tag);
     pa_tagstruct_putu32(t, s->channel);
     pa_tagstruct_put_timeval(t, pa_gettimeofday(&now));
@@ -1571,8 +1571,8 @@ int pa_stream_disconnect(pa_stream *s) {
 
     t = pa_tagstruct_command(
             s->context,
-            s->direction == PA_STREAM_PLAYBACK ? PA_COMMAND_DELETE_PLAYBACK_STREAM :
-            (s->direction == PA_STREAM_RECORD ? PA_COMMAND_DELETE_RECORD_STREAM : PA_COMMAND_DELETE_UPLOAD_STREAM),
+            (uint32_t) (s->direction == PA_STREAM_PLAYBACK ? PA_COMMAND_DELETE_PLAYBACK_STREAM :
+                        (s->direction == PA_STREAM_RECORD ? PA_COMMAND_DELETE_RECORD_STREAM : PA_COMMAND_DELETE_UPLOAD_STREAM)),
             &tag);
     pa_tagstruct_putu32(t, s->channel);
     pa_pstream_send_tagstruct(s->context->pstream, t);
@@ -1729,7 +1729,7 @@ pa_operation* pa_stream_cork(pa_stream *s, int b, pa_stream_success_cb_t cb, voi
 
     t = pa_tagstruct_command(
             s->context,
-            s->direction == PA_STREAM_PLAYBACK ? PA_COMMAND_CORK_PLAYBACK_STREAM : PA_COMMAND_CORK_RECORD_STREAM,
+            (uint32_t) (s->direction == PA_STREAM_PLAYBACK ? PA_COMMAND_CORK_PLAYBACK_STREAM : PA_COMMAND_CORK_RECORD_STREAM),
             &tag);
     pa_tagstruct_putu32(t, s->channel);
     pa_tagstruct_put_boolean(t, !!b);
@@ -1774,7 +1774,7 @@ pa_operation* pa_stream_flush(pa_stream *s, pa_stream_success_cb_t cb, void *use
     PA_CHECK_VALIDITY_RETURN_NULL(s->context, s->state == PA_STREAM_READY, PA_ERR_BADSTATE);
     PA_CHECK_VALIDITY_RETURN_NULL(s->context, s->direction != PA_STREAM_UPLOAD, PA_ERR_BADSTATE);
 
-    if (!(o = stream_send_simple_command(s, s->direction == PA_STREAM_PLAYBACK ? PA_COMMAND_FLUSH_PLAYBACK_STREAM : PA_COMMAND_FLUSH_RECORD_STREAM, cb, userdata)))
+    if (!(o = stream_send_simple_command(s, (uint32_t) (s->direction == PA_STREAM_PLAYBACK ? PA_COMMAND_FLUSH_PLAYBACK_STREAM : PA_COMMAND_FLUSH_RECORD_STREAM), cb, userdata)))
         return NULL;
 
     if (s->direction == PA_STREAM_PLAYBACK) {
@@ -1860,7 +1860,7 @@ pa_operation* pa_stream_set_name(pa_stream *s, const char *name, pa_stream_succe
         o = pa_operation_new(s->context, s, (pa_operation_cb_t) cb, userdata);
         t = pa_tagstruct_command(
                 s->context,
-                s->direction == PA_STREAM_RECORD ? PA_COMMAND_SET_RECORD_STREAM_NAME : PA_COMMAND_SET_PLAYBACK_STREAM_NAME,
+                (uint32_t) (s->direction == PA_STREAM_RECORD ? PA_COMMAND_SET_RECORD_STREAM_NAME : PA_COMMAND_SET_PLAYBACK_STREAM_NAME),
                 &tag);
         pa_tagstruct_putu32(t, s->channel);
         pa_tagstruct_puts(t, name);
@@ -1946,7 +1946,7 @@ int pa_stream_get_latency(pa_stream *s, pa_usec_t *r_usec, int *negative) {
     if (cindex < 0)
         cindex = 0;
 
-    c = pa_bytes_to_usec(cindex, &s->sample_spec);
+    c = pa_bytes_to_usec((uint64_t) cindex, &s->sample_spec);
 
     if (s->direction == PA_STREAM_PLAYBACK)
         *r_usec = time_counter_diff(s, c, t, negative);
@@ -2060,7 +2060,7 @@ pa_operation* pa_stream_set_buffer_attr(pa_stream *s, const pa_buffer_attr *attr
 
     t = pa_tagstruct_command(
             s->context,
-            s->direction == PA_STREAM_RECORD ? PA_COMMAND_SET_RECORD_STREAM_BUFFER_ATTR : PA_COMMAND_SET_PLAYBACK_STREAM_BUFFER_ATTR,
+            (uint32_t) (s->direction == PA_STREAM_RECORD ? PA_COMMAND_SET_RECORD_STREAM_BUFFER_ATTR : PA_COMMAND_SET_PLAYBACK_STREAM_BUFFER_ATTR),
             &tag);
     pa_tagstruct_putu32(t, s->channel);
 
@@ -2191,7 +2191,7 @@ pa_operation *pa_stream_update_sample_rate(pa_stream *s, uint32_t rate, pa_strea
 
     t = pa_tagstruct_command(
             s->context,
-            s->direction == PA_STREAM_RECORD ? PA_COMMAND_UPDATE_RECORD_STREAM_SAMPLE_RATE : PA_COMMAND_UPDATE_PLAYBACK_STREAM_SAMPLE_RATE,
+            (uint32_t) (s->direction == PA_STREAM_RECORD ? PA_COMMAND_UPDATE_RECORD_STREAM_SAMPLE_RATE : PA_COMMAND_UPDATE_PLAYBACK_STREAM_SAMPLE_RATE),
             &tag);
     pa_tagstruct_putu32(t, s->channel);
     pa_tagstruct_putu32(t, rate);
@@ -2219,7 +2219,7 @@ pa_operation *pa_stream_proplist_update(pa_stream *s, pa_update_mode_t mode, pa_
 
     t = pa_tagstruct_command(
             s->context,
-            s->direction == PA_STREAM_RECORD ? PA_COMMAND_UPDATE_RECORD_STREAM_PROPLIST : PA_COMMAND_UPDATE_PLAYBACK_STREAM_PROPLIST,
+            (uint32_t) (s->direction == PA_STREAM_RECORD ? PA_COMMAND_UPDATE_RECORD_STREAM_PROPLIST : PA_COMMAND_UPDATE_PLAYBACK_STREAM_PROPLIST),
             &tag);
     pa_tagstruct_putu32(t, s->channel);
     pa_tagstruct_putu32(t, (uint32_t) mode);
@@ -2252,7 +2252,7 @@ pa_operation *pa_stream_proplist_remove(pa_stream *s, const char *const keys[],
 
     t = pa_tagstruct_command(
             s->context,
-            s->direction == PA_STREAM_RECORD ? PA_COMMAND_REMOVE_RECORD_STREAM_PROPLIST : PA_COMMAND_REMOVE_PLAYBACK_STREAM_PROPLIST,
+            (uint32_t) (s->direction == PA_STREAM_RECORD ? PA_COMMAND_REMOVE_RECORD_STREAM_PROPLIST : PA_COMMAND_REMOVE_PLAYBACK_STREAM_PROPLIST),
             &tag);
     pa_tagstruct_putu32(t, s->channel);
 
diff --git a/src/pulse/timeval.c b/src/pulse/timeval.c
index 9708a735..376cf13c 100644
--- a/src/pulse/timeval.c
+++ b/src/pulse/timeval.c
@@ -90,13 +90,13 @@ pa_usec_t pa_timeval_diff(const struct timeval *a, const struct timeval *b) {
     }
 
     /* Calculate the second difference*/
-    r = ((pa_usec_t) a->tv_sec - b->tv_sec) * PA_USEC_PER_SEC;
+    r = ((pa_usec_t) a->tv_sec - (pa_usec_t) b->tv_sec) * PA_USEC_PER_SEC;
 
     /* Calculate the microsecond difference */
     if (a->tv_usec > b->tv_usec)
-        r += ((pa_usec_t) a->tv_usec - b->tv_usec);
+        r += ((pa_usec_t) a->tv_usec - (pa_usec_t) b->tv_usec);
     else if (a->tv_usec < b->tv_usec)
-        r -= ((pa_usec_t) b->tv_usec - a->tv_usec);
+        r -= ((pa_usec_t) b->tv_usec - (pa_usec_t) a->tv_usec);
 
     return r;
 }
@@ -132,7 +132,7 @@ struct timeval* pa_timeval_add(struct timeval *tv, pa_usec_t v) {
     pa_assert(tv);
 
     secs = (unsigned long) (v/PA_USEC_PER_SEC);
-    tv->tv_sec += secs;
+    tv->tv_sec += (time_t) secs;
     v -= ((pa_usec_t) secs) * PA_USEC_PER_SEC;
 
     tv->tv_usec += (suseconds_t) v;
@@ -140,7 +140,7 @@ struct timeval* pa_timeval_add(struct timeval *tv, pa_usec_t v) {
     /* Normalize */
     while ((unsigned) tv->tv_usec >= PA_USEC_PER_SEC) {
         tv->tv_sec++;
-        tv->tv_usec -= PA_USEC_PER_SEC;
+        tv->tv_usec -= (suseconds_t) PA_USEC_PER_SEC;
     }
 
     return tv;
@@ -151,14 +151,14 @@ struct timeval* pa_timeval_sub(struct timeval *tv, pa_usec_t v) {
     pa_assert(tv);
 
     secs = (unsigned long) (v/PA_USEC_PER_SEC);
-    tv->tv_sec -= secs;
+    tv->tv_sec -= (time_t) secs;
     v -= ((pa_usec_t) secs) * PA_USEC_PER_SEC;
 
     if (tv->tv_usec >= (suseconds_t) v)
         tv->tv_usec -= (suseconds_t) v;
     else {
         tv->tv_sec --;
-        tv->tv_usec = tv->tv_usec + PA_USEC_PER_SEC - v;
+        tv->tv_usec += (suseconds_t) (PA_USEC_PER_SEC - v);
     }
 
     return tv;
@@ -167,8 +167,8 @@ struct timeval* pa_timeval_sub(struct timeval *tv, pa_usec_t v) {
 struct timeval* pa_timeval_store(struct timeval *tv, pa_usec_t v) {
     pa_assert(tv);
 
-    tv->tv_sec = v / PA_USEC_PER_SEC;
-    tv->tv_usec = v % PA_USEC_PER_SEC;
+    tv->tv_sec = (time_t) (v / PA_USEC_PER_SEC);
+    tv->tv_usec = (suseconds_t) (v % PA_USEC_PER_SEC);
 
     return tv;
 }
diff --git a/src/pulse/utf8.c b/src/pulse/utf8.c
index 119be542..91aa9c81 100644
--- a/src/pulse/utf8.c
+++ b/src/pulse/utf8.c
@@ -109,17 +109,17 @@ static char* utf8_validate(const char *str, char *output) {
             if ((*p & 0xe0) == 0xc0) { /* 110xxxxx two-char seq. */
                 size = 2;
                 min = 128;
-                val = *p & 0x1e;
+                val = (uint32_t) (*p & 0x1e);
                 goto ONE_REMAINING;
             } else if ((*p & 0xf0) == 0xe0) { /* 1110xxxx three-char seq.*/
                 size = 3;
                 min = (1 << 11);
-                val = *p & 0x0f;
+                val = (uint32_t) (*p & 0x0f);
                 goto TWO_REMAINING;
             } else if ((*p & 0xf8) == 0xf0) { /* 11110xxx four-char seq */
                 size = 4;
                 min = (1 << 16);
-                val = *p & 0x07;
+                val = (uint32_t) (*p & 0x07);
             } else {
                 size = 1;
                 goto error;
@@ -149,7 +149,7 @@ ONE_REMAINING:
                 goto error;
 
             if (o) {
-                memcpy(o, last, size);
+                memcpy(o, last, (size_t) size);
                 o += size - 1;
             }
 
@@ -189,7 +189,7 @@ char* pa_utf8_filter (const char *str) {
     char *new_str;
 
     pa_assert(str);
-    new_str = pa_xnew(char, strlen(str) + 1);
+    new_str = pa_xmalloc(strlen(str) + 1);
     return utf8_validate(str, new_str);
 }
 
@@ -212,7 +212,7 @@ static char* iconv_simple(const char *str, const char *to, const char *from) {
         return NULL;
 
     inlen = len = strlen(str) + 1;
-    new_str = pa_xnew(char, len);
+    new_str = pa_xmalloc(len);
 
     for (;;) {
         inbuf = (ICONV_CONST char*) str; /* Brain dead prototype for iconv() */
diff --git a/src/pulse/util.c b/src/pulse/util.c
index 44fad4aa..b20ea46a 100644
--- a/src/pulse/util.c
+++ b/src/pulse/util.c
@@ -260,8 +260,8 @@ int pa_msleep(unsigned long t) {
 #elif defined(HAVE_NANOSLEEP)
     struct timespec ts;
 
-    ts.tv_sec = t/1000UL;
-    ts.tv_nsec = (t % 1000UL) * 1000000UL;
+    ts.tv_sec = (time_t) (t/1000UL);
+    ts.tv_nsec = (long) ((t % 1000UL) * 1000000UL);
 
     return nanosleep(&ts, NULL);
 #else
diff --git a/src/pulse/volume.c b/src/pulse/volume.c
index f0d45275..768bf49c 100644
--- a/src/pulse/volume.c
+++ b/src/pulse/volume.c
@@ -53,7 +53,7 @@ pa_cvolume* pa_cvolume_set(pa_cvolume *a, unsigned channels, pa_volume_t v) {
     pa_assert(channels > 0);
     pa_assert(channels <= PA_CHANNELS_MAX);
 
-    a->channels = channels;
+    a->channels = (uint8_t) channels;
 
     for (i = 0; i < a->channels; i++)
         a->values[i] = v;
@@ -175,7 +175,7 @@ pa_cvolume *pa_sw_cvolume_multiply(pa_cvolume *dest, const pa_cvolume *a, const
             i < b->channels ? b->values[i] : PA_VOLUME_NORM);
     }
 
-    dest->channels = i;
+    dest->channels = (uint8_t) i;
 
     return dest;
 }
diff --git a/src/pulse/xmalloc.c b/src/pulse/xmalloc.c
index 90237013..d1138d65 100644
--- a/src/pulse/xmalloc.c
+++ b/src/pulse/xmalloc.c
@@ -113,7 +113,7 @@ char *pa_xstrndup(const char *s, size_t l) {
         return NULL;
 
     if ((e = memchr(s, 0, l)))
-        return pa_xmemdup(s, e-s+1);
+        return pa_xmemdup(s, (size_t) (e-s+1));
 
     r = pa_xmalloc(l+1);
     memcpy(r, s, l);
diff --git a/src/pulsecore/asyncq.c b/src/pulsecore/asyncq.c
index 03e9f0df..f64931a5 100644
--- a/src/pulsecore/asyncq.c
+++ b/src/pulsecore/asyncq.c
@@ -71,7 +71,7 @@ PA_STATIC_FLIST_DECLARE(localq, 0, pa_xfree);
 
 #define PA_ASYNCQ_CELLS(x) ((pa_atomic_ptr_t*) ((uint8_t*) (x) + PA_ALIGN(sizeof(struct pa_asyncq))))
 
-static int reduce(pa_asyncq *l, int value) {
+static unsigned reduce(pa_asyncq *l, unsigned value) {
     return value & (unsigned) (l->size - 1);
 }
 
@@ -132,7 +132,7 @@ void pa_asyncq_free(pa_asyncq *l, pa_free_cb_t free_cb) {
 }
 
 static int push(pa_asyncq*l, void *p, pa_bool_t wait) {
-    int idx;
+    unsigned idx;
     pa_atomic_ptr_t *cells;
 
     pa_assert(l);
@@ -220,7 +220,7 @@ void pa_asyncq_post(pa_asyncq*l, void *p) {
 }
 
 void* pa_asyncq_pop(pa_asyncq*l, pa_bool_t wait) {
-    int idx;
+    unsigned idx;
     void *ret;
     pa_atomic_ptr_t *cells;
 
@@ -263,7 +263,7 @@ int pa_asyncq_read_fd(pa_asyncq *q) {
 }
 
 int pa_asyncq_read_before_poll(pa_asyncq *l) {
-    int idx;
+    unsigned idx;
     pa_atomic_ptr_t *cells;
 
     pa_assert(l);
@@ -280,8 +280,6 @@ int pa_asyncq_read_before_poll(pa_asyncq *l) {
         if (pa_fdsem_before_poll(l->write_fdsem) >= 0)
             return 0;
     }
-
-    return 0;
 }
 
 void pa_asyncq_read_after_poll(pa_asyncq *l) {
diff --git a/src/pulsecore/cli-command.c b/src/pulsecore/cli-command.c
index aa05a464..1624165d 100644
--- a/src/pulsecore/cli-command.c
+++ b/src/pulsecore/cli-command.c
@@ -318,22 +318,22 @@ static int pa_cli_command_stat(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_b
 
     pa_strbuf_printf(buf, "Memory blocks currently allocated: %u, size: %s.\n",
                      (unsigned) pa_atomic_load(&stat->n_allocated),
-                     pa_bytes_snprint(s, sizeof(s), (size_t) pa_atomic_load(&stat->allocated_size)));
+                     pa_bytes_snprint(s, sizeof(s), (unsigned) pa_atomic_load(&stat->allocated_size)));
 
     pa_strbuf_printf(buf, "Memory blocks allocated during the whole lifetime: %u, size: %s.\n",
                      (unsigned) pa_atomic_load(&stat->n_accumulated),
-                     pa_bytes_snprint(s, sizeof(s), (size_t) pa_atomic_load(&stat->accumulated_size)));
+                     pa_bytes_snprint(s, sizeof(s), (unsigned) pa_atomic_load(&stat->accumulated_size)));
 
     pa_strbuf_printf(buf, "Memory blocks imported from other processes: %u, size: %s.\n",
                      (unsigned) pa_atomic_load(&stat->n_imported),
-                     pa_bytes_snprint(s, sizeof(s), (size_t) pa_atomic_load(&stat->imported_size)));
+                     pa_bytes_snprint(s, sizeof(s), (unsigned) pa_atomic_load(&stat->imported_size)));
 
     pa_strbuf_printf(buf, "Memory blocks exported to other processes: %u, size: %s.\n",
                      (unsigned) pa_atomic_load(&stat->n_exported),
-                     pa_bytes_snprint(s, sizeof(s), (size_t) pa_atomic_load(&stat->exported_size)));
+                     pa_bytes_snprint(s, sizeof(s), (unsigned) pa_atomic_load(&stat->exported_size)));
 
     pa_strbuf_printf(buf, "Total sample cache size: %s.\n",
-                     pa_bytes_snprint(s, sizeof(s), pa_scache_total_size(c)));
+                     pa_bytes_snprint(s, sizeof(s), (unsigned) pa_scache_total_size(c)));
 
     pa_strbuf_printf(buf, "Default sample spec: %s\n",
                      pa_sample_spec_snprint(s, sizeof(s), &c->default_sample_spec));
diff --git a/src/pulsecore/cli-text.c b/src/pulsecore/cli-text.c
index 4cbe7c34..7bbc2660 100644
--- a/src/pulsecore/cli-text.c
+++ b/src/pulsecore/cli-text.c
@@ -151,8 +151,10 @@ char *pa_sink_list_to_string(pa_core *c) {
             state_table[pa_sink_get_state(sink)],
             pa_cvolume_snprint(cv, sizeof(cv), pa_sink_get_volume(sink, FALSE)),
             pa_yes_no(pa_sink_get_mute(sink, FALSE)),
-            (double) pa_sink_get_latency(sink) / PA_USEC_PER_MSEC,
-            (double) pa_sink_get_requested_latency(sink) / PA_USEC_PER_MSEC, (double) min_latency / PA_USEC_PER_MSEC, (double) max_latency / PA_USEC_PER_MSEC,
+            (double) pa_sink_get_latency(sink) / (double) PA_USEC_PER_MSEC,
+            (double) pa_sink_get_requested_latency(sink) / (double) PA_USEC_PER_MSEC,
+            (double) min_latency / PA_USEC_PER_MSEC,
+            (double) max_latency / PA_USEC_PER_MSEC,
             (unsigned long) pa_sink_get_max_request(sink) / 1024,
             (unsigned long) pa_sink_get_max_rewind(sink) / 1024,
             sink->monitor_source ? sink->monitor_source->index : PA_INVALID_INDEX,
@@ -225,7 +227,9 @@ char *pa_source_list_to_string(pa_core *c) {
             pa_cvolume_snprint(cv, sizeof(cv), pa_source_get_volume(source, FALSE)),
             pa_yes_no(pa_source_get_mute(source, FALSE)),
             (double) pa_source_get_latency(source) / PA_USEC_PER_MSEC,
-            (double) pa_source_get_requested_latency(source) / PA_USEC_PER_MSEC, (double) min_latency / PA_USEC_PER_MSEC, (double) max_latency / PA_USEC_PER_MSEC,
+            (double) pa_source_get_requested_latency(source) / PA_USEC_PER_MSEC,
+            (double) min_latency / PA_USEC_PER_MSEC,
+            (double) max_latency / PA_USEC_PER_MSEC,
             (unsigned long) pa_source_get_max_rewind(source) / 1024,
             pa_sample_spec_snprint(ss, sizeof(ss), &source->sample_spec),
             pa_channel_map_snprint(cm, sizeof(cm), &source->channel_map),
@@ -411,7 +415,7 @@ char *pa_scache_list_to_string(pa_core *c) {
             if (e->memchunk.memblock) {
                 pa_sample_spec_snprint(ss, sizeof(ss), &e->sample_spec);
                 pa_channel_map_snprint(cm, sizeof(cm), &e->channel_map);
-                l = (double) e->memchunk.length / pa_bytes_per_second(&e->sample_spec);
+                l = (double) e->memchunk.length / (double) pa_bytes_per_second(&e->sample_spec);
             }
 
             pa_strbuf_printf(
diff --git a/src/pulsecore/core-util.c b/src/pulsecore/core-util.c
index 5841df0c..41a31042 100644
--- a/src/pulsecore/core-util.c
+++ b/src/pulsecore/core-util.c
@@ -345,7 +345,7 @@ ssize_t pa_loop_read(int fd, void*data, size_t size, int *type) {
 
         ret += r;
         data = (uint8_t*) data + r;
-        size -= r;
+        size -= (size_t) r;
     }
 
     return ret;
@@ -376,7 +376,7 @@ ssize_t pa_loop_write(int fd, const void*data, size_t size, int *type) {
 
         ret += r;
         data = (const uint8_t*) data + r;
-        size -= r;
+        size -= (size_t) r;
     }
 
     return ret;
@@ -445,7 +445,7 @@ void pa_check_signal_is_blocked(int sig) {
 /* The following function is based on an example from the GNU libc
  * documentation. This function is similar to GNU's asprintf(). */
 char *pa_sprintf_malloc(const char *format, ...) {
-    int  size = 100;
+    size_t  size = 100;
     char *c = NULL;
 
     pa_assert(format);
@@ -462,11 +462,11 @@ char *pa_sprintf_malloc(const char *format, ...) {
 
         c[size-1] = 0;
 
-        if (r > -1 && r < size)
+        if (r > -1 && (size_t) r < size)
             return c;
 
         if (r > -1)    /* glibc 2.1 */
-            size = r+1;
+            size = (size_t) r+1;
         else           /* glibc 2.0 */
             size *= 2;
     }
@@ -475,7 +475,7 @@ char *pa_sprintf_malloc(const char *format, ...) {
 /* Same as the previous function, but use a va_list instead of an
  * ellipsis */
 char *pa_vsprintf_malloc(const char *format, va_list ap) {
-    int  size = 100;
+    size_t  size = 100;
     char *c = NULL;
 
     pa_assert(format);
@@ -492,11 +492,11 @@ char *pa_vsprintf_malloc(const char *format, va_list ap) {
 
         c[size-1] = 0;
 
-        if (r > -1 && r < size)
+        if (r > -1 && (size_t) r < size)
             return c;
 
         if (r > -1)    /* glibc 2.1 */
-            size = r+1;
+            size = (size_t) r+1;
         else           /* glibc 2.0 */
             size *= 2;
     }
@@ -929,10 +929,10 @@ static int is_group(gid_t gid, const char *name) {
     if (n < 0)
         n = 512;
 
-    data = pa_xmalloc(n);
+    data = pa_xmalloc((size_t) n);
 
     errno = 0;
-    if (getgrgid_r(gid, &group, data, n, &result) < 0 || !result) {
+    if (getgrgid_r(gid, &group, data, (size_t) n, &result) < 0 || !result) {
         pa_log("getgrgid_r(%u): %s", (unsigned) gid, pa_cstrerror(errno));
 
         if (!errno)
@@ -970,14 +970,14 @@ finish:
 /* Check the current user is member of the specified group */
 int pa_own_uid_in_group(const char *name, gid_t *gid) {
     GETGROUPS_T *gids, tgid;
-    int n = sysconf(_SC_NGROUPS_MAX);
+    long n = sysconf(_SC_NGROUPS_MAX);
     int r = -1, i, k;
 
     pa_assert(n > 0);
 
-    gids = pa_xmalloc(sizeof(GETGROUPS_T)*n);
+    gids = pa_xmalloc(sizeof(GETGROUPS_T) * (size_t) n);
 
-    if ((n = getgroups(n, gids)) < 0) {
+    if ((n = getgroups((int) n, gids)) < 0) {
         pa_log("getgroups(): %s", pa_cstrerror(errno));
         goto finish;
     }
@@ -1018,10 +1018,10 @@ int pa_uid_in_group(uid_t uid, const char *name) {
     int r = -1;
 
     g_n = sysconf(_SC_GETGR_R_SIZE_MAX);
-    g_buf = pa_xmalloc(g_n);
+    g_buf = pa_xmalloc((size_t) g_n);
 
     p_n = sysconf(_SC_GETPW_R_SIZE_MAX);
-    p_buf = pa_xmalloc(p_n);
+    p_buf = pa_xmalloc((size_t) p_n);
 
     errno = 0;
     if (getgrnam_r(name, &grbuf, g_buf, (size_t) g_n, &gr) != 0 || !gr) {
@@ -1061,7 +1061,7 @@ gid_t pa_get_gid_of_group(const char *name) {
     struct group grbuf, *gr;
 
     g_n = sysconf(_SC_GETGR_R_SIZE_MAX);
-    g_buf = pa_xmalloc(g_n);
+    g_buf = pa_xmalloc((size_t) g_n);
 
     errno = 0;
     if (getgrnam_r(name, &grbuf, g_buf, (size_t) g_n, &gr) != 0 || !gr) {
@@ -1126,7 +1126,7 @@ int pa_lock_fd(int fd, int b) {
 
     /* Try a R/W lock first */
 
-    flock.l_type = b ? F_WRLCK : F_UNLCK;
+    flock.l_type = (short) (b ? F_WRLCK : F_UNLCK);
     flock.l_whence = SEEK_SET;
     flock.l_start = 0;
     flock.l_len = 0;
@@ -1291,7 +1291,7 @@ char *pa_get_state_dir(void) {
     /* If PULSE_STATE_PATH and PULSE_RUNTIME_PATH point to the same
      * dir then this will break. */
 
-    if (pa_make_secure_dir(d, 0700, (pid_t) -1, (pid_t) -1) < 0)  {
+    if (pa_make_secure_dir(d, 0700U, (uid_t) -1, (gid_t) -1) < 0)  {
         pa_log_error("Failed to create secure directory: %s", pa_cstrerror(errno));
         pa_xfree(d);
         return NULL;
@@ -1372,9 +1372,9 @@ char *pa_get_runtime_dir(void) {
     if ((d = getenv("PULSE_RUNTIME_PATH"))) {
         mode_t m;
 
-        m = pa_in_system_mode() ? 0755 : 0700;
+        m = pa_in_system_mode() ? 0755U : 0700U;
 
-        if (pa_make_secure_dir(d, m, (pid_t) -1, (pid_t) -1) < 0)  {
+        if (pa_make_secure_dir(d, m, (uid_t) -1, (gid_t) -1) < 0)  {
             pa_log_error("Failed to create secure directory: %s", pa_cstrerror(errno));
             goto fail;
         }
@@ -1934,8 +1934,8 @@ int pa_atod(const char *s, double *ret_d) {
 }
 
 /* Same as snprintf, but guarantees NUL-termination on every platform */
-int pa_snprintf(char *str, size_t size, const char *format, ...) {
-    int ret;
+size_t pa_snprintf(char *str, size_t size, const char *format, ...) {
+    size_t ret;
     va_list ap;
 
     pa_assert(str);
@@ -1950,7 +1950,7 @@ int pa_snprintf(char *str, size_t size, const char *format, ...) {
 }
 
 /* Same as vsnprintf, but guarantees NUL-termination on every platform */
-int pa_vsnprintf(char *str, size_t size, const char *format, va_list ap) {
+size_t pa_vsnprintf(char *str, size_t size, const char *format, va_list ap) {
     int ret;
 
     pa_assert(str);
@@ -1962,9 +1962,12 @@ int pa_vsnprintf(char *str, size_t size, const char *format, va_list ap) {
     str[size-1] = 0;
 
     if (ret < 0)
-        ret = strlen(str);
+        return strlen(str);
+
+    if ((size_t) ret > size-1)
+        return size-1;
 
-    return PA_MIN((int) size-1, ret);
+    return (size_t) ret;
 }
 
 /* Truncate the specified string, but guarantee that the string
@@ -1988,7 +1991,7 @@ char *pa_getcwd(void) {
     size_t l = 128;
 
     for (;;) {
-        char *p = pa_xnew(char, l);
+        char *p = pa_xmalloc(l);
         if (getcwd(p, l))
             return p;
 
@@ -2013,7 +2016,7 @@ void *pa_will_need(const void *p, size_t l) {
     pa_assert(l > 0);
 
     a = PA_PAGE_ALIGN_PTR(p);
-    size = (const uint8_t*) p + l - (const uint8_t*) a;
+    size = (size_t) ((const uint8_t*) p + l - (const uint8_t*) a);
 
 #ifdef HAVE_POSIX_MADVISE
     if ((r = posix_madvise((void*) a, size, POSIX_MADV_WILLNEED)) == 0) {
@@ -2090,7 +2093,7 @@ char *pa_readlink(const char *p) {
         char *c;
         ssize_t n;
 
-        c = pa_xnew(char, l);
+        c = pa_xmalloc(l);
 
         if ((n = readlink(p, c, l-1)) < 0) {
             pa_xfree(c);
@@ -2109,8 +2112,8 @@ char *pa_readlink(const char *p) {
 
 int pa_close_all(int except_fd, ...) {
     va_list ap;
-    int n = 0, i, r;
-    int *p;
+    unsigned n = 0, i;
+    int r, *p;
 
     va_start(ap, except_fd);
 
@@ -2237,8 +2240,8 @@ int pa_close_allv(const int except_fds[]) {
 
 int pa_unblock_sigs(int except, ...) {
     va_list ap;
-    int n = 0, i, r;
-    int *p;
+    unsigned n = 0, i;
+    int r, *p;
 
     va_start(ap, except);
 
@@ -2286,8 +2289,8 @@ int pa_unblock_sigsv(const int except[]) {
 
 int pa_reset_sigs(int except, ...) {
     va_list ap;
-    int n = 0, i, r;
-    int *p;
+    unsigned n = 0, i;
+    int *p, r;
 
     va_start(ap, except);
 
@@ -2395,7 +2398,7 @@ char *pa_machine_id(void) {
     for (;;) {
         char *c;
 
-        c = pa_xnew(char, l);
+        c = pa_xmalloc(l);
 
         if (!pa_get_host_name(c, l)) {
 
diff --git a/src/pulsecore/core-util.h b/src/pulsecore/core-util.h
index 838e4ad3..7167972b 100644
--- a/src/pulsecore/core-util.h
+++ b/src/pulsecore/core-util.h
@@ -127,8 +127,8 @@ int pa_atoi(const char *s, int32_t *ret_i);
 int pa_atou(const char *s, uint32_t *ret_u);
 int pa_atod(const char *s, double *ret_d);
 
-int pa_snprintf(char *str, size_t size, const char *format, ...);
-int pa_vsnprintf(char *str, size_t size, const char *format, va_list ap);
+size_t pa_snprintf(char *str, size_t size, const char *format, ...);
+size_t pa_vsnprintf(char *str, size_t size, const char *format, va_list ap);
 
 char *pa_truncate_utf8(char *c, size_t l);
 
diff --git a/src/pulsecore/envelope.c b/src/pulsecore/envelope.c
index e2691611..7f2252e9 100644
--- a/src/pulsecore/envelope.c
+++ b/src/pulsecore/envelope.c
@@ -153,11 +153,11 @@ void pa_envelope_free(pa_envelope *e) {
 }
 
 static int32_t linear_interpolate_int(pa_usec_t x1, int32_t _y1, pa_usec_t x2, int32_t y2, pa_usec_t x3) {
-    return (int32_t) (_y1 + (x3 - x1) * (float) (y2 - _y1) / (float) (x2 - x1));
+    return (int32_t) ((double) _y1 + (double) (x3 - x1) * (double) (y2 - _y1) / (double) (x2 - x1));
 }
 
 static float linear_interpolate_float(pa_usec_t x1, float _y1, pa_usec_t x2, float y2, pa_usec_t x3) {
-    return _y1 + (x3 - x1) * (y2 - _y1) / (x2 - x1);
+    return _y1 + ((float) x3 - (float) x1) * (y2 - _y1) / ((float) x2 - (float) x1);
 }
 
 static int32_t item_get_int(pa_envelope_item *i, pa_usec_t x) {
@@ -573,11 +573,11 @@ static float linear_get_float(pa_envelope *e, int v) {
     if (!e->points[v].cached_valid) {
         e->points[v].cached_dy_dx =
             (e->points[v].y.f[e->points[v].n_current+1] - e->points[v].y.f[e->points[v].n_current]) /
-            (e->points[v].x[e->points[v].n_current+1] - e->points[v].x[e->points[v].n_current]);
+            ((float) e->points[v].x[e->points[v].n_current+1] - (float) e->points[v].x[e->points[v].n_current]);
         e->points[v].cached_valid = TRUE;
     }
 
-    return e->points[v].y.f[e->points[v].n_current] + (e->x - e->points[v].x[e->points[v].n_current]) * e->points[v].cached_dy_dx;
+    return e->points[v].y.f[e->points[v].n_current] + (float) (e->x - e->points[v].x[e->points[v].n_current]) * e->points[v].cached_dy_dx;
 }
 
 void pa_envelope_apply(pa_envelope *e, pa_memchunk *chunk) {
@@ -605,7 +605,7 @@ void pa_envelope_apply(pa_envelope *e, pa_memchunk *chunk) {
                 uint8_t *t;
 
                 for (t = p; n > 0; n -= fs) {
-                    int16_t factor = linear_get_int(e, v);
+                    int32_t factor = linear_get_int(e, v);
                     unsigned c;
                     e->x += fs;
 
@@ -620,13 +620,13 @@ void pa_envelope_apply(pa_envelope *e, pa_memchunk *chunk) {
                 uint8_t *t;
 
                 for (t = p; n > 0; n -= fs) {
-                    int16_t factor = linear_get_int(e, v);
+                    int32_t factor = linear_get_int(e, v);
                     unsigned c;
                     e->x += fs;
 
                     for (c = 0; c < e->sample_spec.channels; c++, t++) {
                         int16_t k = st_ulaw2linear16(*t);
-                        *t = (uint8_t) st_14linear2ulaw(((factor * k) / 0x10000) >> 2);
+                        *t = (uint8_t) st_14linear2ulaw((int16_t) (((factor * k) / 0x10000) >> 2));
                     }
                 }
 
@@ -637,13 +637,13 @@ void pa_envelope_apply(pa_envelope *e, pa_memchunk *chunk) {
                 uint8_t *t;
 
                 for (t = p; n > 0; n -= fs) {
-                    int16_t factor = linear_get_int(e, v);
+                    int32_t factor = linear_get_int(e, v);
                     unsigned c;
                     e->x += fs;
 
                     for (c = 0; c < e->sample_spec.channels; c++, t++) {
                         int16_t k = st_alaw2linear16(*t);
-                        *t = (uint8_t) st_13linear2alaw(((factor * k) / 0x10000) >> 3);
+                        *t = (uint8_t) st_13linear2alaw((int16_t) (((factor * k) / 0x10000) >> 3));
                     }
                 }
 
@@ -659,7 +659,7 @@ void pa_envelope_apply(pa_envelope *e, pa_memchunk *chunk) {
                     e->x += fs;
 
                     for (c = 0; c < e->sample_spec.channels; c++, t++)
-                        *t = (factor * *t) / 0x10000;
+                        *t = (int16_t) ((factor * *t) / 0x10000);
                 }
 
                 break;
@@ -674,7 +674,7 @@ void pa_envelope_apply(pa_envelope *e, pa_memchunk *chunk) {
                     e->x += fs;
 
                     for (c = 0; c < e->sample_spec.channels; c++, t++) {
-                        int16_t r = (factor * PA_INT16_SWAP(*t)) / 0x10000;
+                        int16_t r = (int16_t) ((factor * PA_INT16_SWAP(*t)) / 0x10000);
                         *t = PA_INT16_SWAP(r);
                     }
                 }
diff --git a/src/pulsecore/fdsem.c b/src/pulsecore/fdsem.c
index 1531e3db..2a7ae589 100644
--- a/src/pulsecore/fdsem.c
+++ b/src/pulsecore/fdsem.c
@@ -195,7 +195,7 @@ static void flush(pa_fdsem *f) {
             continue;
         }
 
-    } while (pa_atomic_sub(&f->data->in_pipe, r) > r);
+    } while (pa_atomic_sub(&f->data->in_pipe, (int) r) > (int) r);
 }
 
 void pa_fdsem_post(pa_fdsem *f) {
@@ -265,7 +265,7 @@ void pa_fdsem_wait(pa_fdsem *f) {
             continue;
         }
 
-        pa_atomic_sub(&f->data->in_pipe, r);
+        pa_atomic_sub(&f->data->in_pipe, (int) r);
     }
 
     pa_assert_se(pa_atomic_dec(&f->data->waiting) >= 1);
diff --git a/src/pulsecore/idxset.c b/src/pulsecore/idxset.c
index fb4497b8..b6423efd 100644
--- a/src/pulsecore/idxset.c
+++ b/src/pulsecore/idxset.c
@@ -66,7 +66,7 @@ unsigned pa_idxset_string_hash_func(const void *p) {
     const char *c;
 
     for (c = p; *c; c++)
-        hash = 31 * hash + *c;
+        hash = 31 * hash + (unsigned) *c;
 
     return hash;
 }
diff --git a/src/pulsecore/ioline.c b/src/pulsecore/ioline.c
index 90afaafd..88174c05 100644
--- a/src/pulsecore/ioline.c
+++ b/src/pulsecore/ioline.c
@@ -164,7 +164,7 @@ void pa_ioline_puts(pa_ioline *l, const char *c) {
         /* In case the allocated buffer is too small, enlarge it. */
         if (l->wbuf_valid_length + len > l->wbuf_length) {
             size_t n = l->wbuf_valid_length+len;
-            char *new = pa_xnew(char, n);
+            char *new = pa_xnew(char, (unsigned) n);
 
             if (l->wbuf) {
                 memcpy(new, l->wbuf+l->wbuf_index, l->wbuf_valid_length);
@@ -285,7 +285,7 @@ static int do_read(pa_ioline *l) {
                     memmove(l->rbuf, l->rbuf+l->rbuf_index, l->rbuf_valid_length);
             } else {
                 /* Enlarge the buffer */
-                char *new = pa_xnew(char, n);
+                char *new = pa_xnew(char, (unsigned) n);
                 if (l->rbuf_valid_length)
                     memcpy(new, l->rbuf+l->rbuf_index, l->rbuf_valid_length);
                 pa_xfree(l->rbuf);
@@ -315,10 +315,10 @@ static int do_read(pa_ioline *l) {
             return -1;
         }
 
-        l->rbuf_valid_length += r;
+        l->rbuf_valid_length += (size_t) r;
 
         /* Look if a line has been terminated in the newly read data */
-        scan_for_lines(l, l->rbuf_valid_length - r);
+        scan_for_lines(l, l->rbuf_valid_length - (size_t) r);
     }
 
     return 0;
@@ -346,8 +346,8 @@ static int do_write(pa_ioline *l) {
             return -1;
         }
 
-        l->wbuf_index += r;
-        l->wbuf_valid_length -= r;
+        l->wbuf_index += (size_t) r;
+        l->wbuf_valid_length -= (size_t) r;
 
         /* A shortcut for the next time */
         if (l->wbuf_valid_length == 0)
diff --git a/src/pulsecore/ipacl.c b/src/pulsecore/ipacl.c
index 7b5f865b..6d5080fb 100644
--- a/src/pulsecore/ipacl.c
+++ b/src/pulsecore/ipacl.c
@@ -122,7 +122,7 @@ pa_ip_acl* pa_ip_acl_new(const char *s) {
             if (e.bits < 128) {
                 int t = 0, i;
 
-                for (i = 0, bits = e.bits; i < 16; i++) {
+                for (i = 0, bits = (uint32_t) e.bits; i < 16; i++) {
 
                     if (bits >= 8)
                         bits -= 8;
diff --git a/src/pulsecore/memblock.c b/src/pulsecore/memblock.c
index 47909cdc..6d12acdc 100644
--- a/src/pulsecore/memblock.c
+++ b/src/pulsecore/memblock.c
@@ -162,14 +162,14 @@ static void stat_add(pa_memblock*b) {
     pa_assert(b->pool);
 
     pa_atomic_inc(&b->pool->stat.n_allocated);
-    pa_atomic_add(&b->pool->stat.allocated_size, b->length);
+    pa_atomic_add(&b->pool->stat.allocated_size, (int) b->length);
 
     pa_atomic_inc(&b->pool->stat.n_accumulated);
-    pa_atomic_add(&b->pool->stat.accumulated_size, b->length);
+    pa_atomic_add(&b->pool->stat.accumulated_size, (int) b->length);
 
     if (b->type == PA_MEMBLOCK_IMPORTED) {
         pa_atomic_inc(&b->pool->stat.n_imported);
-        pa_atomic_add(&b->pool->stat.imported_size, b->length);
+        pa_atomic_add(&b->pool->stat.imported_size, (int) b->length);
     }
 
     pa_atomic_inc(&b->pool->stat.n_allocated_by_type[b->type]);
@@ -185,14 +185,14 @@ static void stat_remove(pa_memblock *b) {
     pa_assert(pa_atomic_load(&b->pool->stat.allocated_size) >= (int) b->length);
 
     pa_atomic_dec(&b->pool->stat.n_allocated);
-    pa_atomic_sub(&b->pool->stat.allocated_size,  b->length);
+    pa_atomic_sub(&b->pool->stat.allocated_size, (int) b->length);
 
     if (b->type == PA_MEMBLOCK_IMPORTED) {
         pa_assert(pa_atomic_load(&b->pool->stat.n_imported) > 0);
         pa_assert(pa_atomic_load(&b->pool->stat.imported_size) >= (int) b->length);
 
         pa_atomic_dec(&b->pool->stat.n_imported);
-        pa_atomic_sub(&b->pool->stat.imported_size, b->length);
+        pa_atomic_sub(&b->pool->stat.imported_size, (int) b->length);
     }
 
     pa_atomic_dec(&b->pool->stat.n_allocated_by_type[b->type]);
@@ -252,7 +252,7 @@ static struct mempool_slot* mempool_allocate_slot(pa_mempool *p) {
         if ((unsigned) (idx = pa_atomic_inc(&p->n_init)) >= p->n_blocks)
             pa_atomic_dec(&p->n_init);
         else
-            slot = (struct mempool_slot*) ((uint8_t*) p->memory.ptr + (p->block_size * idx));
+            slot = (struct mempool_slot*) ((uint8_t*) p->memory.ptr + (p->block_size * (size_t) idx));
 
         if (!slot) {
             pa_log_info("Pool full");
@@ -280,7 +280,7 @@ static unsigned mempool_slot_idx(pa_mempool *p, void *ptr) {
     pa_assert((uint8_t*) ptr >= (uint8_t*) p->memory.ptr);
     pa_assert((uint8_t*) ptr < (uint8_t*) p->memory.ptr + p->memory.size);
 
-    return ((uint8_t*) ptr - (uint8_t*) p->memory.ptr) / p->block_size;
+    return (unsigned) ((size_t) ((uint8_t*) ptr - (uint8_t*) p->memory.ptr) / p->block_size);
 }
 
 /* No lock necessary */
@@ -659,7 +659,7 @@ static void memblock_replace_import(pa_memblock *b) {
     pa_assert(pa_atomic_load(&b->pool->stat.n_imported) > 0);
     pa_assert(pa_atomic_load(&b->pool->stat.imported_size) >= (int) b->length);
     pa_atomic_dec(&b->pool->stat.n_imported);
-    pa_atomic_sub(&b->pool->stat.imported_size, b->length);
+    pa_atomic_sub(&b->pool->stat.imported_size, (int) b->length);
 
     seg = b->per_type.imported.segment;
     pa_assert(seg);
@@ -766,7 +766,7 @@ void pa_mempool_vacuum(pa_mempool *p) {
             ;
 
     while ((slot = pa_flist_pop(list))) {
-        pa_shm_punch(&p->memory, (uint8_t*) slot - (uint8_t*) p->memory.ptr, p->block_size);
+        pa_shm_punch(&p->memory, (size_t) ((uint8_t*) slot - (uint8_t*) p->memory.ptr), p->block_size);
 
         while (pa_flist_push(p->free_slots, slot))
             ;
@@ -979,7 +979,7 @@ void pa_memexport_free(pa_memexport *e) {
 
     pa_mutex_lock(e->mutex);
     while (e->used_slots)
-        pa_memexport_process_release(e, e->used_slots - e->slots);
+        pa_memexport_process_release(e, (uint32_t) (e->used_slots - e->slots));
     pa_mutex_unlock(e->mutex);
 
     pa_mutex_lock(e->pool->mutex);
@@ -1018,7 +1018,7 @@ int pa_memexport_process_release(pa_memexport *e, uint32_t id) {
     pa_assert(pa_atomic_load(&e->pool->stat.exported_size) >= (int) b->length);
 
     pa_atomic_dec(&e->pool->stat.n_exported);
-    pa_atomic_sub(&e->pool->stat.exported_size, b->length);
+    pa_atomic_sub(&e->pool->stat.exported_size, (int) b->length);
 
     pa_memblock_unref(b);
 
@@ -1046,7 +1046,7 @@ static void memexport_revoke_blocks(pa_memexport *e, pa_memimport *i) {
             slot->block->per_type.imported.segment->import != i)
             continue;
 
-        idx = slot - e->slots;
+        idx = (uint32_t) (slot - e->slots);
         e->revoke_cb(e, idx, e->userdata);
         pa_memexport_process_release(e, idx);
     }
@@ -1107,7 +1107,7 @@ int pa_memexport_put(pa_memexport *e, pa_memblock *b, uint32_t *block_id, uint32
 
     PA_LLIST_PREPEND(struct memexport_slot, e->used_slots, slot);
     slot->block = b;
-    *block_id = slot - e->slots;
+    *block_id = (uint32_t) (slot - e->slots);
 
     pa_mutex_unlock(e->mutex);
 /*     pa_log("Got block id %u", *block_id); */
@@ -1127,13 +1127,13 @@ int pa_memexport_put(pa_memexport *e, pa_memblock *b, uint32_t *block_id, uint32
     pa_assert((uint8_t*) data + b->length <= (uint8_t*) memory->ptr + memory->size);
 
     *shm_id = memory->id;
-    *offset = (uint8_t*) data - (uint8_t*) memory->ptr;
+    *offset = (size_t) ((uint8_t*) data - (uint8_t*) memory->ptr);
     *size = b->length;
 
     pa_memblock_release(b);
 
     pa_atomic_inc(&e->pool->stat.n_exported);
-    pa_atomic_add(&e->pool->stat.exported_size, b->length);
+    pa_atomic_add(&e->pool->stat.exported_size, (int) b->length);
 
     return 0;
 }
diff --git a/src/pulsecore/memblockq.c b/src/pulsecore/memblockq.c
index 841b9075..265da37f 100644
--- a/src/pulsecore/memblockq.c
+++ b/src/pulsecore/memblockq.c
@@ -84,7 +84,8 @@ pa_memblockq* pa_memblockq_new(
     pa_log_debug("memblockq requested: maxlength=%lu, tlength=%lu, base=%lu, prebuf=%lu, minreq=%lu maxrewind=%lu",
                  (unsigned long) maxlength, (unsigned long) tlength, (unsigned long) base, (unsigned long) prebuf, (unsigned long) minreq, (unsigned long) maxrewind);
 
-    bq->missing = bq->requested = bq->maxlength = bq->tlength = bq->prebuf = bq->minreq = bq->maxrewind = 0;
+    bq->missing = 0;
+    bq->requested = bq->maxlength = bq->tlength = bq->prebuf = bq->minreq = bq->maxrewind = 0;
     bq->in_prebuf = TRUE;
 
     pa_memblockq_set_maxlength(bq, maxlength);
@@ -215,7 +216,7 @@ static void drop_backlog(pa_memblockq *bq) {
     int64_t boundary;
     pa_assert(bq);
 
-    boundary = bq->read_index - bq->maxrewind;
+    boundary = bq->read_index - (int64_t) bq->maxrewind;
 
     while (bq->blocks && (bq->blocks->index + (int64_t) bq->blocks->chunk.length <= boundary))
         drop_block(bq, bq->blocks);
@@ -227,10 +228,10 @@ static pa_bool_t can_push(pa_memblockq *bq, size_t l) {
     pa_assert(bq);
 
     if (bq->read_index > bq->write_index) {
-        size_t d =  bq->read_index - bq->write_index;
+        int64_t d = bq->read_index - bq->write_index;
 
-        if (l > d)
-            l -= d;
+        if ((int64_t) l > d)
+            l -= (size_t) d;
         else
             return TRUE;
     }
@@ -239,7 +240,7 @@ static pa_bool_t can_push(pa_memblockq *bq, size_t l) {
 
     /* Make sure that the list doesn't get too long */
     if (bq->write_index + (int64_t) l > end)
-        if (bq->write_index + l - bq->read_index > bq->maxlength)
+        if (bq->write_index + (int64_t) l - bq->read_index > (int64_t) bq->maxlength)
             return FALSE;
 
     return TRUE;
@@ -294,7 +295,7 @@ int pa_memblockq_push(pa_memblockq* bq, const pa_memchunk *uchunk) {
             /* This entry isn't touched at all, let's skip it */
             q = q->prev;
         } else if (bq->write_index <= q->index &&
-            bq->write_index + chunk.length >= q->index + q->chunk.length) {
+                   bq->write_index + (int64_t) chunk.length >= q->index + (int64_t) q->chunk.length) {
 
             /* This entry is fully replaced by the new entry, so let's drop it */
 
@@ -306,7 +307,7 @@ int pa_memblockq_push(pa_memblockq* bq, const pa_memchunk *uchunk) {
             /* The write index points into this memblock, so let's
              * truncate or split it */
 
-            if (bq->write_index + chunk.length < q->index + q->chunk.length) {
+            if (bq->write_index + (int64_t) chunk.length < q->index + (int64_t) q->chunk.length) {
 
                 /* We need to save the end of this memchunk */
                 struct list_item *p;
@@ -320,11 +321,11 @@ int pa_memblockq_push(pa_memblockq* bq, const pa_memchunk *uchunk) {
                 pa_memblock_ref(p->chunk.memblock);
 
                 /* Calculate offset */
-                d = bq->write_index + chunk.length - q->index;
+                d = (size_t) (bq->write_index + (int64_t) chunk.length - q->index);
                 pa_assert(d > 0);
 
                 /* Drop it from the new entry */
-                p->index = q->index + d;
+                p->index = q->index + (int64_t) d;
                 p->chunk.length -= d;
 
                 /* Add it to the list */
@@ -339,7 +340,7 @@ int pa_memblockq_push(pa_memblockq* bq, const pa_memchunk *uchunk) {
             }
 
             /* Truncate the chunk */
-            if (!(q->chunk.length = bq->write_index - q->index)) {
+            if (!(q->chunk.length = (size_t) (bq->write_index - q->index))) {
                 struct list_item *p;
                 p = q;
                 q = q->prev;
@@ -357,8 +358,8 @@ int pa_memblockq_push(pa_memblockq* bq, const pa_memchunk *uchunk) {
 
             /* The job overwrites the current entry at the end, so let's drop the beginning of this entry */
 
-            d = bq->write_index + chunk.length - q->index;
-            q->index += d;
+            d = (size_t) (bq->write_index + (int64_t) chunk.length - q->index);
+            q->index += (int64_t) d;
             q->chunk.index += d;
             q->chunk.length -= d;
 
@@ -373,11 +374,11 @@ int pa_memblockq_push(pa_memblockq* bq, const pa_memchunk *uchunk) {
         /* Try to merge memory blocks */
 
         if (q->chunk.memblock == chunk.memblock &&
-            q->chunk.index + (int64_t)q->chunk.length == chunk.index &&
-            bq->write_index == q->index + (int64_t)q->chunk.length) {
+            q->chunk.index + q->chunk.length == chunk.index &&
+            bq->write_index == q->index + (int64_t) q->chunk.length) {
 
             q->chunk.length += chunk.length;
-            bq->write_index += chunk.length;
+            bq->write_index += (int64_t) chunk.length;
             goto finish;
         }
     } else
@@ -389,7 +390,7 @@ int pa_memblockq_push(pa_memblockq* bq, const pa_memchunk *uchunk) {
     n->chunk = chunk;
     pa_memblock_ref(n->chunk.memblock);
     n->index = bq->write_index;
-    bq->write_index += n->chunk.length;
+    bq->write_index += (int64_t) n->chunk.length;
 
     n->next = q ? q->next : bq->blocks;
     n->prev = q;
@@ -411,10 +412,10 @@ finish:
     delta = bq->write_index - old;
 
     if (delta >= (int64_t) bq->requested) {
-        delta -= bq->requested;
+        delta -= (int64_t) bq->requested;
         bq->requested = 0;
     } else {
-        bq->requested -= delta;
+        bq->requested -= (size_t) delta;
         delta = 0;
     }
 
@@ -471,7 +472,7 @@ int pa_memblockq_peek(pa_memblockq* bq, pa_memchunk *chunk) {
 
         /* How much silence shall we return? */
         if (bq->current_read)
-            length = bq->current_read->index - bq->read_index;
+            length = (size_t) (bq->current_read->index - bq->read_index);
         else if (bq->write_index > bq->read_index)
             length = (size_t) (bq->write_index - bq->read_index);
         else
@@ -506,8 +507,8 @@ int pa_memblockq_peek(pa_memblockq* bq, pa_memchunk *chunk) {
 
     pa_assert(bq->read_index >= bq->current_read->index);
     d = bq->read_index - bq->current_read->index;
-    chunk->index += d;
-    chunk->length -= d;
+    chunk->index += (size_t) d;
+    chunk->length -= (size_t) d;
 
     return 0;
 }
@@ -533,20 +534,20 @@ void pa_memblockq_drop(pa_memblockq *bq, size_t length) {
             /* We go through this piece by piece to make sure we don't
              * drop more than allowed by prebuf */
 
-            p = bq->current_read->index + bq->current_read->chunk.length;
+            p = bq->current_read->index + (int64_t) bq->current_read->chunk.length;
             pa_assert(p >= bq->read_index);
             d = p - bq->read_index;
 
             if (d > (int64_t) length)
-                d = length;
+                d = (int64_t) length;
 
             bq->read_index += d;
-            length -= d;
+            length -= (size_t) d;
 
         } else {
 
             /* The list is empty, there's nothing we could drop */
-            bq->read_index += length;
+            bq->read_index += (int64_t) length;
             break;
         }
     }
@@ -563,8 +564,8 @@ void pa_memblockq_rewind(pa_memblockq *bq, size_t length) {
 
     /* This is kind of the inverse of pa_memblockq_drop() */
 
-    bq->read_index -= length;
-    bq->missing -= length;
+    bq->read_index -= (int64_t) length;
+    bq->missing -= (int64_t) length;
 }
 
 pa_bool_t pa_memblockq_is_readable(pa_memblockq *bq) {
@@ -628,10 +629,10 @@ void pa_memblockq_seek(pa_memblockq *bq, int64_t offset, pa_seek_mode_t seek) {
     delta = bq->write_index - old;
 
     if (delta >= (int64_t) bq->requested) {
-        delta -= bq->requested;
+        delta -= (int64_t) bq->requested;
         bq->requested = 0;
     } else if (delta >= 0) {
-        bq->requested -= delta;
+        bq->requested -= (size_t) delta;
         delta = 0;
     }
 
@@ -652,10 +653,10 @@ void pa_memblockq_flush_write(pa_memblockq *bq) {
     delta = bq->write_index - old;
 
     if (delta >= (int64_t) bq->requested) {
-        delta -= bq->requested;
+        delta -= (int64_t) bq->requested;
         bq->requested = 0;
     } else if (delta >= 0) {
-        bq->requested -= delta;
+        bq->requested -= (size_t) delta;
         delta = 0;
     }
 
@@ -874,7 +875,7 @@ int pa_memblockq_splice(pa_memblockq *bq, pa_memblockq *source) {
 
             pa_memblock_unref(chunk.memblock);
         } else
-            pa_memblockq_seek(bq, chunk.length, PA_SEEK_RELATIVE);
+            pa_memblockq_seek(bq, (int64_t) chunk.length, PA_SEEK_RELATIVE);
 
         pa_memblockq_drop(bq, chunk.length);
     }
diff --git a/src/pulsecore/namereg.c b/src/pulsecore/namereg.c
index 30420546..ad697ed5 100644
--- a/src/pulsecore/namereg.c
+++ b/src/pulsecore/namereg.c
@@ -45,7 +45,7 @@ struct namereg_entry {
     void *data;
 };
 
-static int is_valid_char(char c) {
+static pa_bool_t is_valid_char(char c) {
     return
         (c >= 'a' && c <= 'z') ||
         (c >= 'A' && c <= 'Z') ||
@@ -77,10 +77,10 @@ char* pa_namereg_make_valid_name(const char *name) {
     if (*name == 0)
         return NULL;
 
-    n = pa_xnew(char, strlen(name)+1);
+    n = pa_xmalloc(strlen(name)+1);
 
     for (a = name, b = n; *a && (a-name < PA_NAME_MAX); a++, b++)
-        *b = is_valid_char(*a) ? *a : '_';
+        *b = (char) (is_valid_char(*a) ? *a : '_');
 
     *b = 0;
 
@@ -136,7 +136,7 @@ const char *pa_namereg_register(pa_core *c, const char *name, pa_namereg_type_t
             return NULL;
         }
 
-        k = pa_xnew(char, l+4);
+        k = pa_xmalloc(l+4);
 
         for (i = 2; i <= 99; i++) {
             pa_snprintf(k, l+4, "%s.%u", name, i);
diff --git a/src/pulsecore/parseaddr.c b/src/pulsecore/parseaddr.c
index f2b6b2cf..c5cd7fe7 100644
--- a/src/pulsecore/parseaddr.c
+++ b/src/pulsecore/parseaddr.c
@@ -51,20 +51,29 @@ static char *parse_host(const char *s, uint16_t *ret_port) {
         if (!(e = strchr(s+1, ']')))
             return NULL;
 
-        if (e[1] == ':')
-            *ret_port = atoi(e+2);
-        else if (e[1] != 0)
+        if (e[1] == ':') {
+            uint32_t p;
+
+            if (pa_atou(e+2, &p) < 0)
+                return NULL;
+
+            *ret_port = (uint16_t) p;
+        } else if (e[1] != 0)
             return NULL;
 
-        return pa_xstrndup(s+1, e-s-1);
+        return pa_xstrndup(s+1, (size_t) (e-s-1));
     } else {
         char *e;
+        uint32_t p;
 
         if (!(e = strrchr(s, ':')))
             return pa_xstrdup(s);
 
-        *ret_port = atoi(e+1);
-        return pa_xstrndup(s, e-s);
+        if (pa_atou(e+1, &p) < 0)
+            return NULL;
+
+        *ret_port = (uint16_t) p;
+        return pa_xstrndup(s, (size_t) (e-s));
     }
 }
 
diff --git a/src/pulsecore/pid.c b/src/pulsecore/pid.c
index 81148da4..1c0851ba 100644
--- a/src/pulsecore/pid.c
+++ b/src/pulsecore/pid.c
@@ -182,9 +182,11 @@ static int proc_name_ours(pid_t pid, const char *procname) {
 
         return !!good;
     }
-#endif
+#else
 
     return 1;
+#endif
+
 }
 
 /* Create a new PID file for the current process. */
diff --git a/src/pulsecore/protocol-esound.c b/src/pulsecore/protocol-esound.c
index 36d1b458..460119a9 100644
--- a/src/pulsecore/protocol-esound.c
+++ b/src/pulsecore/protocol-esound.c
@@ -184,7 +184,7 @@ static struct proto_handler proto_map[ESD_PROTO_MAX] = {
     { sizeof(int),                    esd_proto_sample_free_or_play, "sample play" },                /* 8 */
     { sizeof(int),                    NULL, "sample loop" },
     { sizeof(int),                    NULL, "sample stop" },
-    { -1,                             NULL, "TODO: sample kill" },
+    { (size_t) -1,                    NULL, "TODO: sample kill" },
 
     { ESD_KEY_LEN + sizeof(int),      esd_proto_standby_or_resume, "standby" },  /* NOOP! */
     { ESD_KEY_LEN + sizeof(int),      esd_proto_standby_or_resume, "resume" },   /* NOOP! */         /* 13 */
@@ -194,8 +194,8 @@ static struct proto_handler proto_map[ESD_PROTO_MAX] = {
 
     { sizeof(int),                    esd_proto_server_info, "server info" },
     { sizeof(int),                    esd_proto_all_info, "all info" },
-    { -1,                             NULL, "TODO: subscribe" },
-    { -1,                             NULL, "TODO: unsubscribe" },
+    { (size_t) -1,                    NULL, "TODO: subscribe" },
+    { (size_t) -1,                    NULL, "TODO: unsubscribe" },
 
     { 3 * sizeof(int),                esd_proto_stream_pan, "stream pan"},
     { 3 * sizeof(int),                NULL, "sample pan" },
@@ -309,7 +309,7 @@ static void connection_write(connection *c, const void *data, size_t length) {
 static void format_esd2native(int format, pa_bool_t swap_bytes, pa_sample_spec *ss) {
     pa_assert(ss);
 
-    ss->channels = ((format & ESD_MASK_CHAN) == ESD_STEREO) ? 2 : 1;
+    ss->channels = (uint8_t) (((format & ESD_MASK_CHAN) == ESD_STEREO) ? 2 : 1);
     if ((format & ESD_MASK_BITS) == ESD_BITS16)
         ss->format = swap_bytes ? PA_SAMPLE_S16RE : PA_SAMPLE_S16NE;
     else
@@ -397,7 +397,7 @@ static int esd_proto_stream_play(connection *c, esd_proto_t request, const void
     rate = PA_MAYBE_INT32_SWAP(c->swap_byte_order, rate);
     data = (const char*) data + sizeof(int32_t);
 
-    ss.rate = rate;
+    ss.rate = (uint32_t) rate;
     format_esd2native(format, c->swap_byte_order, &ss);
 
     CHECK_VALIDITY(pa_sample_spec_valid(&ss), "Invalid sample specification");
@@ -430,7 +430,7 @@ static int esd_proto_stream_play(connection *c, esd_proto_t request, const void
 
     CHECK_VALIDITY(c->sink_input, "Failed to create sink input.");
 
-    l = (size_t) (pa_bytes_per_second(&ss)*PLAYBACK_BUFFER_SECONDS);
+    l = (size_t) ((double) pa_bytes_per_second(&ss)*PLAYBACK_BUFFER_SECONDS);
     c->input_memblockq = pa_memblockq_new(
             0,
             l,
@@ -455,7 +455,7 @@ static int esd_proto_stream_play(connection *c, esd_proto_t request, const void
 
     c->protocol->n_player++;
 
-    pa_atomic_store(&c->playback.missing, pa_memblockq_missing(c->input_memblockq));
+    pa_atomic_store(&c->playback.missing, (int) pa_memblockq_missing(c->input_memblockq));
 
     pa_sink_input_put(c->sink_input);
 
@@ -482,7 +482,7 @@ static int esd_proto_stream_record(connection *c, esd_proto_t request, const voi
     rate = PA_MAYBE_INT32_SWAP(c->swap_byte_order, rate);
     data = (const char*) data + sizeof(int32_t);
 
-    ss.rate = rate;
+    ss.rate = (uint32_t) rate;
     format_esd2native(format, c->swap_byte_order, &ss);
 
     CHECK_VALIDITY(pa_sample_spec_valid(&ss), "Invalid sample specification.");
@@ -572,7 +572,7 @@ static int esd_proto_get_latency(connection *c, esd_proto_t request, const void
     if (!(sink = pa_namereg_get(c->protocol->core, c->options->default_sink, PA_NAMEREG_SINK, 1)))
         latency = 0;
     else {
-        double usec = pa_sink_get_latency(sink);
+        double usec = (double) pa_sink_get_latency(sink);
         latency = (int) ((usec*44100)/1000000);
     }
 
@@ -591,7 +591,7 @@ static int esd_proto_server_info(connection *c, esd_proto_t request, const void
     pa_assert(length == sizeof(int32_t));
 
     if ((sink = pa_namereg_get(c->protocol->core, c->options->default_sink, PA_NAMEREG_SINK, 1))) {
-        rate = sink->sample_spec.rate;
+        rate = (int32_t) sink->sample_spec.rate;
         format = format_native2esd(&sink->sample_spec);
     }
 
@@ -641,9 +641,9 @@ static int esd_proto_all_info(connection *c, esd_proto_t request, const void *da
 
         if (conn->sink_input) {
             pa_cvolume volume = *pa_sink_input_get_volume(conn->sink_input);
-            rate = conn->sink_input->sample_spec.rate;
-            lvolume = (volume.values[0]*ESD_VOLUME_BASE)/PA_VOLUME_NORM;
-            rvolume = (volume.values[1]*ESD_VOLUME_BASE)/PA_VOLUME_NORM;
+            rate = (int32_t) conn->sink_input->sample_spec.rate;
+            lvolume = (int32_t) ((volume.values[0]*ESD_VOLUME_BASE)/PA_VOLUME_NORM);
+            rvolume = (int32_t) ((volume.values[1]*ESD_VOLUME_BASE)/PA_VOLUME_NORM);
             format = format_native2esd(&conn->sink_input->sample_spec);
         }
 
@@ -706,15 +706,15 @@ static int esd_proto_all_info(connection *c, esd_proto_t request, const void *da
             connection_write(c, name, ESD_NAME_MAX);
 
             /* rate */
-            rate = PA_MAYBE_UINT32_SWAP(c->swap_byte_order, ce->sample_spec.rate);
+            rate = PA_MAYBE_INT32_SWAP(c->swap_byte_order, (int32_t) ce->sample_spec.rate);
             connection_write(c, &rate, sizeof(int32_t));
 
             /* left */
-            lvolume = PA_MAYBE_UINT32_SWAP(c->swap_byte_order, (ce->volume.values[0]*ESD_VOLUME_BASE)/PA_VOLUME_NORM);
+            lvolume = PA_MAYBE_INT32_SWAP(c->swap_byte_order, (int32_t) ((ce->volume.values[0]*ESD_VOLUME_BASE)/PA_VOLUME_NORM));
             connection_write(c, &lvolume, sizeof(int32_t));
 
             /*right*/
-            rvolume = PA_MAYBE_UINT32_SWAP(c->swap_byte_order, (ce->volume.values[0]*ESD_VOLUME_BASE)/PA_VOLUME_NORM);
+            rvolume = PA_MAYBE_INT32_SWAP(c->swap_byte_order, (int32_t) ((ce->volume.values[0]*ESD_VOLUME_BASE)/PA_VOLUME_NORM));
             connection_write(c, &rvolume, sizeof(int32_t));
 
             /*format*/
@@ -790,7 +790,7 @@ static int esd_proto_sample_cache(connection *c, esd_proto_t request, const void
     rate = PA_MAYBE_INT32_SWAP(c->swap_byte_order, rate);
     data = (const char*)data + sizeof(int32_t);
 
-    ss.rate = rate;
+    ss.rate = (uint32_t) rate;
     format_esd2native(format, c->swap_byte_order, &ss);
 
     CHECK_VALIDITY(pa_sample_spec_valid(&ss), "Invalid sample specification.");
@@ -807,9 +807,9 @@ static int esd_proto_sample_cache(connection *c, esd_proto_t request, const void
     CHECK_VALIDITY(pa_utf8_valid(name), "Invalid UTF8 in sample name.");
 
     pa_assert(!c->scache.memchunk.memblock);
-    c->scache.memchunk.memblock = pa_memblock_new(c->protocol->core->mempool, sc_length);
+    c->scache.memchunk.memblock = pa_memblock_new(c->protocol->core->mempool, (size_t) sc_length);
     c->scache.memchunk.index = 0;
-    c->scache.memchunk.length = sc_length;
+    c->scache.memchunk.length = (size_t) sc_length;
     c->scache.sample_spec = ss;
     pa_assert(!c->scache.name);
     c->scache.name = pa_xstrdup(name);
@@ -840,7 +840,7 @@ static int esd_proto_sample_get_id(connection *c, esd_proto_t request, const voi
 
     ok = -1;
     if ((idx = pa_scache_get_id_by_name(c->protocol->core, name)) != PA_IDXSET_INVALID)
-        ok = idx + 1;
+        ok = (int32_t) idx + 1;
 
     connection_write(c, &ok, sizeof(int32_t));
 
@@ -867,12 +867,12 @@ static int esd_proto_sample_free_or_play(connection *c, esd_proto_t request, con
 
             if ((sink = pa_namereg_get(c->protocol->core, c->options->default_sink, PA_NAMEREG_SINK, 1)))
                 if (pa_scache_play_item(c->protocol->core, name, sink, PA_VOLUME_NORM, c->client->proplist, NULL) >= 0)
-                    ok = idx + 1;
+                    ok = (int32_t) idx + 1;
         } else {
             pa_assert(request == ESD_PROTO_SAMPLE_FREE);
 
             if (pa_scache_remove_item(c->protocol->core, name) >= 0)
-                ok = idx + 1;
+                ok = (int32_t) idx + 1;
         }
     }
 
@@ -919,7 +919,9 @@ static int do_read(connection *c) {
             return -1;
         }
 
-        if ((c->read_data_length+= r) >= sizeof(c->request)) {
+        c->read_data_length += (size_t) r;
+
+        if (c->read_data_length >= sizeof(c->request)) {
             struct proto_handler *handler;
 
             c->request = PA_MAYBE_INT32_SWAP(c->swap_byte_order, c->request);
@@ -970,7 +972,8 @@ static int do_read(connection *c) {
             return -1;
         }
 
-        if ((c->read_data_length += r) >= handler->data_length) {
+        c->read_data_length += (size_t) r;
+        if (c->read_data_length >= handler->data_length) {
             size_t l = c->read_data_length;
             pa_assert(handler->proc);
 
@@ -1000,7 +1003,7 @@ static int do_read(connection *c) {
             return -1;
         }
 
-        c->scache.memchunk.index += r;
+        c->scache.memchunk.index += (size_t) r;
         pa_assert(c->scache.memchunk.index <= c->scache.memchunk.length);
 
         if (c->scache.memchunk.index == c->scache.memchunk.length) {
@@ -1033,7 +1036,7 @@ static int do_read(connection *c) {
 
 /*         pa_log("STREAMING_DATA"); */
 
-        if (!(l = pa_atomic_load(&c->playback.missing)))
+        if (!(l = (size_t) pa_atomic_load(&c->playback.missing)))
             return 0;
 
         if (c->playback.current_memblock) {
@@ -1071,12 +1074,12 @@ static int do_read(connection *c) {
 
         chunk.memblock = c->playback.current_memblock;
         chunk.index = c->playback.memblock_index;
-        chunk.length = r;
+        chunk.length = (size_t) r;
 
-        c->playback.memblock_index += r;
+        c->playback.memblock_index += (size_t) r;
 
         pa_asyncmsgq_post(c->sink_input->sink->asyncmsgq, PA_MSGOBJECT(c->sink_input), SINK_INPUT_MESSAGE_POST_DATA, NULL, 0, &chunk, NULL);
-        pa_atomic_sub(&c->playback.missing, r);
+        pa_atomic_sub(&c->playback.missing, (int) r);
     }
 
     return 0;
@@ -1100,7 +1103,8 @@ static int do_write(connection *c) {
             return -1;
         }
 
-        if ((c->write_data_index +=r) >= c->write_data_length)
+        c->write_data_index += (size_t) r;
+        if (c->write_data_index >= c->write_data_length)
             c->write_data_length = c->write_data_index = 0;
 
     } else if (c->state == ESD_STREAMING_DATA && c->source_output) {
@@ -1129,7 +1133,7 @@ static int do_write(connection *c) {
             return -1;
         }
 
-        pa_memblockq_drop(c->output_memblockq, r);
+        pa_memblockq_drop(c->output_memblockq, (size_t) r);
     }
 
     return 0;
@@ -1288,7 +1292,7 @@ static int sink_input_pop_cb(pa_sink_input *i, size_t length, pa_memchunk *chunk
         m = pa_memblockq_pop_missing(c->input_memblockq);
 
         if (m > 0)
-            if (pa_atomic_add(&c->playback.missing, m) <= 0)
+            if (pa_atomic_add(&c->playback.missing, (int) m) <= 0)
                 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(c), CONNECTION_MESSAGE_REQUEST_DATA, NULL, 0, NULL, NULL);
 
         return 0;
diff --git a/src/pulsecore/protocol-native.c b/src/pulsecore/protocol-native.c
index b7466022..d4694a05 100644
--- a/src/pulsecore/protocol-native.c
+++ b/src/pulsecore/protocol-native.c
@@ -477,12 +477,12 @@ static void fix_record_buffer_attr_pre(record_stream *s, pa_bool_t adjust_latenc
     if (*maxlength == (uint32_t) -1 || *maxlength > MAX_MEMBLOCKQ_LENGTH)
         *maxlength = MAX_MEMBLOCKQ_LENGTH;
     if (*maxlength <= 0)
-        *maxlength = pa_frame_size(&s->source_output->sample_spec);
+        *maxlength = (uint32_t) pa_frame_size(&s->source_output->sample_spec);
 
     if (*fragsize == (uint32_t) -1)
-        *fragsize = pa_usec_to_bytes(DEFAULT_FRAGSIZE_MSEC*PA_USEC_PER_MSEC, &s->source_output->sample_spec);
+        *fragsize = (uint32_t) pa_usec_to_bytes(DEFAULT_FRAGSIZE_MSEC*PA_USEC_PER_MSEC, &s->source_output->sample_spec);
     if (*fragsize <= 0)
-        *fragsize = pa_frame_size(&s->source_output->sample_spec);
+        *fragsize = (uint32_t) pa_frame_size(&s->source_output->sample_spec);
 
     if (adjust_latency) {
         pa_usec_t fragsize_usec;
@@ -501,7 +501,7 @@ static void fix_record_buffer_attr_pre(record_stream *s, pa_bool_t adjust_latenc
         else
             fragsize_usec = s->source_latency;
 
-        *fragsize = pa_usec_to_bytes(fragsize_usec, &s->source_output->sample_spec);
+        *fragsize = (uint32_t) pa_usec_to_bytes(fragsize_usec, &s->source_output->sample_spec);
     } else
         s->source_latency = 0;
 }
@@ -513,7 +513,7 @@ static void fix_record_buffer_attr_post(record_stream *s, uint32_t *maxlength, u
     pa_assert(maxlength);
     pa_assert(fragsize);
 
-    *maxlength = pa_memblockq_get_maxlength(s->memblockq);
+    *maxlength = (uint32_t) pa_memblockq_get_maxlength(s->memblockq);
 
     base = pa_frame_size(&s->source_output->sample_spec);
 
@@ -524,7 +524,7 @@ static void fix_record_buffer_attr_post(record_stream *s, uint32_t *maxlength, u
     if (s->fragment_size > *maxlength)
         s->fragment_size = *maxlength;
 
-    *fragsize = s->fragment_size;
+    *fragsize = (uint32_t) s->fragment_size;
 }
 
 static record_stream* record_stream_new(
@@ -666,10 +666,10 @@ static int playback_stream_process_msg(pa_msgobject *o, int code, void*userdata,
             uint32_t l = 0;
 
             for (;;) {
-                if ((l = pa_atomic_load(&s->missing)) <= 0)
+                if ((l = (uint32_t) pa_atomic_load(&s->missing)) <= 0)
                     break;
 
-                if (pa_atomic_cmpxchg(&s->missing, l, 0))
+                if (pa_atomic_cmpxchg(&s->missing, (int) l, 0))
                     break;
             }
 
@@ -749,20 +749,20 @@ static void fix_playback_buffer_attr_pre(playback_stream *s, pa_bool_t adjust_la
     if (*maxlength == (uint32_t) -1 || *maxlength > MAX_MEMBLOCKQ_LENGTH)
         *maxlength = MAX_MEMBLOCKQ_LENGTH;
     if (*maxlength <= 0)
-        *maxlength = frame_size;
+        *maxlength = (uint32_t) frame_size;
 
     if (*tlength == (uint32_t) -1)
-        *tlength = pa_usec_to_bytes(DEFAULT_TLENGTH_MSEC*PA_USEC_PER_MSEC, &s->sink_input->sample_spec);
+        *tlength = (uint32_t) pa_usec_to_bytes(DEFAULT_TLENGTH_MSEC*PA_USEC_PER_MSEC, &s->sink_input->sample_spec);
     if (*tlength <= 0)
-        *tlength = frame_size;
+        *tlength = (uint32_t) frame_size;
 
     if (*minreq == (uint32_t) -1)
-        *minreq = pa_usec_to_bytes(DEFAULT_PROCESS_MSEC*PA_USEC_PER_MSEC, &s->sink_input->sample_spec);
+        *minreq = (uint32_t) pa_usec_to_bytes(DEFAULT_PROCESS_MSEC*PA_USEC_PER_MSEC, &s->sink_input->sample_spec);
     if (*minreq <= 0)
-        *minreq = frame_size;
+        *minreq = (uint32_t) frame_size;
 
     if (*tlength < *minreq+frame_size)
-        *tlength = *minreq+frame_size;
+        *tlength = *minreq+(uint32_t) frame_size;
 
     tlength_usec = pa_bytes_to_usec(*tlength, &s->sink_input->sample_spec);
     minreq_usec = pa_bytes_to_usec(*minreq, &s->sink_input->sample_spec);
@@ -823,16 +823,16 @@ static void fix_playback_buffer_attr_pre(playback_stream *s, pa_bool_t adjust_la
     if (tlength_usec < s->sink_latency + 2*minreq_usec)
         tlength_usec = s->sink_latency + 2*minreq_usec;
 
-    *tlength = pa_usec_to_bytes(tlength_usec, &s->sink_input->sample_spec);
-    *minreq = pa_usec_to_bytes(minreq_usec, &s->sink_input->sample_spec);
+    *tlength = (uint32_t) pa_usec_to_bytes(tlength_usec, &s->sink_input->sample_spec);
+    *minreq = (uint32_t) pa_usec_to_bytes(minreq_usec, &s->sink_input->sample_spec);
 
     if (*minreq <= 0) {
-        *minreq += frame_size;
-        *tlength += frame_size*2;
+        *minreq += (uint32_t) frame_size;
+        *tlength += (uint32_t) frame_size*2;
     }
 
     if (*tlength <= *minreq)
-        *tlength =  *minreq*2 + frame_size;
+        *tlength = *minreq*2 + (uint32_t) frame_size;
 
     if (*prebuf == (uint32_t) -1 || *prebuf > *tlength)
         *prebuf = *tlength;
@@ -996,7 +996,7 @@ static void playback_stream_request_bytes(playback_stream *s) {
 
 /*     pa_log("request_bytes(%lu)", (unsigned long) m); */
 
-    previous_missing = pa_atomic_add(&s->missing, m);
+    previous_missing = (size_t) pa_atomic_add(&s->missing, (int) m);
 
     if (pa_memblockq_prebuf_active(s->memblockq) ||
         (previous_missing < s->minreq && previous_missing+m >= s->minreq))
@@ -1156,7 +1156,7 @@ static void handle_seek(playback_stream *s, int64_t indexw) {
              * let's have it usk us again */
 
             pa_log_debug("Requesting rewind due to rewrite.");
-            pa_sink_input_request_rewind(s->sink_input, indexr - indexw, TRUE, FALSE);
+            pa_sink_input_request_rewind(s->sink_input, (size_t) (indexr - indexw), TRUE, FALSE);
         }
     }
 
@@ -1196,7 +1196,7 @@ static int sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int
             if (pa_memblockq_push_align(s->memblockq, chunk) < 0) {
                 pa_log_warn("Failed to push data into queue");
                 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_OVERFLOW, NULL, 0, NULL, NULL);
-                pa_memblockq_seek(s->memblockq, chunk->length, PA_SEEK_RELATIVE);
+                pa_memblockq_seek(s->memblockq, (int64_t) chunk->length, PA_SEEK_RELATIVE);
             }
 
             handle_seek(s, windex);
@@ -2239,7 +2239,7 @@ static void command_stat(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_ta
     pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->allocated_size));
     pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->n_accumulated));
     pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->accumulated_size));
-    pa_tagstruct_putu32(reply, pa_scache_total_size(c->protocol->core));
+    pa_tagstruct_putu32(reply, (uint32_t) pa_scache_total_size(c->protocol->core));
     pa_pstream_send_tagstruct(c->pstream, reply);
 }
 
@@ -2593,7 +2593,7 @@ static void module_fill_tagstruct(pa_tagstruct *t, pa_module *module) {
     pa_tagstruct_putu32(t, module->index);
     pa_tagstruct_puts(t, module->name);
     pa_tagstruct_puts(t, module->argument);
-    pa_tagstruct_putu32(t, module->n_used);
+    pa_tagstruct_putu32(t, (uint32_t) module->n_used);
     pa_tagstruct_put_boolean(t, module->auto_unload);
 }
 
@@ -2666,7 +2666,7 @@ static void scache_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_s
     pa_tagstruct_put_usec(t, e->memchunk.memblock ? pa_bytes_to_usec(e->memchunk.length, &e->sample_spec) : 0);
     pa_tagstruct_put_sample_spec(t, &fixed_ss);
     pa_tagstruct_put_channel_map(t, &e->channel_map);
-    pa_tagstruct_putu32(t, e->memchunk.length);
+    pa_tagstruct_putu32(t, (uint32_t) e->memchunk.length);
     pa_tagstruct_put_boolean(t, e->lazy);
     pa_tagstruct_puts(t, e->filename);
 
@@ -3412,7 +3412,7 @@ static void command_remove_proplist(pa_pdispatch *pd, uint32_t command, uint32_t
         if (!z)
             break;
 
-        changed += pa_proplist_unset(p, z) >= 0;
+        changed += (unsigned) (pa_proplist_unset(p, z) >= 0);
         pa_xfree(z);
     }
 
@@ -3669,7 +3669,7 @@ static void autoload_fill_tagstruct(pa_tagstruct *t, const pa_autoload_entry *e)
 
     pa_tagstruct_putu32(t, e->index);
     pa_tagstruct_puts(t, e->name);
-    pa_tagstruct_putu32(t, e->type == PA_NAMEREG_SINK ? 0 : 1);
+    pa_tagstruct_putu32(t, e->type == PA_NAMEREG_SINK ? 0U : 1U);
     pa_tagstruct_puts(t, e->module);
     pa_tagstruct_puts(t, e->argument);
 }
diff --git a/src/pulsecore/protocol-simple.c b/src/pulsecore/protocol-simple.c
index 78874bb9..65e67737 100644
--- a/src/pulsecore/protocol-simple.c
+++ b/src/pulsecore/protocol-simple.c
@@ -159,7 +159,7 @@ static int do_read(connection *c) {
 
     connection_assert_ref(c);
 
-    if (!c->sink_input || (l = pa_atomic_load(&c->playback.missing)) <= 0)
+    if (!c->sink_input || (l = (size_t) pa_atomic_load(&c->playback.missing)) <= 0)
         return 0;
 
     if (c->playback.current_memblock) {
@@ -197,12 +197,12 @@ static int do_read(connection *c) {
 
     chunk.memblock = c->playback.current_memblock;
     chunk.index = c->playback.memblock_index;
-    chunk.length = r;
+    chunk.length = (size_t) r;
 
-    c->playback.memblock_index += r;
+    c->playback.memblock_index += (size_t) r;
 
     pa_asyncmsgq_post(c->sink_input->sink->asyncmsgq, PA_MSGOBJECT(c->sink_input), SINK_INPUT_MESSAGE_POST_DATA, NULL, 0, &chunk, NULL);
-    pa_atomic_sub(&c->playback.missing, r);
+    pa_atomic_sub(&c->playback.missing, (int) r);
 
     return 0;
 }
@@ -240,7 +240,7 @@ static int do_write(connection *c) {
         return -1;
     }
 
-    pa_memblockq_drop(c->output_memblockq, r);
+    pa_memblockq_drop(c->output_memblockq, (size_t) r);
 
     return 0;
 }
@@ -377,7 +377,7 @@ static int sink_input_pop_cb(pa_sink_input *i, size_t length, pa_memchunk *chunk
         m = pa_memblockq_pop_missing(c->input_memblockq);
 
         if (m > 0)
-            if (pa_atomic_add(&c->playback.missing, m) <= 0)
+            if (pa_atomic_add(&c->playback.missing, (int) m) <= 0)
                 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(c), CONNECTION_MESSAGE_REQUEST_DATA, NULL, 0, NULL, NULL);
 
         return 0;
@@ -546,7 +546,7 @@ void pa_simple_protocol_connect(pa_simple_protocol *p, pa_iochannel *io, pa_simp
 
         pa_sink_input_set_requested_latency(c->sink_input, DEFAULT_SINK_LATENCY);
 
-        l = (size_t) (pa_bytes_per_second(&o->sample_spec)*PLAYBACK_BUFFER_SECONDS);
+        l = (size_t) ((double) pa_bytes_per_second(&o->sample_spec)*PLAYBACK_BUFFER_SECONDS);
         c->input_memblockq = pa_memblockq_new(
                 0,
                 l,
@@ -558,7 +558,7 @@ void pa_simple_protocol_connect(pa_simple_protocol *p, pa_iochannel *io, pa_simp
                 NULL);
         pa_iochannel_socket_set_rcvbuf(io, l);
 
-        pa_atomic_store(&c->playback.missing, pa_memblockq_missing(c->input_memblockq));
+        pa_atomic_store(&c->playback.missing, (int) pa_memblockq_missing(c->input_memblockq));
 
         pa_sink_input_put(c->sink_input);
     }
diff --git a/src/pulsecore/pstream.c b/src/pulsecore/pstream.c
index 48404cca..7ff8edc9 100644
--- a/src/pulsecore/pstream.c
+++ b/src/pulsecore/pstream.c
@@ -488,7 +488,7 @@ static void prepare_next_write_item(pa_pstream *p) {
 
         pa_assert(p->write.current->packet);
         p->write.data = p->write.current->packet->data;
-        p->write.descriptor[PA_PSTREAM_DESCRIPTOR_LENGTH] = htonl(p->write.current->packet->length);
+        p->write.descriptor[PA_PSTREAM_DESCRIPTOR_LENGTH] = htonl((uint32_t) p->write.current->packet->length);
 
     } else if (p->write.current->type == PA_PSTREAM_ITEM_SHMRELEASE) {
 
@@ -511,7 +511,7 @@ static void prepare_next_write_item(pa_pstream *p) {
         p->write.descriptor[PA_PSTREAM_DESCRIPTOR_OFFSET_HI] = htonl((uint32_t) (((uint64_t) p->write.current->offset) >> 32));
         p->write.descriptor[PA_PSTREAM_DESCRIPTOR_OFFSET_LO] = htonl((uint32_t) ((uint64_t) p->write.current->offset));
 
-        flags = p->write.current->seek_mode & PA_FLAG_SEEKMASK;
+        flags = (uint32_t) (p->write.current->seek_mode & PA_FLAG_SEEKMASK);
 
         if (p->use_shm) {
             uint32_t block_id, shm_id;
@@ -542,7 +542,7 @@ static void prepare_next_write_item(pa_pstream *p) {
         }
 
         if (send_payload) {
-            p->write.descriptor[PA_PSTREAM_DESCRIPTOR_LENGTH] = htonl(p->write.current->chunk.length);
+            p->write.descriptor[PA_PSTREAM_DESCRIPTOR_LENGTH] = htonl((uint32_t) p->write.current->chunk.length);
             p->write.memchunk = p->write.current->chunk;
             pa_memblock_ref(p->write.memchunk.memblock);
             p->write.data = NULL;
@@ -607,7 +607,7 @@ static int do_write(pa_pstream *p) {
     if (release_memblock)
         pa_memblock_release(release_memblock);
 
-    p->write.index += r;
+    p->write.index += (size_t) r;
 
     if (p->write.index >= PA_PSTREAM_DESCRIPTOR_SIZE + ntohl(p->write.descriptor[PA_PSTREAM_DESCRIPTOR_LENGTH])) {
         pa_assert(p->write.current);
@@ -675,7 +675,7 @@ static int do_read(pa_pstream *p) {
     if (release_memblock)
         pa_memblock_release(release_memblock);
 
-    p->read.index += r;
+    p->read.index += (size_t) r;
 
     if (p->read.index == PA_PSTREAM_DESCRIPTOR_SIZE) {
         uint32_t flags, length, channel;
@@ -769,7 +769,7 @@ static int do_read(pa_pstream *p) {
         if (p->read.memblock && p->recieve_memblock_callback) {
 
             /* Is this memblock data? Than pass it to the user */
-            l = (p->read.index - r) < PA_PSTREAM_DESCRIPTOR_SIZE ? p->read.index - PA_PSTREAM_DESCRIPTOR_SIZE : (size_t) r;
+            l = (p->read.index - (size_t) r) < PA_PSTREAM_DESCRIPTOR_SIZE ? (size_t) (p->read.index - PA_PSTREAM_DESCRIPTOR_SIZE) : (size_t) r;
 
             if (l > 0) {
                 pa_memchunk chunk;
diff --git a/src/pulsecore/resampler.c b/src/pulsecore/resampler.c
index c82f4c1e..ee953652 100644
--- a/src/pulsecore/resampler.c
+++ b/src/pulsecore/resampler.c
@@ -373,7 +373,7 @@ size_t pa_resampler_max_block_size(pa_resampler *r) {
 
     /* We deduce the "largest" sample spec we're using during the
      * conversion */
-    ss.channels = PA_MAX(r->i_ss.channels, r->o_ss.channels);
+    ss.channels = (uint8_t) (PA_MAX(r->i_ss.channels, r->o_ss.channels));
 
     /* We silently assume that the format enum is ordered by size */
     ss.format = PA_MAX(r->i_ss.format, r->o_ss.format);
@@ -642,7 +642,7 @@ static void calc_map_table(pa_resampler *r) {
                 if (n > 0)
                     for (ic = 0; ic < r->i_ss.channels; ic++)
                         if (on_left(r->i_cm.map[ic])) {
-                            r->map_table[oc][ic] = 1.0 / n;
+                            r->map_table[oc][ic] = 1.0f / (float) n;
                             ic_connected[ic] = TRUE;
                         }
 
@@ -663,7 +663,7 @@ static void calc_map_table(pa_resampler *r) {
                 if (n > 0)
                     for (ic = 0; ic < r->i_ss.channels; ic++)
                         if (on_right(r->i_cm.map[ic])) {
-                            r->map_table[oc][ic] = 1.0 / n;
+                            r->map_table[oc][ic] = 1.0f / (float) n;
                             ic_connected[ic] = TRUE;
                         }
 
@@ -684,7 +684,7 @@ static void calc_map_table(pa_resampler *r) {
                 if (n > 0) {
                     for (ic = 0; ic < r->i_ss.channels; ic++)
                         if (on_center(r->i_cm.map[ic])) {
-                            r->map_table[oc][ic] = 1.0 / n;
+                            r->map_table[oc][ic] = 1.0f / (float) n;
                             ic_connected[ic] = TRUE;
                         }
                 } else {
@@ -701,7 +701,7 @@ static void calc_map_table(pa_resampler *r) {
                     if (n > 0)
                         for (ic = 0; ic < r->i_ss.channels; ic++)
                             if (on_left(r->i_cm.map[ic]) || on_right(r->i_cm.map[ic])) {
-                                r->map_table[oc][ic] = 1.0 / n;
+                                r->map_table[oc][ic] = 1.0f / (float) n;
                                 ic_connected[ic] = TRUE;
                             }
 
@@ -716,7 +716,7 @@ static void calc_map_table(pa_resampler *r) {
                  * channels for LFE. */
 
                 for (ic = 0; ic < r->i_ss.channels; ic++) {
-                    r->map_table[oc][ic] = 1.0 / r->i_ss.channels;
+                    r->map_table[oc][ic] = 1.0f / (float) r->i_ss.channels;
 
                     /* Please note that a channel connected to LFE
                      * doesn't really count as connected. */
@@ -763,12 +763,12 @@ static void calc_map_table(pa_resampler *r) {
                 for (ic = 0; ic < r->i_ss.channels; ic++) {
 
                     if (ic_connected[ic]) {
-                        r->map_table[oc][ic] *= .9;
+                        r->map_table[oc][ic] *= .9f;
                         continue;
                     }
 
                     if (on_left(r->i_cm.map[ic]))
-                        r->map_table[oc][ic] = .1 / ic_unconnected_left;
+                        r->map_table[oc][ic] = .1f / (float) ic_unconnected_left;
                 }
             }
         }
@@ -788,12 +788,12 @@ static void calc_map_table(pa_resampler *r) {
                 for (ic = 0; ic < r->i_ss.channels; ic++) {
 
                     if (ic_connected[ic]) {
-                        r->map_table[oc][ic] *= .9;
+                        r->map_table[oc][ic] *= .9f;
                         continue;
                     }
 
                     if (on_right(r->i_cm.map[ic]))
-                        r->map_table[oc][ic] = .1 / ic_unconnected_right;
+                        r->map_table[oc][ic] = .1f / (float) ic_unconnected_right;
                 }
             }
         }
@@ -814,12 +814,12 @@ static void calc_map_table(pa_resampler *r) {
                 for (ic = 0; ic < r->i_ss.channels; ic++)  {
 
                     if (ic_connected[ic]) {
-                        r->map_table[oc][ic] *= .9;
+                        r->map_table[oc][ic] *= .9f;
                         continue;
                     }
 
                     if (on_center(r->i_cm.map[ic])) {
-                        r->map_table[oc][ic] = .1 / ic_unconnected_center;
+                        r->map_table[oc][ic] = .1f / (float) ic_unconnected_center;
                         mixed_in = TRUE;
                     }
                 }
@@ -840,12 +840,12 @@ static void calc_map_table(pa_resampler *r) {
                     for (ic = 0; ic < r->i_ss.channels; ic++)  {
 
                         if (ic_connected[ic]) {
-                            r->map_table[oc][ic] *= .75;
+                            r->map_table[oc][ic] *= .75f;
                             continue;
                         }
 
                         if (on_center(r->i_cm.map[ic]))
-                            r->map_table[oc][ic] = .375 / ic_unconnected_center;
+                            r->map_table[oc][ic] = .375f / (float) ic_unconnected_center;
                     }
                 }
             }
@@ -862,7 +862,7 @@ static void calc_map_table(pa_resampler *r) {
                     continue;
 
                 for (oc = 0; oc < r->o_ss.channels; oc++)
-                    r->map_table[oc][ic] = 0.375 / ic_unconnected_lfe;
+                    r->map_table[oc][ic] = 0.375f / (float) ic_unconnected_lfe;
             }
         }
     }
@@ -905,7 +905,7 @@ static pa_memchunk* convert_to_work_format(pa_resampler *r, pa_memchunk *input)
     if (!r->to_work_format_func || !input->length)
         return input;
 
-    n_samples = (input->length / r->i_fz) * r->i_ss.channels;
+    n_samples = (unsigned) ((input->length / r->i_fz) * r->i_ss.channels);
 
     r->buf1.index = 0;
     r->buf1.length = r->w_sz * n_samples;
@@ -974,7 +974,7 @@ static pa_memchunk *remap_channels(pa_resampler *r, pa_memchunk *input) {
     if (!r->map_required || !input->length)
         return input;
 
-    in_n_samples = input->length / r->w_sz;
+    in_n_samples = (unsigned) (input->length / r->w_sz);
     n_frames = in_n_samples / r->i_ss.channels;
     out_n_samples = n_frames * r->o_ss.channels;
 
@@ -994,8 +994,8 @@ static pa_memchunk *remap_channels(pa_resampler *r, pa_memchunk *input) {
 
     memset(dst, 0, r->buf2.length);
 
-    o_skip = r->w_sz * r->o_ss.channels;
-    i_skip = r->w_sz * r->i_ss.channels;
+    o_skip = (int) (r->w_sz * r->o_ss.channels);
+    i_skip = (int) (r->w_sz * r->i_ss.channels);
 
     switch (r->work_format) {
         case PA_SAMPLE_FLOAT32NE:
@@ -1013,7 +1013,7 @@ static pa_memchunk *remap_channels(pa_resampler *r, pa_memchunk *input) {
                             (float*) dst + oc, o_skip,
                             (float*) dst + oc, o_skip,
                             (float*) src + ic, i_skip,
-                            n_frames,
+                            (int) n_frames,
                             &one, &r->map_table[oc][ic]);
                 }
             }
@@ -1037,7 +1037,7 @@ static pa_memchunk *remap_channels(pa_resampler *r, pa_memchunk *input) {
                                 (int16_t*) dst + oc, o_skip,
                                 (int16_t*) dst + oc, o_skip,
                                 (int16_t*) src + ic, i_skip,
-                                n_frames,
+                                (int) n_frames,
                                 &one, &one);
 
                     } else
@@ -1046,7 +1046,7 @@ static pa_memchunk *remap_channels(pa_resampler *r, pa_memchunk *input) {
                                 (int16_t*) dst + oc, o_skip,
                                 (int16_t*) dst + oc, o_skip,
                                 (int16_t*) src + ic, i_skip,
-                                n_frames,
+                                (int) n_frames,
                                 1.0, r->map_table[oc][ic]);
                 }
             }
@@ -1077,8 +1077,8 @@ static pa_memchunk *resample(pa_resampler *r, pa_memchunk *input) {
     if (!r->impl_resample || !input->length)
         return input;
 
-    in_n_samples = input->length / r->w_sz;
-    in_n_frames = in_n_samples / r->o_ss.channels;
+    in_n_samples = (unsigned) (input->length / r->w_sz);
+    in_n_frames = (unsigned) (in_n_samples / r->o_ss.channels);
 
     out_n_frames = ((in_n_frames*r->o_ss.rate)/r->i_ss.rate)+EXTRA_FRAMES;
     out_n_samples = out_n_frames * r->o_ss.channels;
@@ -1112,8 +1112,8 @@ static pa_memchunk *convert_from_work_format(pa_resampler *r, pa_memchunk *input
     if (!r->from_work_format_func || !input->length)
         return input;
 
-    n_samples = input->length / r->w_sz;
-    n_frames =  n_samples / r->o_ss.channels;
+    n_samples = (unsigned) (input->length / r->w_sz);
+    n_frames = n_samples / r->o_ss.channels;
 
     r->buf4.index = 0;
     r->buf4.length = r->o_fz * n_frames;
@@ -1192,7 +1192,7 @@ static void libsamplerate_resample(pa_resampler *r, const pa_memchunk *input, un
     pa_memblock_release(input->memblock);
     pa_memblock_release(output->memblock);
 
-    *out_n_frames = data.output_frames_gen;
+    *out_n_frames = (unsigned) data.output_frames_gen;
 }
 
 static void libsamplerate_update_rates(pa_resampler *r) {
@@ -1354,7 +1354,7 @@ static void trivial_resample(pa_resampler *r, const pa_memchunk *input, unsigned
         pa_assert(o_index * fz < pa_memblock_get_length(output->memblock));
 
         oil_memcpy((uint8_t*) dst + fz * o_index,
-                   (uint8_t*) src + fz * j, fz);
+                   (uint8_t*) src + fz * j, (int) fz);
     }
 
     pa_memblock_release(input->memblock);
@@ -1430,7 +1430,7 @@ static void peaks_resample(pa_resampler *r, const pa_memchunk *input, unsigned i
                 for (c = 0; c < r->o_ss.channels; c++, s++) {
                     int16_t n;
 
-                    n = *s < 0 ? -*s : *s;
+                    n = (int16_t) (*s < 0 ? -*s : *s);
 
                     if (n > r->peaks.max_i[c])
                         r->peaks.max_i[c] = n;
@@ -1523,7 +1523,7 @@ static void ffmpeg_resample(pa_resampler *r, const pa_memchunk *input, unsigned
         p = pa_memblock_acquire(b);
 
         /* Copy the remaining data into it */
-        l = r->ffmpeg.buf[c].length;
+        l = (unsigned) r->ffmpeg.buf[c].length;
         if (r->ffmpeg.buf[c].memblock) {
             t = (int16_t*) ((uint8_t*) pa_memblock_acquire(r->ffmpeg.buf[c].memblock) + r->ffmpeg.buf[c].index);
             memcpy(p, t, l);
@@ -1543,18 +1543,18 @@ static void ffmpeg_resample(pa_resampler *r, const pa_memchunk *input, unsigned
         pa_memblock_release(input->memblock);
 
         /* Calculate the resulting number of frames */
-        in = in_n_frames + l / sizeof(int16_t);
+        in = (unsigned) in_n_frames + l / (unsigned) sizeof(int16_t);
 
         /* Allocate buffer for the result */
         w = pa_memblock_new(r->mempool, *out_n_frames * sizeof(int16_t));
         q = pa_memblock_acquire(w);
 
         /* Now, resample */
-        used_frames = av_resample(r->ffmpeg.state,
-                                  q, p,
-                                  &consumed_frames,
-                                  in, *out_n_frames,
-                                  c >= (unsigned) r->o_ss.channels-1);
+        used_frames = (unsigned) av_resample(r->ffmpeg.state,
+                                             q, p,
+                                             &consumed_frames,
+                                             (int) in, (int) *out_n_frames,
+                                             c >= (unsigned) (r->o_ss.channels-1));
 
         pa_memblock_release(b);
 
@@ -1562,8 +1562,8 @@ static void ffmpeg_resample(pa_resampler *r, const pa_memchunk *input, unsigned
         pa_assert(consumed_frames <= (int) in);
         if (consumed_frames < (int) in) {
             r->ffmpeg.buf[c].memblock = b;
-            r->ffmpeg.buf[c].index = consumed_frames * sizeof(int16_t);
-            r->ffmpeg.buf[c].length = (in - consumed_frames) * sizeof(int16_t);
+            r->ffmpeg.buf[c].index = (size_t) consumed_frames * sizeof(int16_t);
+            r->ffmpeg.buf[c].length = (size_t) (in - (unsigned) consumed_frames) * sizeof(int16_t);
         } else
             pa_memblock_unref(b);
 
@@ -1605,7 +1605,7 @@ static int ffmpeg_init(pa_resampler *r) {
      * internally only uses these hardcoded values, so let's use them
      * here for now as well until ffmpeg makes this configurable. */
 
-    if (!(r->ffmpeg.state = av_resample_init(r->o_ss.rate, r->i_ss.rate, 16, 10, 0, 0.8)))
+    if (!(r->ffmpeg.state = av_resample_init((int) r->o_ss.rate, (int) r->i_ss.rate, 16, 10, 0, 0.8)))
         return -1;
 
     r->impl_free = ffmpeg_free;
diff --git a/src/pulsecore/rtpoll.c b/src/pulsecore/rtpoll.c
index a67a5516..543262bc 100644
--- a/src/pulsecore/rtpoll.c
+++ b/src/pulsecore/rtpoll.c
@@ -394,7 +394,7 @@ int pa_rtpoll_run(pa_rtpoll *p, pa_bool_t wait) {
 #endif
 
 #endif
-        r = poll(p->pollfd, p->n_pollfd_used, (!wait || p->quit || p->timer_enabled) ? (timeout.tv_sec*1000) + (timeout.tv_usec / 1000) : -1);
+        r = poll(p->pollfd, p->n_pollfd_used, (!wait || p->quit || p->timer_enabled) ? (int) ((timeout.tv_sec*1000) + (timeout.tv_usec / 1000)) : -1);
 
     if (r < 0) {
         if (errno == EAGAIN || errno == EINTR)
diff --git a/src/pulsecore/rtsig.c b/src/pulsecore/rtsig.c
index 4df217c3..4cd6aa8f 100644
--- a/src/pulsecore/rtsig.c
+++ b/src/pulsecore/rtsig.c
@@ -40,7 +40,7 @@ static void _free_rtsig(void *p) {
     pa_rtsig_put(PA_PTR_TO_INT(p));
 }
 
-PA_STATIC_FLIST_DECLARE(rtsig_flist, pa_make_power_of_two(SIGRTMAX-SIGRTMIN+1), NULL);
+PA_STATIC_FLIST_DECLARE(rtsig_flist, pa_make_power_of_two((unsigned) (SIGRTMAX-SIGRTMIN+1)), NULL);
 PA_STATIC_TLS_DECLARE(rtsig_tls, _free_rtsig);
 
 static pa_atomic_t rtsig_current = PA_ATOMIC_INIT(-1);
diff --git a/src/pulsecore/sample-util.c b/src/pulsecore/sample-util.c
index 0cdbcd02..4b2efe5e 100644
--- a/src/pulsecore/sample-util.c
+++ b/src/pulsecore/sample-util.c
@@ -85,7 +85,6 @@ static uint8_t silence_byte(pa_sample_format_t format) {
         default:
             pa_assert_not_reached();
     }
-    return 0;
 }
 
 void* pa_silence_memory(void *p, size_t length, const pa_sample_spec *spec) {
@@ -134,7 +133,7 @@ static void calc_linear_float_stream_volumes(pa_mix_info streams[], unsigned nst
 
         for (channel = 0; channel < spec->channels; channel++) {
             pa_mix_info *m = streams + k;
-            m->linear[channel].f = pa_sw_volume_to_linear(m->volume.values[channel]);
+            m->linear[channel].f = (float) pa_sw_volume_to_linear(m->volume.values[channel]);
         }
     }
 }
@@ -146,7 +145,7 @@ static void calc_linear_float_volume(float linear[], const pa_cvolume *volume) {
     pa_assert(volume);
 
     for (channel = 0; channel < volume->channels; channel++)
-        linear[channel] = pa_sw_volume_to_linear(volume->values[channel]);
+        linear[channel] = (float) pa_sw_volume_to_linear(volume->values[channel]);
 }
 
 size_t pa_mix(
@@ -412,7 +411,7 @@ size_t pa_mix(
 
                 sum = (sum * linear[channel]) / 0x10000;
                 sum = PA_CLAMP_UNLIKELY(sum, -0x8000, 0x7FFF);
-                *((uint8_t*) data) = (uint8_t) st_14linear2ulaw(sum >> 2);
+                *((uint8_t*) data) = (uint8_t) st_14linear2ulaw((int16_t) sum >> 2);
 
                 data = (uint8_t*) data + 1;
 
@@ -451,7 +450,7 @@ size_t pa_mix(
 
                 sum = (sum * linear[channel]) / 0x10000;
                 sum = PA_CLAMP_UNLIKELY(sum, -0x8000, 0x7FFF);
-                *((uint8_t*) data) = (uint8_t) st_13linear2alaw(sum >> 3);
+                *((uint8_t*) data) = (uint8_t) st_13linear2alaw((int16_t) sum >> 3);
 
                 data = (uint8_t*) data + 1;
 
@@ -707,7 +706,7 @@ void pa_volume_memchunk(
                 t = (int32_t) st_ulaw2linear16(*d);
                 t = (t * linear[channel]) / 0x10000;
                 t = PA_CLAMP_UNLIKELY(t, -0x8000, 0x7FFF);
-                *d = (uint8_t) st_14linear2ulaw(t >> 2);
+                *d = (uint8_t) st_14linear2ulaw((int16_t) t >> 2);
 
                 if (PA_UNLIKELY(++channel >= spec->channels))
                     channel = 0;
@@ -730,7 +729,7 @@ void pa_volume_memchunk(
                 t = (int32_t) st_alaw2linear16(*d);
                 t = (t * linear[channel]) / 0x10000;
                 t = PA_CLAMP_UNLIKELY(t, -0x8000, 0x7FFF);
-                *d = (uint8_t) st_13linear2alaw(t >> 3);
+                *d = (uint8_t) st_13linear2alaw((int16_t) t >> 3);
 
                 if (PA_UNLIKELY(++channel >= spec->channels))
                     channel = 0;
@@ -745,8 +744,8 @@ void pa_volume_memchunk(
             unsigned channel;
 
             d = ptr;
-            skip = spec->channels * sizeof(float);
-            n = c->length/sizeof(float)/spec->channels;
+            skip = (int) (spec->channels * sizeof(float));
+            n = (unsigned) (c->length/sizeof(float)/spec->channels);
 
             for (channel = 0; channel < spec->channels; channel ++) {
                 float v, *t;
@@ -756,7 +755,7 @@ void pa_volume_memchunk(
 
                 v = (float) pa_sw_volume_to_linear(volume->values[channel]);
                 t = d + channel;
-                oil_scalarmult_f32(t, skip, t, skip, &v, n);
+                oil_scalarmult_f32(t, skip, t, skip, &v, (int) n);
             }
             break;
         }
@@ -834,7 +833,7 @@ void pa_interleave(const void *src[], unsigned channels, void *dst, size_t ss, u
         d = (uint8_t*) dst + c * ss;
 
         for (j = 0; j < n; j ++) {
-            oil_memcpy(d, s, ss);
+            oil_memcpy(d, s, (int) ss);
             s = (uint8_t*) s + ss;
             d = (uint8_t*) d + fs;
         }
@@ -862,7 +861,7 @@ void pa_deinterleave(const void *src, void *dst[], unsigned channels, size_t ss,
         d = dst[c];
 
         for (j = 0; j < n; j ++) {
-            oil_memcpy(d, s, ss);
+            oil_memcpy(d, s, (int) ss);
             s = (uint8_t*) s + fs;
             d = (uint8_t*) d + ss;
         }
@@ -965,7 +964,7 @@ void pa_sample_clamp(pa_sample_format_t format, void *dst, size_t dstr, const vo
     if (format == PA_SAMPLE_FLOAT32NE) {
 
         float minus_one = -1.0, plus_one = 1.0;
-        oil_clip_f32(d, dstr, s, sstr, n, &minus_one, &plus_one);
+        oil_clip_f32(d, (int) dstr, s, (int) sstr, (int) n, &minus_one, &plus_one);
 
     } else {
         pa_assert(format == PA_SAMPLE_FLOAT32RE);
@@ -974,7 +973,7 @@ void pa_sample_clamp(pa_sample_format_t format, void *dst, size_t dstr, const vo
             float f;
 
             f = PA_FLOAT32_SWAP(*s);
-            f = PA_CLAMP_UNLIKELY(f, -1.0, 1.0);
+            f = PA_CLAMP_UNLIKELY(f, -1.0f, 1.0f);
             *d = PA_FLOAT32_SWAP(f);
 
             s = (const float*) ((const uint8_t*) s + sstr);
diff --git a/src/pulsecore/sconv-s16le.c b/src/pulsecore/sconv-s16le.c
index 41670f27..693d529b 100644
--- a/src/pulsecore/sconv-s16le.c
+++ b/src/pulsecore/sconv-s16le.c
@@ -70,13 +70,13 @@ void pa_sconv_s16le_to_float32ne(unsigned n, const int16_t *a, float *b) {
 
     for (; n > 0; n--) {
         int16_t s = *(a++);
-        *(b++) = ((float) INT16_FROM(s))/0x7FFF;
+        *(b++) = ((float) INT16_FROM(s))/(float) 0x7FFF;
     }
 
 #else
 {
     static const double add = 0, factor = 1.0/0x7FFF;
-    oil_scaleconv_f32_s16(b, a, n, &add, &factor);
+    oil_scaleconv_f32_s16(b, a, (int) n, &add, &factor);
 }
 #endif
 }
@@ -95,7 +95,7 @@ void pa_sconv_s32le_to_float32ne(unsigned n, const int32_t *a, float *b) {
 #else
 {
     static const double add = 0, factor = 1.0/0x7FFFFFFF;
-    oil_scaleconv_f32_s32(b, a, n, &add, &factor);
+    oil_scaleconv_f32_s32(b, a, (int) n, &add, &factor);
 }
 #endif
 }
@@ -110,7 +110,7 @@ void pa_sconv_s16le_from_float32ne(unsigned n, const float *a, int16_t *b) {
         int16_t s;
         float v = *(a++);
 
-        v = PA_CLAMP_UNLIKELY(v, -1, 1);
+        v = PA_CLAMP_UNLIKELY(v, -1.0f, 1.f);
         s = (int16_t) (v * 0x7FFF);
         *(b++) = INT16_TO(s);
     }
@@ -118,7 +118,7 @@ void pa_sconv_s16le_from_float32ne(unsigned n, const float *a, int16_t *b) {
 #else
 {
     static const double add = 0, factor = 0x7FFF;
-    oil_scaleconv_s16_f32(b, a, n, &add, &factor);
+    oil_scaleconv_s16_f32(b, a, (int) n, &add, &factor);
 }
 #endif
 }
@@ -133,7 +133,7 @@ void pa_sconv_s32le_from_float32ne(unsigned n, const float *a, int32_t *b) {
         int32_t s;
         float v = *(a++);
 
-        v = PA_CLAMP_UNLIKELY(v, -1, 1);
+        v = PA_CLAMP_UNLIKELY(v, -1.0f, 1.0f);
         s = (int32_t) ((double) v * (double) 0x7FFFFFFF);
         *(b++) = INT32_TO(s);
     }
@@ -141,7 +141,7 @@ void pa_sconv_s32le_from_float32ne(unsigned n, const float *a, int32_t *b) {
 #else
 {
     static const double add = 0, factor = 0x7FFFFFFF;
-    oil_scaleconv_s32_f32(b, a, n, &add, &factor);
+    oil_scaleconv_s32_f32(b, a, (int) n, &add, &factor);
 }
 #endif
 }
@@ -181,7 +181,7 @@ void pa_sconv_s16le_from_float32re(unsigned n, const float *a, int16_t *b) {
         float v = *(a++);
         uint32_t *j = (uint32_t*) &v;
         *j = PA_UINT32_SWAP(*j);
-        v = PA_CLAMP_UNLIKELY(v, -1, 1);
+        v = PA_CLAMP_UNLIKELY(v, -1.0f, 1.0f);
         s = (int16_t) (v * 0x7FFF);
         *(b++) = INT16_TO(s);
     }
@@ -196,7 +196,7 @@ void pa_sconv_s32le_from_float32re(unsigned n, const float *a, int32_t *b) {
         float v = *(a++);
         uint32_t *j = (uint32_t*) &v;
         *j = PA_UINT32_SWAP(*j);
-        v = PA_CLAMP_UNLIKELY(v, -1, 1);
+        v = PA_CLAMP_UNLIKELY(v, -1.0f, 1.0f);
         s = (int32_t) ((double) v * 0x7FFFFFFF);
         *(b++) = INT32_TO(s);
     }
@@ -219,7 +219,7 @@ void pa_sconv_s32le_to_s16re(unsigned n, const int32_t*a, int16_t *b) {
 
     for (; n > 0; n--) {
         int16_t s = (int16_t) (INT32_FROM(*a) >> 16);
-        *b = PA_UINT32_SWAP(s);
+        *b = PA_INT16_SWAP(s);
         a++;
         b++;
     }
@@ -241,7 +241,7 @@ void pa_sconv_s32le_from_s16re(unsigned n, const int16_t *a, int32_t *b) {
     pa_assert(b);
 
     for (; n > 0; n--) {
-        int32_t s = ((int32_t) PA_UINT16_SWAP(*a)) << 16;
+        int32_t s = ((int32_t) PA_INT16_SWAP(*a)) << 16;
         *b = INT32_TO(s);
         a++;
         b++;
diff --git a/src/pulsecore/sconv.c b/src/pulsecore/sconv.c
index 581e4681..733a46ae 100644
--- a/src/pulsecore/sconv.c
+++ b/src/pulsecore/sconv.c
@@ -46,7 +46,7 @@ static void u8_to_float32ne(unsigned n, const uint8_t *a, float *b) {
     pa_assert(a);
     pa_assert(b);
 
-    oil_scaleconv_f32_u8(b, a, n, &add, &factor);
+    oil_scaleconv_f32_u8(b, a, (int) n, &add, &factor);
 }
 
 static void u8_from_float32ne(unsigned n, const float *a, uint8_t *b) {
@@ -55,7 +55,7 @@ static void u8_from_float32ne(unsigned n, const float *a, uint8_t *b) {
     pa_assert(a);
     pa_assert(b);
 
-    oil_scaleconv_u8_f32(b, a, n, &add, &factor);
+    oil_scaleconv_u8_f32(b, a, (int) n, &add, &factor);
 }
 
 static void u8_to_s16ne(unsigned n, const uint8_t *a, int16_t *b) {
@@ -64,9 +64,9 @@ static void u8_to_s16ne(unsigned n, const uint8_t *a, int16_t *b) {
     pa_assert(a);
     pa_assert(b);
 
-    oil_conv_s16_u8(b, 2, a, 1, n);
-    oil_scalaradd_s16(b, 2, b, 2, &add, n);
-    oil_scalarmult_s16(b, 2, b, 2, &factor, n);
+    oil_conv_s16_u8(b, 2, a, 1, (int) n);
+    oil_scalaradd_s16(b, 2, b, 2, &add, (int) n);
+    oil_scalarmult_s16(b, 2, b, 2, &factor, (int) n);
 }
 
 static void u8_from_s16ne(unsigned n, const int16_t *a, uint8_t *b) {
@@ -84,7 +84,7 @@ static void float32ne_to_float32ne(unsigned n, const float *a, float *b) {
     pa_assert(a);
     pa_assert(b);
 
-    oil_memcpy(b, a, sizeof(float) * n);
+    oil_memcpy(b, a, (int) (sizeof(float) * n));
 }
 
 static void float32re_to_float32ne(unsigned n, const float *a, float *b) {
@@ -101,7 +101,7 @@ static void s16ne_to_s16ne(unsigned n, const int16_t *a, int16_t *b) {
     pa_assert(a);
     pa_assert(b);
 
-    oil_memcpy(b, a, sizeof(int16_t) * n);
+    oil_memcpy(b, a, (int) (sizeof(int16_t) * n));
 }
 
 static void s16re_to_s16ne(unsigned n, const int16_t *a, int16_t *b) {
@@ -109,7 +109,7 @@ static void s16re_to_s16ne(unsigned n, const int16_t *a, int16_t *b) {
     pa_assert(b);
 
     for (; n > 0; n--, a++, b++)
-        *b = PA_UINT16_SWAP(*a);
+        *b = PA_INT16_SWAP(*a);
 }
 
 /* ulaw */
@@ -128,7 +128,7 @@ static void ulaw_from_float32ne(unsigned n, const float *a, uint8_t *b) {
 
     for (; n > 0; n--) {
         float v = *(a++);
-        v = PA_CLAMP_UNLIKELY(v, -1, 1);
+        v = PA_CLAMP_UNLIKELY(v, -1.0f, 1.0f);
         v *= 0x1FFF;
         *(b++) = st_14linear2ulaw((int16_t) v);
     }
@@ -166,7 +166,7 @@ static void alaw_from_float32ne(unsigned n, const float *a, uint8_t *b) {
 
     for (; n > 0; n--, a++, b++) {
         float v = *a;
-        v = PA_CLAMP_UNLIKELY(v, -1, 1);
+        v = PA_CLAMP_UNLIKELY(v, -1.0f, 1.0f);
         v *= 0xFFF;
         *b = st_13linear2alaw((int16_t) v);
     }
@@ -177,7 +177,7 @@ static void alaw_to_s16ne(unsigned n, const int8_t *a, int16_t *b) {
     pa_assert(b);
 
     for (; n > 0; n--, a++, b++)
-        *b = st_alaw2linear16(*a);
+        *b = st_alaw2linear16((uint8_t) *a);
 }
 
 static void alaw_from_s16ne(unsigned n, const int16_t *a, uint8_t *b) {
diff --git a/src/pulsecore/shm.c b/src/pulsecore/shm.c
index 298bf716..b0870202 100644
--- a/src/pulsecore/shm.c
+++ b/src/pulsecore/shm.c
@@ -138,7 +138,7 @@ int pa_shm_create_rw(pa_shm *m, size_t size, pa_bool_t shared, mode_t mode) {
 
         m->size = size + PA_ALIGN(sizeof(struct shm_marker));
 
-        if (ftruncate(fd, m->size) < 0) {
+        if (ftruncate(fd, (off_t) m->size) < 0) {
             pa_log("ftruncate() failed: %s", pa_cstrerror(errno));
             goto fail;
         }
@@ -235,7 +235,7 @@ void pa_shm_punch(pa_shm *m, size_t offset, size_t size) {
 
     /* Align this to multiples of the page size */
     ptr = (uint8_t*) m->ptr + offset;
-    o = (uint8_t*) ptr - (uint8_t*) PA_PAGE_ALIGN_PTR(ptr);
+    o = (size_t) ((uint8_t*) ptr - (uint8_t*) PA_PAGE_ALIGN_PTR(ptr));
 
     if (o > 0) {
         ps = PA_PAGE_SIZE;
@@ -289,7 +289,7 @@ int pa_shm_attach_ro(pa_shm *m, unsigned id) {
         goto fail;
     }
 
-    m->size = st.st_size;
+    m->size = (size_t) st.st_size;
 
     if ((m->ptr = mmap(NULL, m->size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
         pa_log("mmap() failed: %s", pa_cstrerror(errno));
diff --git a/src/pulsecore/sink-input.c b/src/pulsecore/sink-input.c
index 64a6cdf9..f4e803d0 100644
--- a/src/pulsecore/sink-input.c
+++ b/src/pulsecore/sink-input.c
@@ -535,7 +535,7 @@ int pa_sink_input_peek(pa_sink_input *i, size_t slength /* in sink frames */, pa
              * data, so let's just hand out silence */
             pa_atomic_store(&i->thread_info.drained, 1);
 
-            pa_memblockq_seek(i->thread_info.render_memblockq, slength, PA_SEEK_RELATIVE);
+            pa_memblockq_seek(i->thread_info.render_memblockq, (int64_t) slength, PA_SEEK_RELATIVE);
             i->thread_info.playing_for = 0;
             if (i->thread_info.underrun_for != (uint64_t) -1)
                 i->thread_info.underrun_for += ilength;
diff --git a/src/pulsecore/socket-client.c b/src/pulsecore/socket-client.c
index 7be0e242..3bde40d0 100644
--- a/src/pulsecore/socket-client.c
+++ b/src/pulsecore/socket-client.c
@@ -283,7 +283,7 @@ static int sockaddr_prepare(pa_socket_client *c, const struct sockaddr *sa, size
     else
         pa_make_socket_low_delay(c->fd);
 
-    if (do_connect(c, sa, salen) < 0)
+    if (do_connect(c, sa, (socklen_t) salen) < 0)
         return -1;
 
     return 0;
diff --git a/src/pulsecore/socket-server.c b/src/pulsecore/socket-server.c
index 9885a02b..a600e0a6 100644
--- a/src/pulsecore/socket-server.c
+++ b/src/pulsecore/socket-server.c
@@ -199,7 +199,7 @@ pa_socket_server* pa_socket_server_new_unix(pa_mainloop_api *m, const char *file
 
     pa_make_socket_low_delay(fd);
 
-    if (bind(fd, (struct sockaddr*) &sa, SUN_LEN(&sa)) < 0) {
+    if (bind(fd, (struct sockaddr*) &sa, (socklen_t) SUN_LEN(&sa)) < 0) {
         pa_log("bind(): %s", pa_cstrerror(errno));
         goto fail;
     }
diff --git a/src/pulsecore/sound-file-stream.c b/src/pulsecore/sound-file-stream.c
index 8b2a29b9..c30c16eb 100644
--- a/src/pulsecore/sound-file-stream.c
+++ b/src/pulsecore/sound-file-stream.c
@@ -170,10 +170,10 @@ static int sink_input_pop_cb(pa_sink_input *i, size_t length, pa_memchunk *chunk
 
         if (u->readf_function) {
             fs = pa_frame_size(&i->sample_spec);
-            n = u->readf_function(u->sndfile, p, length/fs);
+            n = u->readf_function(u->sndfile, p, (sf_count_t) (length/fs));
         } else {
             fs = 1;
-            n = sf_read_raw(u->sndfile, p, length);
+            n = sf_read_raw(u->sndfile, p, (sf_count_t) length);
         }
 
         pa_memblock_release(tchunk.memblock);
@@ -186,7 +186,7 @@ static int sink_input_pop_cb(pa_sink_input *i, size_t length, pa_memchunk *chunk
             break;
         }
 
-        tchunk.length = n * fs;
+        tchunk.length = (size_t) n * fs;
 
         pa_memblockq_push(u->memblockq, &tchunk);
         pa_memblock_unref(tchunk.memblock);
@@ -310,8 +310,8 @@ int pa_play_file(
             break;
     }
 
-    ss.rate = sfinfo.samplerate;
-    ss.channels = sfinfo.channels;
+    ss.rate = (uint32_t) sfinfo.samplerate;
+    ss.channels = (uint8_t) sfinfo.channels;
 
     if (!pa_sample_spec_valid(&ss)) {
         pa_log("Unsupported sample format in file %s", fname);
diff --git a/src/pulsecore/sound-file.c b/src/pulsecore/sound-file.c
index 3183ede6..74338f9a 100644
--- a/src/pulsecore/sound-file.c
+++ b/src/pulsecore/sound-file.c
@@ -108,8 +108,8 @@ int pa_sound_file_load(
             break;
     }
 
-    ss->rate = sfinfo.samplerate;
-    ss->channels = sfinfo.channels;
+    ss->rate = (uint32_t) sfinfo.samplerate;
+    ss->channels = (uint8_t) sfinfo.channels;
 
     if (!pa_sample_spec_valid(ss)) {
         pa_log("Unsupported sample format in file %s", fname);
@@ -119,7 +119,7 @@ int pa_sound_file_load(
     if (map)
         pa_channel_map_init_extend(map, ss->channels, PA_CHANNEL_MAP_DEFAULT);
 
-    if ((l = pa_frame_size(ss) * sfinfo.frames) > PA_SCACHE_ENTRY_SIZE_MAX) {
+    if ((l = pa_frame_size(ss) * (size_t) sfinfo.frames) > PA_SCACHE_ENTRY_SIZE_MAX) {
         pa_log("File too large");
         goto finish;
     }
@@ -131,7 +131,7 @@ int pa_sound_file_load(
     ptr = pa_memblock_acquire(chunk->memblock);
 
     if ((readf_function && readf_function(sf, ptr, sfinfo.frames) != sfinfo.frames) ||
-        (!readf_function && sf_read_raw(sf, ptr, l) != (sf_count_t) l)) {
+        (!readf_function && sf_read_raw(sf, ptr, (sf_count_t) l) != (sf_count_t) l)) {
         pa_log("Premature file end");
         goto finish;
     }
@@ -189,15 +189,15 @@ int pa_sound_file_too_big_to_cache(const char *fname) {
             break;
     }
 
-    ss.rate = sfinfo.samplerate;
-    ss.channels = sfinfo.channels;
+    ss.rate = (uint32_t) sfinfo.samplerate;
+    ss.channels = (uint8_t) sfinfo.channels;
 
     if (!pa_sample_spec_valid(&ss)) {
         pa_log("Unsupported sample format in file %s", fname);
         return -1;
     }
 
-    if ((pa_frame_size(&ss) * sfinfo.frames) > PA_SCACHE_ENTRY_SIZE_MAX) {
+    if ((pa_frame_size(&ss) * (size_t) sfinfo.frames) > PA_SCACHE_ENTRY_SIZE_MAX) {
         pa_log("File too large: %s", fname);
         return 1;
     }
diff --git a/src/pulsecore/source-output.c b/src/pulsecore/source-output.c
index dbf3af94..4257154e 100644
--- a/src/pulsecore/source-output.c
+++ b/src/pulsecore/source-output.c
@@ -397,7 +397,7 @@ void pa_source_output_push(pa_source_output *o, const pa_memchunk *chunk) {
 
     if (pa_memblockq_push(o->thread_info.delay_memblockq, chunk) < 0) {
         pa_log_debug("Delay queue overflow!");
-        pa_memblockq_seek(o->thread_info.delay_memblockq, chunk->length, PA_SEEK_RELATIVE);
+        pa_memblockq_seek(o->thread_info.delay_memblockq, (int64_t) chunk->length, PA_SEEK_RELATIVE);
     }
 
     limit = o->process_rewind ? 0 : o->source->thread_info.max_rewind;
diff --git a/src/pulsecore/strbuf.c b/src/pulsecore/strbuf.c
index b59b6f49..540faef9 100644
--- a/src/pulsecore/strbuf.c
+++ b/src/pulsecore/strbuf.c
@@ -77,7 +77,7 @@ char *pa_strbuf_tostring(pa_strbuf *sb) {
 
     pa_assert(sb);
 
-    e = t = pa_xnew(char, sb->length+1);
+    e = t = pa_xmalloc(sb->length+1);
 
     for (c = sb->head; c; c = c->next) {
         pa_assert((size_t) (e-t) <= sb->length);
@@ -150,8 +150,8 @@ void pa_strbuf_putsn(pa_strbuf *sb, const char *t, size_t l) {
 
 /* Append a printf() style formatted string to the string buffer. */
 /* The following is based on an example from the GNU libc documentation */
-int pa_strbuf_printf(pa_strbuf *sb, const char *format, ...) {
-    int size = 100;
+size_t pa_strbuf_printf(pa_strbuf *sb, const char *format, ...) {
+    size_t size = 100;
     struct chunk *c = NULL;
 
     pa_assert(sb);
@@ -168,14 +168,14 @@ int pa_strbuf_printf(pa_strbuf *sb, const char *format, ...) {
         CHUNK_TO_TEXT(c)[size-1] = 0;
         va_end(ap);
 
-        if (r > -1 && r < size) {
-            c->length = r;
+        if (r > -1 && (size_t) r < size) {
+            c->length = (size_t) r;
             append(sb, c);
-            return r;
+            return (size_t) r;
         }
 
         if (r > -1)    /* glibc 2.1 */
-            size = r+1;
+            size = (size_t) r+1;
         else           /* glibc 2.0 */
             size *= 2;
     }
diff --git a/src/pulsecore/strbuf.h b/src/pulsecore/strbuf.h
index 24c876d5..ac68d7be 100644
--- a/src/pulsecore/strbuf.h
+++ b/src/pulsecore/strbuf.h
@@ -31,7 +31,7 @@ void pa_strbuf_free(pa_strbuf *sb);
 char *pa_strbuf_tostring(pa_strbuf *sb);
 char *pa_strbuf_tostring_free(pa_strbuf *sb);
 
-int pa_strbuf_printf(pa_strbuf *sb, const char *format, ...)  PA_GCC_PRINTF_ATTR(2,3);
+size_t pa_strbuf_printf(pa_strbuf *sb, const char *format, ...)  PA_GCC_PRINTF_ATTR(2,3);
 void pa_strbuf_puts(pa_strbuf *sb, const char *t);
 void pa_strbuf_putsn(pa_strbuf *sb, const char *t, size_t m);
 
diff --git a/src/pulsecore/tagstruct.c b/src/pulsecore/tagstruct.c
index b0ed59ef..e5b228e9 100644
--- a/src/pulsecore/tagstruct.c
+++ b/src/pulsecore/tagstruct.c
@@ -154,7 +154,7 @@ void pa_tagstruct_put_arbitrary(pa_tagstruct *t, const void *p, size_t length) {
 
     extend(t, 5+length);
     t->data[t->length] = PA_TAG_ARBITRARY;
-    tmp = htonl(length);
+    tmp = htonl((uint32_t) length);
     memcpy(t->data+t->length+1, &tmp, 4);
     if (length)
         memcpy(t->data+t->length+5, p, length);
@@ -165,7 +165,7 @@ void pa_tagstruct_put_boolean(pa_tagstruct*t, pa_bool_t b) {
     pa_assert(t);
 
     extend(t, 1);
-    t->data[t->length] = b ? PA_TAG_BOOLEAN_TRUE : PA_TAG_BOOLEAN_FALSE;
+    t->data[t->length] = (uint8_t) (b ? PA_TAG_BOOLEAN_TRUE : PA_TAG_BOOLEAN_FALSE);
     t->length += 1;
 }
 
@@ -175,9 +175,9 @@ void pa_tagstruct_put_timeval(pa_tagstruct*t, const struct timeval *tv) {
 
     extend(t, 9);
     t->data[t->length] = PA_TAG_TIMEVAL;
-    tmp = htonl(tv->tv_sec);
+    tmp = htonl((uint32_t) tv->tv_sec);
     memcpy(t->data+t->length+1, &tmp, 4);
-    tmp = htonl(tv->tv_usec);
+    tmp = htonl((uint32_t) tv->tv_usec);
     memcpy(t->data+t->length+5, &tmp, 4);
     t->length += 9;
 }
@@ -228,7 +228,7 @@ void pa_tagstruct_put_channel_map(pa_tagstruct *t, const pa_channel_map *map) {
     unsigned i;
 
     pa_assert(t);
-    extend(t, 2 + map->channels);
+    extend(t, 2 + (size_t) map->channels);
 
     t->data[t->length++] = PA_TAG_CHANNEL_MAP;
     t->data[t->length++] = map->channels;
@@ -435,9 +435,9 @@ int pa_tagstruct_get_timeval(pa_tagstruct*t, struct timeval *tv) {
         return -1;
 
     memcpy(&tv->tv_sec, t->data+t->rindex+1, 4);
-    tv->tv_sec = ntohl(tv->tv_sec);
+    tv->tv_sec = ntohl((uint32_t) tv->tv_sec);
     memcpy(&tv->tv_usec, t->data+t->rindex+5, 4);
-    tv->tv_usec = ntohl(tv->tv_usec);
+    tv->tv_usec = ntohl((uint32_t) tv->tv_usec);
     t->rindex += 9;
     return 0;
 }
@@ -523,7 +523,7 @@ int pa_tagstruct_get_channel_map(pa_tagstruct *t, pa_channel_map *map) {
     for (i = 0; i < map->channels; i ++)
         map->map[i] = (int8_t) t->data[t->rindex + 2 + i];
 
-    t->rindex += 2 + map->channels;
+    t->rindex += 2 + (size_t) map->channels;
     return 0;
 }
 
diff --git a/src/pulsecore/time-smoother.c b/src/pulsecore/time-smoother.c
index d0231486..b165f4a8 100644
--- a/src/pulsecore/time-smoother.c
+++ b/src/pulsecore/time-smoother.c
@@ -209,8 +209,8 @@ static double avg_gradient(pa_smoother *s, pa_usec_t x) {
     i = s->history_idx;
     for (j = s->n_history; j > 0; j--) {
 
-        ax += s->history_x[i];
-        ay += s->history_y[i];
+        ax += (int64_t) s->history_x[i];
+        ay += (int64_t) s->history_y[i];
         c++;
 
         REDUCE_INC(i);
@@ -236,7 +236,7 @@ static double avg_gradient(pa_smoother *s, pa_usec_t x) {
         REDUCE_INC(i);
     }
 
-    r = (double) k / t;
+    r = (double) k / (double) t;
 
     return (s->monotonic && r < 0) ? 0 : r;
 }
@@ -268,8 +268,8 @@ static void calc_abc(pa_smoother *s) {
 
     /* Calculate a, b, c for y=ax^3+bx^2+cx */
     s->c = de;
-    s->b = (((double) (3*ky)/kx - dp - 2*de)) / kx;
-    s->a = (dp/kx - 2*s->b - de/kx) / (3*kx);
+    s->b = (((double) (3*ky)/ (double) kx - dp - (double) (2*de))) / (double) kx;
+    s->a = (dp/(double) kx - 2*s->b - de/(double) kx) / (double) (3*kx);
 
     s->abc_valid = TRUE;
 }
@@ -284,7 +284,7 @@ static void estimate(pa_smoother *s, pa_usec_t x, pa_usec_t *y, double *deriv) {
         /* The requested point is right of the point where we wanted
          * to be on track again, thus just linearly estimate */
 
-        t = (int64_t) s->py + (int64_t) (s->dp * (x - s->px));
+        t = (int64_t) s->py + (int64_t) (s->dp * (double) (x - s->px));
 
         if (t < 0)
             t = 0;
@@ -360,7 +360,7 @@ void pa_smoother_put(pa_smoother *s, pa_usec_t x, pa_usec_t y) {
 
     /* And calculate when we want to be on track again */
     s->px = s->ex + s->adjust_time;
-    s->py = s->ry + s->dp *s->adjust_time;
+    s->py = s->ry + (pa_usec_t) (s->dp * (double) s->adjust_time);
 
     s->abc_valid = FALSE;
 
diff --git a/src/pulsecore/x11prop.c b/src/pulsecore/x11prop.c
index 9e75f63a..7f91ba3c 100644
--- a/src/pulsecore/x11prop.c
+++ b/src/pulsecore/x11prop.c
@@ -32,7 +32,7 @@
 
 void pa_x11_set_prop(Display *d, const char *name, const char *data) {
     Atom a = XInternAtom(d, name, False);
-    XChangeProperty(d, RootWindow(d, 0), a, XA_STRING, 8, PropModeReplace, (const unsigned char*) data, strlen(data)+1);
+    XChangeProperty(d, RootWindow(d, 0), a, XA_STRING, 8, PropModeReplace, (const unsigned char*) data, (int) (strlen(data)+1));
 }
 
 void pa_x11_del_prop(Display *d, const char *name) {
@@ -49,7 +49,7 @@ char* pa_x11_get_prop(Display *d, const char *name, char *p, size_t l) {
     char *ret = NULL;
 
     Atom a = XInternAtom(d, name, False);
-    if (XGetWindowProperty(d, RootWindow(d, 0), a, 0, (l+2)/4, False, XA_STRING, &actual_type, &actual_format, &nitems, &nbytes_after, &prop) != Success)
+    if (XGetWindowProperty(d, RootWindow(d, 0), a, 0, (long) ((l+2)/4), False, XA_STRING, &actual_type, &actual_format, &nitems, &nbytes_after, &prop) != Success)
         goto finish;
 
     if (actual_type != XA_STRING)
diff --git a/src/tests/envelope-test.c b/src/tests/envelope-test.c
index 9f914553..d71eff1c 100644
--- a/src/tests/envelope-test.c
+++ b/src/tests/envelope-test.c
@@ -40,7 +40,7 @@ const pa_envelope_def ramp_down = {
     .n_points = 2,
     .points_x = { 100*PA_USEC_PER_MSEC, 300*PA_USEC_PER_MSEC },
     .points_y = {
-        .f = { 1.0, 0.2 },
+        .f = { 1.0f, 0.2f },
         .i = { 0x10000, 0x10000/5 }
     }
 };
@@ -49,7 +49,7 @@ const pa_envelope_def ramp_up = {
     .n_points = 2,
     .points_x = { 100*PA_USEC_PER_MSEC, 300*PA_USEC_PER_MSEC },
     .points_y = {
-        .f = { 0.2, 1.0 },
+        .f = { 0.2f, 1.0f },
         .i = { 0x10000/5, 0x10000 }
     }
 };
@@ -58,7 +58,7 @@ const pa_envelope_def ramp_down2 = {
     .n_points = 2,
     .points_x = { 50*PA_USEC_PER_MSEC, 900*PA_USEC_PER_MSEC },
     .points_y = {
-        .f = { 0.8, 0.7 },
+        .f = { 0.8f, 0.7f },
         .i = { 0x10000*4/5, 0x10000*7/10 }
     }
 };
@@ -67,7 +67,7 @@ const pa_envelope_def ramp_up2 = {
     .n_points = 2,
     .points_x = { 50*PA_USEC_PER_MSEC, 900*PA_USEC_PER_MSEC },
     .points_y = {
-        .f = { 0.7, 0.9 },
+        .f = { 0.7f, 0.9f },
         .i = { 0x10000*7/10, 0x10000*9/10 }
     }
 };
@@ -140,7 +140,7 @@ static pa_memblock * generate_block(pa_mempool *pool, const pa_sample_spec *ss)
     unsigned n_samples;
 
     block = pa_memblock_new(pool, pa_bytes_per_second(ss));
-    n_samples = pa_memblock_get_length(block) / pa_sample_size(ss);
+    n_samples = (unsigned) (pa_memblock_get_length(block) / pa_sample_size(ss));
 
     d = pa_memblock_acquire(block);
 
@@ -171,7 +171,7 @@ static pa_memblock * generate_block(pa_mempool *pool, const pa_sample_spec *ss)
             float *f;
 
             for (f = d; n_samples > 0; n_samples--, f++)
-                *f = PA_MAYBE_FLOAT32_SWAP(ss->format == PA_SAMPLE_FLOAT32RE, 1.0);
+                *f = PA_MAYBE_FLOAT32_SWAP(ss->format == PA_SAMPLE_FLOAT32RE, 1.0f);
 
             break;
         }
diff --git a/src/tests/mcalign-test.c b/src/tests/mcalign-test.c
index e23f098c..c0665822 100644
--- a/src/tests/mcalign-test.c
+++ b/src/tests/mcalign-test.c
@@ -47,7 +47,7 @@ int main(int argc, char *argv[]) {
 
     pa_memchunk_reset(&c);
 
-    srand(time(NULL));
+    srand((unsigned) time(NULL));
 
     for (;;) {
         ssize_t r;
@@ -62,7 +62,7 @@ int main(int argc, char *argv[]) {
 
         l = pa_memblock_get_length(c.memblock) - c.index;
 
-        l = l <= 1 ? l : rand() % (l-1) +1 ;
+        l = l <= 1 ? l : (size_t) rand() % (l-1) +1;
 
         p = pa_memblock_acquire(c.memblock);
 
@@ -74,11 +74,11 @@ int main(int argc, char *argv[]) {
 
         pa_memblock_release(c.memblock);
 
-        c.length = r;
+        c.length = (size_t) r;
         pa_mcalign_push(a, &c);
         fprintf(stderr, "Read %ld bytes\n", (long)r);
 
-        c.index += r;
+        c.index += (size_t) r;
 
         if (c.index >= pa_memblock_get_length(c.memblock)) {
             pa_memblock_unref(c.memblock);
diff --git a/src/tests/mix-test.c b/src/tests/mix-test.c
index f3f6f829..544121fd 100644
--- a/src/tests/mix-test.c
+++ b/src/tests/mix-test.c
@@ -166,16 +166,16 @@ static pa_memblock* generate_block(pa_mempool *pool, const pa_sample_spec *ss) {
         case PA_SAMPLE_FLOAT32RE: {
             float *u = d;
 
-            u[0] = 0.0;
-            u[1] = -1.0;
-            u[2] = 1.0;
-            u[3] = 4711;
-            u[4] = 0.222;
-            u[5] = 0.33;
-            u[6] = -.3;
-            u[7] = 99;
-            u[8] = -0.555;
-            u[9] = -.123;
+            u[0] = 0.0f;
+            u[1] = -1.0f;
+            u[2] = 1.0f;
+            u[3] = 4711.0f;
+            u[4] = 0.222f;
+            u[5] = 0.33f;
+            u[6] = -.3f;
+            u[7] = 99.0f;
+            u[8] = -0.555f;
+            u[9] = -.123f;
 
             if (ss->format == PA_SAMPLE_FLOAT32RE)
                 for (i = 0; i < 10; i++)
diff --git a/src/tests/pacat-simple.c b/src/tests/pacat-simple.c
index ed54f57d..ffe3176a 100644
--- a/src/tests/pacat-simple.c
+++ b/src/tests/pacat-simple.c
@@ -94,7 +94,7 @@ int main(int argc, char*argv[]) {
         }
 
         /* ... and play it */
-        if (pa_simple_write(s, buf, r, &error) < 0) {
+        if (pa_simple_write(s, buf, (size_t) r, &error) < 0) {
             fprintf(stderr, __FILE__": pa_simple_write() failed: %s\n", pa_strerror(error));
             goto finish;
         }
diff --git a/src/tests/parec-simple.c b/src/tests/parec-simple.c
index ea34a075..0312005d 100644
--- a/src/tests/parec-simple.c
+++ b/src/tests/parec-simple.c
@@ -47,7 +47,7 @@ static ssize_t loop_write(int fd, const void*data, size_t size) {
 
         ret += r;
         data = (const uint8_t*) data + r;
-        size -= r;
+        size -= (size_t) r;
     }
 
     return ret;
@@ -80,6 +80,9 @@ int main(int argc, char*argv[]) {
             goto finish;
         }
 
+        if (r == 0)
+            break;
+
         /* And write it to STDOUT */
         if ((r = loop_write(STDOUT_FILENO, buf, sizeof(buf))) <= 0) {
             fprintf(stderr, __FILE__": write() failed: %s\n", strerror(errno));
diff --git a/src/tests/resampler-test.c b/src/tests/resampler-test.c
index 1a20be2c..6959127b 100644
--- a/src/tests/resampler-test.c
+++ b/src/tests/resampler-test.c
@@ -166,16 +166,16 @@ static pa_memblock* generate_block(pa_mempool *pool, const pa_sample_spec *ss) {
         case PA_SAMPLE_FLOAT32RE: {
             float *u = d;
 
-            u[0] = 0.0;
-            u[1] = -1.0;
-            u[2] = 1.0;
-            u[3] = 4711;
-            u[4] = 0.222;
-            u[5] = 0.33;
-            u[6] = -.3;
-            u[7] = 99;
-            u[8] = -0.555;
-            u[9] = -.123;
+            u[0] = 0.0f;
+            u[1] = -1.0f;
+            u[2] = 1.0f;
+            u[3] = 4711.0f;
+            u[4] = 0.222f;
+            u[5] = 0.33f;
+            u[6] = -.3f;
+            u[7] = 99.0f;
+            u[8] = -0.555f;
+            u[9] = -.123f;
 
             if (ss->format == PA_SAMPLE_FLOAT32RE)
                 for (i = 0; i < 10; i++)
diff --git a/src/tests/rtstutter.c b/src/tests/rtstutter.c
index 91e85c36..6b0cb8f7 100644
--- a/src/tests/rtstutter.c
+++ b/src/tests/rtstutter.c
@@ -52,7 +52,7 @@ static void* work(void *p) {
     pa_assert_se(pthread_setschedparam(pthread_self(), SCHED_FIFO, &param) == 0);
 
     CPU_ZERO(&mask);
-    CPU_SET(PA_PTR_TO_INT(p), &mask);
+    CPU_SET((size_t) PA_PTR_TO_INT(p), &mask);
     pa_assert_se(pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) == 0);
 
     for (;;) {
@@ -65,17 +65,17 @@ static void* work(void *p) {
         pa_assert_se(clock_gettime(CLOCK_REALTIME, &end) == 0);
 
         nsec =
-            (uint64_t) ((((double) rand())*(msec_upper-msec_lower)*PA_NSEC_PER_MSEC)/RAND_MAX) +
-            (uint64_t) (msec_lower*PA_NSEC_PER_MSEC);
+            (uint64_t) ((((double) rand())*(double)(msec_upper-msec_lower)*PA_NSEC_PER_MSEC)/RAND_MAX) +
+            (uint64_t) ((uint64_t) msec_lower*PA_NSEC_PER_MSEC);
 
         pa_log_notice("CPU%i: Freezing for %ims", PA_PTR_TO_INT(p), (int) (nsec/PA_NSEC_PER_MSEC));
 
-        end.tv_sec += nsec / PA_NSEC_PER_SEC;
-        end.tv_nsec += nsec % PA_NSEC_PER_SEC;
+        end.tv_sec += (time_t) (nsec / PA_NSEC_PER_SEC);
+        end.tv_nsec += (long int) (nsec % PA_NSEC_PER_SEC);
 
         while ((pa_usec_t) end.tv_nsec > PA_NSEC_PER_SEC) {
             end.tv_sec++;
-            end.tv_nsec -= PA_NSEC_PER_SEC;
+            end.tv_nsec -= (long int) PA_NSEC_PER_SEC;
         }
 
         do {
@@ -88,7 +88,7 @@ static void* work(void *p) {
 int main(int argc, char*argv[]) {
     int n;
 
-    srand(time(NULL));
+    srand((unsigned) time(NULL));
 
     if (argc >= 3) {
         msec_lower = atoi(argv[1]);
diff --git a/src/tests/smoother-test.c b/src/tests/smoother-test.c
index b78f3c91..15700ec2 100644
--- a/src/tests/smoother-test.c
+++ b/src/tests/smoother-test.c
@@ -64,7 +64,7 @@ int main(int argc, char*argv[]) {
     for (x = 0, u = 0; x < PA_USEC_PER_SEC * 10; x += PA_USEC_PER_MSEC) {
 
         while (u < PA_ELEMENTSOF(msec) && (pa_usec_t) msec[u]*PA_USEC_PER_MSEC < x) {
-            pa_smoother_put(s, msec[u]*PA_USEC_PER_MSEC, msec[u+1]*PA_USEC_PER_MSEC);
+            pa_smoother_put(s, (pa_usec_t) msec[u] * PA_USEC_PER_MSEC, (pa_usec_t) msec[u+1] * PA_USEC_PER_MSEC);
             printf("%i\t\t%i\n", msec[u],  msec[u+1]);
             u += 2;
         }
diff --git a/src/tests/stripnul.c b/src/tests/stripnul.c
index 0ab06776..2b8aa083 100644
--- a/src/tests/stripnul.c
+++ b/src/tests/stripnul.c
@@ -35,7 +35,7 @@ int main(int argc, char *argv[]) {
     uint8_t *zero;
 
     pa_assert_se(argc >= 2);
-    pa_assert_se((granularity = atoi(argv[1])) >= 1);
+    pa_assert_se((granularity = (size_t) atoi(argv[1])) >= 1);
     pa_assert_se((i = (argc >= 3) ? fopen(argv[2], "r") : stdin));
     pa_assert_se((o = (argc >= 4) ? fopen(argv[3], "w") : stdout));
 
@@ -53,11 +53,11 @@ int main(int argc, char *argv[]) {
         if (found)
             pa_assert_se(fwrite(buffer, granularity, k, o) == k);
         else {
-            for (p = buffer; (p-buffer)/granularity < k; p += granularity)
+            for (p = buffer; ((size_t) (p-buffer)/granularity) < k; p += granularity)
                 if (memcmp(p, zero, granularity)) {
                     size_t left;
                     found = TRUE;
-                    left = k - (p-buffer)/granularity;
+                    left = (size_t) (k - (size_t) (p-buffer)/granularity);
                     pa_assert_se(fwrite(p, granularity, left, o) == left);
                     break;
                 }
diff --git a/src/tests/sync-playback.c b/src/tests/sync-playback.c
index 7e364685..42c479a1 100644
--- a/src/tests/sync-playback.c
+++ b/src/tests/sync-playback.c
@@ -89,7 +89,7 @@ static void stream_state_callback(pa_stream *s, void *userdata) {
 
             fprintf(stderr, "Writing data to stream %i.\n", i);
 
-            r = pa_stream_write(s, data, sizeof(data), nop_free_cb, sizeof(data) * i, PA_SEEK_ABSOLUTE);
+            r = pa_stream_write(s, data, sizeof(data), nop_free_cb, (int64_t) sizeof(data) * (int64_t) i, PA_SEEK_ABSOLUTE);
             assert(r == 0);
 
             /* Be notified when this stream is drained */
diff --git a/src/utils/pacat.c b/src/utils/pacat.c
index 32fa6bcf..c1826d7b 100644
--- a/src/utils/pacat.c
+++ b/src/utils/pacat.c
@@ -274,8 +274,8 @@ static void context_state_callback(pa_context *c, void *userdata) {
 
             if (latency > 0) {
                 memset(&buffer_attr, 0, sizeof(buffer_attr));
-                buffer_attr.tlength = latency;
-                buffer_attr.minreq = process_time;
+                buffer_attr.tlength = (uint32_t) latency;
+                buffer_attr.minreq = (uint32_t) process_time;
                 buffer_attr.maxlength = (uint32_t) -1;
                 buffer_attr.prebuf = (uint32_t) -1;
                 flags |= PA_STREAM_ADJUST_LATENCY;
@@ -391,7 +391,7 @@ static void stdin_callback(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_even
         return;
     }
 
-    buffer_length = r;
+    buffer_length = (uint32_t) r;
     buffer_index = 0;
 
     if (w)
@@ -422,8 +422,8 @@ static void stdout_callback(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_eve
         return;
     }
 
-    buffer_length -= r;
-    buffer_index += r;
+    buffer_length -= (uint32_t) r;
+    buffer_index += (uint32_t) r;
 
     if (!buffer_length) {
         pa_xfree(buffer);
@@ -456,7 +456,7 @@ static void stream_update_timing_callback(pa_stream *s, int success, void *userd
 
     fprintf(stderr, _("Time: %0.3f sec; Latency: %0.0f usec.  \r"),
             (float) usec / 1000000,
-            (float) l * (negative?-1:1));
+            (float) l * (negative?-1.0f:1.0f));
 }
 
 /* Someone requested that the latency is shown */
@@ -626,12 +626,12 @@ int main(int argc, char *argv[]) {
 
             case ARG_VOLUME: {
                 int v = atoi(optarg);
-                volume = v < 0 ? 0 : v;
+                volume = v < 0 ? 0U : (pa_volume_t) v;
                 break;
             }
 
             case ARG_CHANNELS:
-                sample_spec.channels = atoi(optarg);
+                sample_spec.channels = (uint8_t) atoi(optarg);
                 break;
 
             case ARG_SAMPLEFORMAT:
@@ -639,7 +639,7 @@ int main(int argc, char *argv[]) {
                 break;
 
             case ARG_SAMPLERATE:
-                sample_spec.rate = atoi(optarg);
+                sample_spec.rate = (uint32_t) atoi(optarg);
                 break;
 
             case ARG_CHANNELMAP:
@@ -672,14 +672,14 @@ int main(int argc, char *argv[]) {
                 break;
 
             case ARG_LATENCY:
-                if (((latency = atoi(optarg))) <= 0) {
+                if (((latency = (size_t) atoi(optarg))) <= 0) {
                     fprintf(stderr, _("Invalid latency specification '%s'\n"), optarg);
                     goto quit;
                 }
                 break;
 
             case ARG_PROCESS_TIME:
-                if (((process_time = atoi(optarg))) <= 0) {
+                if (((process_time = (size_t) atoi(optarg))) <= 0) {
                     fprintf(stderr, _("Invalid process time specification '%s'\n"), optarg);
                     goto quit;
                 }
diff --git a/src/utils/pactl.c b/src/utils/pactl.c
index 3f00df1b..2f430ca7 100644
--- a/src/utils/pactl.c
+++ b/src/utils/pactl.c
@@ -555,7 +555,7 @@ static void stream_write_callback(pa_stream *s, size_t length, void *userdata) {
     d = pa_xmalloc(length);
 
     assert(sample_length >= length);
-    l = length/pa_frame_size(&sample_spec);
+    l = (sf_count_t) (length/pa_frame_size(&sample_spec));
 
     if ((sf_readf_float(sndfile, d, l)) != l) {
         pa_xfree(d);
@@ -791,11 +791,11 @@ int main(int argc, char *argv[]) {
                 goto quit;
             }
 
-            sample_spec.format =  PA_SAMPLE_FLOAT32;
-            sample_spec.rate = sfinfo.samplerate;
-            sample_spec.channels = sfinfo.channels;
+            sample_spec.format = PA_SAMPLE_FLOAT32;
+            sample_spec.rate = (uint32_t) sfinfo.samplerate;
+            sample_spec.channels = (uint8_t) sfinfo.channels;
 
-            sample_length = sfinfo.frames*pa_frame_size(&sample_spec);
+            sample_length = (size_t)sfinfo.frames*pa_frame_size(&sample_spec);
         } else if (!strcmp(argv[optind], "play-sample")) {
             action = PLAY_SAMPLE;
             if (argc != optind+2 && argc != optind+3) {
@@ -823,7 +823,7 @@ int main(int argc, char *argv[]) {
                 goto quit;
             }
 
-            sink_input_idx = atoi(argv[optind+1]);
+            sink_input_idx = (uint32_t) atoi(argv[optind+1]);
             sink_name = pa_xstrdup(argv[optind+2]);
         } else if (!strcmp(argv[optind], "move-source-output")) {
             action = MOVE_SOURCE_OUTPUT;
@@ -832,7 +832,7 @@ int main(int argc, char *argv[]) {
                 goto quit;
             }
 
-            source_output_idx = atoi(argv[optind+1]);
+            source_output_idx = (uint32_t) atoi(argv[optind+1]);
             source_name = pa_xstrdup(argv[optind+2]);
         } else if (!strcmp(argv[optind], "load-module")) {
             int i;
@@ -852,7 +852,7 @@ int main(int argc, char *argv[]) {
                 n += strlen(argv[i])+1;
 
             if (n > 0) {
-                p = module_args = pa_xnew0(char, n);
+                p = module_args = pa_xmalloc(n);
 
                 for (i = optind+2; i < argc; i++)
                     p += sprintf(p, "%s%s", p == module_args ? "" : " ", argv[i]);
@@ -866,7 +866,7 @@ int main(int argc, char *argv[]) {
                 goto quit;
             }
 
-            module_index = atoi(argv[optind+1]);
+            module_index = (uint32_t) atoi(argv[optind+1]);
 
         } else if (!strcmp(argv[optind], "suspend-sink")) {
             action = SUSPEND_SINK;
diff --git a/src/utils/padsp.c b/src/utils/padsp.c
index c82fde64..134a7e58 100644
--- a/src/utils/padsp.c
+++ b/src/utils/padsp.c
@@ -748,7 +748,7 @@ static void fix_metrics(fd_info *i) {
     /* Number of fragments set? */
     if (i->n_fragments < 2) {
         if (i->fragment_size > 0) {
-            i->n_fragments = pa_bytes_per_second(&i->sample_spec) / 2 / i->fragment_size;
+            i->n_fragments = (unsigned) (pa_bytes_per_second(&i->sample_spec) / 2 / i->fragment_size);
             if (i->n_fragments < 2)
                 i->n_fragments = 2;
         } else
@@ -864,7 +864,7 @@ static int fd_info_copy_data(fd_info *i, int force) {
                 return -1;
             }
 
-            if (pa_stream_write(i->play_stream, i->buf, r, free, 0, PA_SEEK_RELATIVE) < 0) {
+            if (pa_stream_write(i->play_stream, i->buf, (size_t) r, free, 0, PA_SEEK_RELATIVE) < 0) {
                 debug(DEBUG_LEVEL_NORMAL, __FILE__": pa_stream_write(): %s\n", pa_strerror(pa_context_errno(i->context)));
                 return -1;
             }
@@ -872,7 +872,7 @@ static int fd_info_copy_data(fd_info *i, int force) {
             i->buf = NULL;
 
             assert(n >= (size_t) r);
-            n -= r;
+            n -= (size_t) r;
         }
 
         if (n >= i->fragment_size)
@@ -916,7 +916,7 @@ static int fd_info_copy_data(fd_info *i, int force) {
             }
 
             assert((size_t)r <= len - i->rec_offset);
-            i->rec_offset += r;
+            i->rec_offset += (size_t) r;
 
             if (i->rec_offset == len) {
                 if (pa_stream_drop(i->rec_stream) < 0) {
@@ -927,7 +927,7 @@ static int fd_info_copy_data(fd_info *i, int force) {
             }
 
             assert(n >= (size_t) r);
-            n -= r;
+            n -= (size_t) r;
         }
 
         if (n >= i->fragment_size)
@@ -998,10 +998,10 @@ static int create_playback_stream(fd_info *i) {
     pa_stream_set_latency_update_callback(i->play_stream, stream_latency_update_cb, i);
 
     memset(&attr, 0, sizeof(attr));
-    attr.maxlength = i->fragment_size * (i->n_fragments+1);
-    attr.tlength = i->fragment_size * i->n_fragments;
-    attr.prebuf = i->fragment_size;
-    attr.minreq = i->fragment_size;
+    attr.maxlength = (uint32_t) (i->fragment_size * (i->n_fragments+1));
+    attr.tlength = (uint32_t) (i->fragment_size * i->n_fragments);
+    attr.prebuf = (uint32_t) i->fragment_size;
+    attr.minreq = (uint32_t) i->fragment_size;
 
     flags = PA_STREAM_INTERPOLATE_TIMING|PA_STREAM_AUTO_TIMING_UPDATE;
     if (i->play_precork) {
@@ -1013,9 +1013,9 @@ static int create_playback_stream(fd_info *i) {
         goto fail;
     }
 
-    n = i->fragment_size;
+    n = (int) i->fragment_size;
     setsockopt(i->app_fd, SOL_SOCKET, SO_SNDBUF, &n, sizeof(n));
-    n = i->fragment_size;
+    n = (int) i->fragment_size;
     setsockopt(i->thread_fd, SOL_SOCKET, SO_RCVBUF, &n, sizeof(n));
 
     return 0;
@@ -1042,8 +1042,8 @@ static int create_record_stream(fd_info *i) {
     pa_stream_set_latency_update_callback(i->rec_stream, stream_latency_update_cb, i);
 
     memset(&attr, 0, sizeof(attr));
-    attr.maxlength = i->fragment_size * (i->n_fragments+1);
-    attr.fragsize = i->fragment_size;
+    attr.maxlength = (uint32_t) (i->fragment_size * (i->n_fragments+1));
+    attr.fragsize = (uint32_t) i->fragment_size;
 
     flags = PA_STREAM_INTERPOLATE_TIMING|PA_STREAM_AUTO_TIMING_UPDATE;
     if (i->rec_precork) {
@@ -1055,9 +1055,9 @@ static int create_record_stream(fd_info *i) {
         goto fail;
     }
 
-    n = i->fragment_size;
+    n = (int) i->fragment_size;
     setsockopt(i->app_fd, SOL_SOCKET, SO_RCVBUF, &n, sizeof(n));
-    n = i->fragment_size;
+    n = (int) i->fragment_size;
     setsockopt(i->thread_fd, SOL_SOCKET, SO_SNDBUF, &n, sizeof(n));
 
     return 0;
@@ -1474,7 +1474,7 @@ int open(const char *filename, int flags, ...) {
     if (flags & O_CREAT) {
         va_start(args, flags);
         if (sizeof(mode_t) < sizeof(int))
-            mode = va_arg(args, int);
+            mode = (mode_t) va_arg(args, int);
         else
             mode = va_arg(args, mode_t);
         va_end(args);
diff --git a/src/utils/paplay.c b/src/utils/paplay.c
index 9264a940..df2edf62 100644
--- a/src/utils/paplay.c
+++ b/src/utils/paplay.c
@@ -107,14 +107,14 @@ static void stream_write_callback(pa_stream *s, size_t length, void *userdata) {
     if (readf_function) {
         size_t k = pa_frame_size(&sample_spec);
 
-        if ((bytes = readf_function(sndfile, data, length/k)) > 0)
-            bytes *= k;
+        if ((bytes = readf_function(sndfile, data, (sf_count_t) (length/k))) > 0)
+            bytes *= (sf_count_t) k;
 
     } else
-        bytes = sf_read_raw(sndfile, data, length);
+        bytes = sf_read_raw(sndfile, data, (sf_count_t) length);
 
     if (bytes > 0)
-        pa_stream_write(s, data, bytes, pa_xfree, 0, PA_SEEK_RELATIVE);
+        pa_stream_write(s, data, (size_t) bytes, pa_xfree, 0, PA_SEEK_RELATIVE);
     else
         pa_xfree(data);
 
@@ -283,7 +283,7 @@ int main(int argc, char *argv[]) {
 
             case ARG_VOLUME: {
                 int v = atoi(optarg);
-                volume = v < 0 ? 0 : v;
+                volume = v < 0 ? 0U : (pa_volume_t) v;
                 break;
             }
 
@@ -315,8 +315,8 @@ int main(int argc, char *argv[]) {
         goto quit;
     }
 
-    sample_spec.rate = sfinfo.samplerate;
-    sample_spec.channels = sfinfo.channels;
+    sample_spec.rate = (uint32_t) sfinfo.samplerate;
+    sample_spec.channels = (uint8_t) sfinfo.channels;
 
     readf_function = NULL;